(function() {
"use strict";
var wp;
(wp ||= {}).components = (() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __esm = (fn, res) => function __init() {
    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
  };
  var __commonJS = (cb, mod) => function __require() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from2, except, desc) => {
    if (from2 && typeof from2 === "object" || typeof from2 === "function") {
      for (let key of __getOwnPropNames(from2))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

  // package-external:@wordpress/primitives
  var require_primitives = __commonJS({
    "package-external:@wordpress/primitives"(exports, module) {
      module.exports = window.wp.primitives;
    }
  });

  // package-external:@wordpress/i18n
  var require_i18n = __commonJS({
    "package-external:@wordpress/i18n"(exports, module) {
      module.exports = window.wp.i18n;
    }
  });

  // package-external:@wordpress/compose
  var require_compose = __commonJS({
    "package-external:@wordpress/compose"(exports, module) {
      module.exports = window.wp.compose;
    }
  });

  // package-external:@wordpress/element
  var require_element = __commonJS({
    "package-external:@wordpress/element"(exports, module) {
      module.exports = window.wp.element;
    }
  });

  // vendor-external:react
  var require_react = __commonJS({
    "vendor-external:react"(exports, module) {
      module.exports = window.React;
    }
  });

  // vendor-external:react/jsx-runtime
  var require_jsx_runtime = __commonJS({
    "vendor-external:react/jsx-runtime"(exports, module) {
      module.exports = window.ReactJSXRuntime;
    }
  });

  // node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
  var require_use_sync_external_store_shim_development = __commonJS({
    "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
      "use strict";
      (function() {
        function is(x2, y3) {
          return x2 === y3 && (0 !== x2 || 1 / x2 === 1 / y3) || x2 !== x2 && y3 !== y3;
        }
        function useSyncExternalStore$2(subscribe2, getSnapshot) {
          didWarnOld18Alpha || void 0 === React40.startTransition || (didWarnOld18Alpha = true, console.error(
            "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
          ));
          var value = getSnapshot();
          if (!didWarnUncachedGetSnapshot) {
            var cachedValue = getSnapshot();
            objectIs(value, cachedValue) || (console.error(
              "The result of getSnapshot should be cached to avoid an infinite loop"
            ), didWarnUncachedGetSnapshot = true);
          }
          cachedValue = useState78({
            inst: { value, getSnapshot }
          });
          var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
          useLayoutEffect25(
            function() {
              inst.value = value;
              inst.getSnapshot = getSnapshot;
              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
            },
            [subscribe2, value, getSnapshot]
          );
          useEffect73(
            function() {
              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
              return subscribe2(function() {
                checkIfSnapshotChanged(inst) && forceUpdate({ inst });
              });
            },
            [subscribe2]
          );
          useDebugValue(value);
          return value;
        }
        function checkIfSnapshotChanged(inst) {
          var latestGetSnapshot = inst.getSnapshot;
          inst = inst.value;
          try {
            var nextValue = latestGetSnapshot();
            return !objectIs(inst, nextValue);
          } catch (error) {
            return true;
          }
        }
        function useSyncExternalStore$1(subscribe2, getSnapshot) {
          return getSnapshot();
        }
        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
        var React40 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState78 = React40.useState, useEffect73 = React40.useEffect, useLayoutEffect25 = React40.useLayoutEffect, useDebugValue = React40.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
        exports.useSyncExternalStore = void 0 !== React40.useSyncExternalStore ? React40.useSyncExternalStore : shim;
        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
      })();
    }
  });

  // node_modules/use-sync-external-store/shim/index.js
  var require_shim = __commonJS({
    "node_modules/use-sync-external-store/shim/index.js"(exports, module) {
      "use strict";
      if (false) {
        module.exports = null;
      } else {
        module.exports = require_use_sync_external_store_shim_development();
      }
    }
  });

  // vendor-external:react-dom
  var require_react_dom = __commonJS({
    "vendor-external:react-dom"(exports, module) {
      module.exports = window.ReactDOM;
    }
  });

  // package-external:@wordpress/deprecated
  var require_deprecated = __commonJS({
    "package-external:@wordpress/deprecated"(exports, module) {
      module.exports = window.wp.deprecated;
    }
  });

  // node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
  function memoize(fn) {
    var cache2 = /* @__PURE__ */ Object.create(null);
    return function(arg) {
      if (cache2[arg] === void 0) cache2[arg] = fn(arg);
      return cache2[arg];
    };
  }
  var init_emotion_memoize_esm = __esm({
    "node_modules/@emotion/memoize/dist/emotion-memoize.esm.js"() {
    }
  });

  // node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js
  var emotion_is_prop_valid_esm_exports = {};
  __export(emotion_is_prop_valid_esm_exports, {
    default: () => isPropValid
  });
  var reactPropsRegex, isPropValid;
  var init_emotion_is_prop_valid_esm = __esm({
    "node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js"() {
      init_emotion_memoize_esm();
      reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|popover|popoverTarget|popoverTargetAction|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/;
      isPropValid = /* @__PURE__ */ memoize(
        function(prop) {
          return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111 && prop.charCodeAt(1) === 110 && prop.charCodeAt(2) < 91;
        }
        /* Z+1 */
      );
    }
  });

  // node_modules/react-is/cjs/react-is.development.js
  var require_react_is_development = __commonJS({
    "node_modules/react-is/cjs/react-is.development.js"(exports) {
      "use strict";
      if (true) {
        (function() {
          "use strict";
          var hasSymbol = typeof Symbol === "function" && Symbol.for;
          var REACT_ELEMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
          var REACT_PORTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.portal") : 60106;
          var REACT_FRAGMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107;
          var REACT_STRICT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108;
          var REACT_PROFILER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114;
          var REACT_PROVIDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.provider") : 60109;
          var REACT_CONTEXT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.context") : 60110;
          var REACT_ASYNC_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111;
          var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111;
          var REACT_FORWARD_REF_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112;
          var REACT_SUSPENSE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113;
          var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120;
          var REACT_MEMO_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
          var REACT_LAZY_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116;
          var REACT_BLOCK_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.block") : 60121;
          var REACT_FUNDAMENTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117;
          var REACT_RESPONDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.responder") : 60118;
          var REACT_SCOPE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
          function isValidElementType(type) {
            return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
            type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
          }
          function typeOf(object) {
            if (typeof object === "object" && object !== null) {
              var $$typeof = object.$$typeof;
              switch ($$typeof) {
                case REACT_ELEMENT_TYPE:
                  var type = object.type;
                  switch (type) {
                    case REACT_ASYNC_MODE_TYPE:
                    case REACT_CONCURRENT_MODE_TYPE:
                    case REACT_FRAGMENT_TYPE:
                    case REACT_PROFILER_TYPE:
                    case REACT_STRICT_MODE_TYPE:
                    case REACT_SUSPENSE_TYPE:
                      return type;
                    default:
                      var $$typeofType = type && type.$$typeof;
                      switch ($$typeofType) {
                        case REACT_CONTEXT_TYPE:
                        case REACT_FORWARD_REF_TYPE:
                        case REACT_LAZY_TYPE:
                        case REACT_MEMO_TYPE:
                        case REACT_PROVIDER_TYPE:
                          return $$typeofType;
                        default:
                          return $$typeof;
                      }
                  }
                case REACT_PORTAL_TYPE:
                  return $$typeof;
              }
            }
            return void 0;
          }
          var AsyncMode = REACT_ASYNC_MODE_TYPE;
          var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
          var ContextConsumer = REACT_CONTEXT_TYPE;
          var ContextProvider = REACT_PROVIDER_TYPE;
          var Element2 = REACT_ELEMENT_TYPE;
          var ForwardRef = REACT_FORWARD_REF_TYPE;
          var Fragment8 = REACT_FRAGMENT_TYPE;
          var Lazy = REACT_LAZY_TYPE;
          var Memo = REACT_MEMO_TYPE;
          var Portal3 = REACT_PORTAL_TYPE;
          var Profiler = REACT_PROFILER_TYPE;
          var StrictMode = REACT_STRICT_MODE_TYPE;
          var Suspense = REACT_SUSPENSE_TYPE;
          var hasWarnedAboutDeprecatedIsAsyncMode = false;
          function isAsyncMode(object) {
            {
              if (!hasWarnedAboutDeprecatedIsAsyncMode) {
                hasWarnedAboutDeprecatedIsAsyncMode = true;
                console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
              }
            }
            return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
          }
          function isConcurrentMode(object) {
            return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
          }
          function isContextConsumer(object) {
            return typeOf(object) === REACT_CONTEXT_TYPE;
          }
          function isContextProvider(object) {
            return typeOf(object) === REACT_PROVIDER_TYPE;
          }
          function isElement3(object) {
            return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
          }
          function isForwardRef(object) {
            return typeOf(object) === REACT_FORWARD_REF_TYPE;
          }
          function isFragment(object) {
            return typeOf(object) === REACT_FRAGMENT_TYPE;
          }
          function isLazy(object) {
            return typeOf(object) === REACT_LAZY_TYPE;
          }
          function isMemo(object) {
            return typeOf(object) === REACT_MEMO_TYPE;
          }
          function isPortal(object) {
            return typeOf(object) === REACT_PORTAL_TYPE;
          }
          function isProfiler(object) {
            return typeOf(object) === REACT_PROFILER_TYPE;
          }
          function isStrictMode(object) {
            return typeOf(object) === REACT_STRICT_MODE_TYPE;
          }
          function isSuspense(object) {
            return typeOf(object) === REACT_SUSPENSE_TYPE;
          }
          exports.AsyncMode = AsyncMode;
          exports.ConcurrentMode = ConcurrentMode;
          exports.ContextConsumer = ContextConsumer;
          exports.ContextProvider = ContextProvider;
          exports.Element = Element2;
          exports.ForwardRef = ForwardRef;
          exports.Fragment = Fragment8;
          exports.Lazy = Lazy;
          exports.Memo = Memo;
          exports.Portal = Portal3;
          exports.Profiler = Profiler;
          exports.StrictMode = StrictMode;
          exports.Suspense = Suspense;
          exports.isAsyncMode = isAsyncMode;
          exports.isConcurrentMode = isConcurrentMode;
          exports.isContextConsumer = isContextConsumer;
          exports.isContextProvider = isContextProvider;
          exports.isElement = isElement3;
          exports.isForwardRef = isForwardRef;
          exports.isFragment = isFragment;
          exports.isLazy = isLazy;
          exports.isMemo = isMemo;
          exports.isPortal = isPortal;
          exports.isProfiler = isProfiler;
          exports.isStrictMode = isStrictMode;
          exports.isSuspense = isSuspense;
          exports.isValidElementType = isValidElementType;
          exports.typeOf = typeOf;
        })();
      }
    }
  });

  // node_modules/react-is/index.js
  var require_react_is = __commonJS({
    "node_modules/react-is/index.js"(exports, module) {
      "use strict";
      if (false) {
        module.exports = null;
      } else {
        module.exports = require_react_is_development();
      }
    }
  });

  // node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js
  var require_hoist_non_react_statics_cjs = __commonJS({
    "node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js"(exports, module) {
      "use strict";
      var reactIs = require_react_is();
      var REACT_STATICS = {
        childContextTypes: true,
        contextType: true,
        contextTypes: true,
        defaultProps: true,
        displayName: true,
        getDefaultProps: true,
        getDerivedStateFromError: true,
        getDerivedStateFromProps: true,
        mixins: true,
        propTypes: true,
        type: true
      };
      var KNOWN_STATICS = {
        name: true,
        length: true,
        prototype: true,
        caller: true,
        callee: true,
        arguments: true,
        arity: true
      };
      var FORWARD_REF_STATICS = {
        "$$typeof": true,
        render: true,
        defaultProps: true,
        displayName: true,
        propTypes: true
      };
      var MEMO_STATICS = {
        "$$typeof": true,
        compare: true,
        defaultProps: true,
        displayName: true,
        propTypes: true,
        type: true
      };
      var TYPE_STATICS = {};
      TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
      TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
      function getStatics(component) {
        if (reactIs.isMemo(component)) {
          return MEMO_STATICS;
        }
        return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
      }
      var defineProperty = Object.defineProperty;
      var getOwnPropertyNames = Object.getOwnPropertyNames;
      var getOwnPropertySymbols = Object.getOwnPropertySymbols;
      var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
      var getPrototypeOf = Object.getPrototypeOf;
      var objectPrototype = Object.prototype;
      function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
        if (typeof sourceComponent !== "string") {
          if (objectPrototype) {
            var inheritedComponent = getPrototypeOf(sourceComponent);
            if (inheritedComponent && inheritedComponent !== objectPrototype) {
              hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
            }
          }
          var keys = getOwnPropertyNames(sourceComponent);
          if (getOwnPropertySymbols) {
            keys = keys.concat(getOwnPropertySymbols(sourceComponent));
          }
          var targetStatics = getStatics(targetComponent);
          var sourceStatics = getStatics(sourceComponent);
          for (var i3 = 0; i3 < keys.length; ++i3) {
            var key = keys[i3];
            if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
              var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
              try {
                defineProperty(targetComponent, key, descriptor);
              } catch (e3) {
              }
            }
          }
        }
        return targetComponent;
      }
      module.exports = hoistNonReactStatics;
    }
  });

  // node_modules/deepmerge/dist/cjs.js
  var require_cjs = __commonJS({
    "node_modules/deepmerge/dist/cjs.js"(exports, module) {
      "use strict";
      var isMergeableObject = function isMergeableObject2(value) {
        return isNonNullObject(value) && !isSpecial(value);
      };
      function isNonNullObject(value) {
        return !!value && typeof value === "object";
      }
      function isSpecial(value) {
        var stringValue = Object.prototype.toString.call(value);
        return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
      }
      var canUseSymbol = typeof Symbol === "function" && Symbol.for;
      var REACT_ELEMENT_TYPE = canUseSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
      function isReactElement(value) {
        return value.$$typeof === REACT_ELEMENT_TYPE;
      }
      function emptyTarget(val) {
        return Array.isArray(val) ? [] : {};
      }
      function cloneUnlessOtherwiseSpecified(value, options2) {
        return options2.clone !== false && options2.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options2) : value;
      }
      function defaultArrayMerge(target, source, options2) {
        return target.concat(source).map(function(element) {
          return cloneUnlessOtherwiseSpecified(element, options2);
        });
      }
      function getMergeFunction(key, options2) {
        if (!options2.customMerge) {
          return deepmerge2;
        }
        var customMerge = options2.customMerge(key);
        return typeof customMerge === "function" ? customMerge : deepmerge2;
      }
      function getEnumerableOwnPropertySymbols(target) {
        return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol4) {
          return Object.propertyIsEnumerable.call(target, symbol4);
        }) : [];
      }
      function getKeys2(target) {
        return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
      }
      function propertyIsOnObject(object, property) {
        try {
          return property in object;
        } catch (_2) {
          return false;
        }
      }
      function propertyIsUnsafe(target, key) {
        return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
      }
      function mergeObject(target, source, options2) {
        var destination = {};
        if (options2.isMergeableObject(target)) {
          getKeys2(target).forEach(function(key) {
            destination[key] = cloneUnlessOtherwiseSpecified(target[key], options2);
          });
        }
        getKeys2(source).forEach(function(key) {
          if (propertyIsUnsafe(target, key)) {
            return;
          }
          if (propertyIsOnObject(target, key) && options2.isMergeableObject(source[key])) {
            destination[key] = getMergeFunction(key, options2)(target[key], source[key], options2);
          } else {
            destination[key] = cloneUnlessOtherwiseSpecified(source[key], options2);
          }
        });
        return destination;
      }
      function deepmerge2(target, source, options2) {
        options2 = options2 || {};
        options2.arrayMerge = options2.arrayMerge || defaultArrayMerge;
        options2.isMergeableObject = options2.isMergeableObject || isMergeableObject;
        options2.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
        var sourceIsArray = Array.isArray(source);
        var targetIsArray = Array.isArray(target);
        var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
        if (!sourceAndTargetTypesMatch) {
          return cloneUnlessOtherwiseSpecified(source, options2);
        } else if (sourceIsArray) {
          return options2.arrayMerge(target, source, options2);
        } else {
          return mergeObject(target, source, options2);
        }
      }
      deepmerge2.all = function deepmergeAll(array, options2) {
        if (!Array.isArray(array)) {
          throw new Error("first argument should be an array");
        }
        return array.reduce(function(prev2, next2) {
          return deepmerge2(prev2, next2, options2);
        }, {});
      };
      var deepmerge_1 = deepmerge2;
      module.exports = deepmerge_1;
    }
  });

  // node_modules/fast-deep-equal/es6/index.js
  var require_es6 = __commonJS({
    "node_modules/fast-deep-equal/es6/index.js"(exports, module) {
      "use strict";
      module.exports = function equal(a3, b3) {
        if (a3 === b3) return true;
        if (a3 && b3 && typeof a3 == "object" && typeof b3 == "object") {
          if (a3.constructor !== b3.constructor) return false;
          var length2, i3, keys;
          if (Array.isArray(a3)) {
            length2 = a3.length;
            if (length2 != b3.length) return false;
            for (i3 = length2; i3-- !== 0; )
              if (!equal(a3[i3], b3[i3])) return false;
            return true;
          }
          if (a3 instanceof Map && b3 instanceof Map) {
            if (a3.size !== b3.size) return false;
            for (i3 of a3.entries())
              if (!b3.has(i3[0])) return false;
            for (i3 of a3.entries())
              if (!equal(i3[1], b3.get(i3[0]))) return false;
            return true;
          }
          if (a3 instanceof Set && b3 instanceof Set) {
            if (a3.size !== b3.size) return false;
            for (i3 of a3.entries())
              if (!b3.has(i3[0])) return false;
            return true;
          }
          if (ArrayBuffer.isView(a3) && ArrayBuffer.isView(b3)) {
            length2 = a3.length;
            if (length2 != b3.length) return false;
            for (i3 = length2; i3-- !== 0; )
              if (a3[i3] !== b3[i3]) return false;
            return true;
          }
          if (a3.constructor === RegExp) return a3.source === b3.source && a3.flags === b3.flags;
          if (a3.valueOf !== Object.prototype.valueOf) return a3.valueOf() === b3.valueOf();
          if (a3.toString !== Object.prototype.toString) return a3.toString() === b3.toString();
          keys = Object.keys(a3);
          length2 = keys.length;
          if (length2 !== Object.keys(b3).length) return false;
          for (i3 = length2; i3-- !== 0; )
            if (!Object.prototype.hasOwnProperty.call(b3, keys[i3])) return false;
          for (i3 = length2; i3-- !== 0; ) {
            var key = keys[i3];
            if (!equal(a3[key], b3[key])) return false;
          }
          return true;
        }
        return a3 !== a3 && b3 !== b3;
      };
    }
  });

  // package-external:@wordpress/warning
  var require_warning = __commonJS({
    "package-external:@wordpress/warning"(exports, module) {
      module.exports = window.wp.warning;
    }
  });

  // node_modules/highlight-words-core/dist/index.js
  var require_dist = __commonJS({
    "node_modules/highlight-words-core/dist/index.js"(exports, module) {
      module.exports = /******/
      (function(modules) {
        var installedModules = {};
        function __webpack_require__(moduleId) {
          if (installedModules[moduleId])
            return installedModules[moduleId].exports;
          var module2 = installedModules[moduleId] = {
            /******/
            exports: {},
            /******/
            id: moduleId,
            /******/
            loaded: false
            /******/
          };
          modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__);
          module2.loaded = true;
          return module2.exports;
        }
        __webpack_require__.m = modules;
        __webpack_require__.c = installedModules;
        __webpack_require__.p = "";
        return __webpack_require__(0);
      })([
        /* 0 */
        /***/
        (function(module2, exports2, __webpack_require__) {
          module2.exports = __webpack_require__(1);
        }),
        /* 1 */
        /***/
        (function(module2, exports2, __webpack_require__) {
          "use strict";
          Object.defineProperty(exports2, "__esModule", {
            value: true
          });
          var _utils = __webpack_require__(2);
          Object.defineProperty(exports2, "combineChunks", {
            enumerable: true,
            get: function get() {
              return _utils.combineChunks;
            }
          });
          Object.defineProperty(exports2, "fillInChunks", {
            enumerable: true,
            get: function get() {
              return _utils.fillInChunks;
            }
          });
          Object.defineProperty(exports2, "findAll", {
            enumerable: true,
            get: function get() {
              return _utils.findAll;
            }
          });
          Object.defineProperty(exports2, "findChunks", {
            enumerable: true,
            get: function get() {
              return _utils.findChunks;
            }
          });
        }),
        /* 2 */
        /***/
        (function(module2, exports2) {
          "use strict";
          Object.defineProperty(exports2, "__esModule", {
            value: true
          });
          var findAll2 = exports2.findAll = function findAll3(_ref9) {
            var autoEscape = _ref9.autoEscape, _ref$caseSensitive = _ref9.caseSensitive, caseSensitive = _ref$caseSensitive === void 0 ? false : _ref$caseSensitive, _ref$findChunks = _ref9.findChunks, findChunks = _ref$findChunks === void 0 ? defaultFindChunks : _ref$findChunks, sanitize2 = _ref9.sanitize, searchWords = _ref9.searchWords, textToHighlight = _ref9.textToHighlight;
            return fillInChunks({
              chunksToHighlight: combineChunks({
                chunks: findChunks({
                  autoEscape,
                  caseSensitive,
                  sanitize: sanitize2,
                  searchWords,
                  textToHighlight
                })
              }),
              totalLength: textToHighlight ? textToHighlight.length : 0
            });
          };
          var combineChunks = exports2.combineChunks = function combineChunks2(_ref24) {
            var chunks = _ref24.chunks;
            chunks = chunks.sort(function(first, second) {
              return first.start - second.start;
            }).reduce(function(processedChunks, nextChunk) {
              if (processedChunks.length === 0) {
                return [nextChunk];
              } else {
                var prevChunk = processedChunks.pop();
                if (nextChunk.start <= prevChunk.end) {
                  var endIndex = Math.max(prevChunk.end, nextChunk.end);
                  processedChunks.push({ highlight: false, start: prevChunk.start, end: endIndex });
                } else {
                  processedChunks.push(prevChunk, nextChunk);
                }
                return processedChunks;
              }
            }, []);
            return chunks;
          };
          var defaultFindChunks = function defaultFindChunks2(_ref32) {
            var autoEscape = _ref32.autoEscape, caseSensitive = _ref32.caseSensitive, _ref3$sanitize = _ref32.sanitize, sanitize2 = _ref3$sanitize === void 0 ? defaultSanitize : _ref3$sanitize, searchWords = _ref32.searchWords, textToHighlight = _ref32.textToHighlight;
            textToHighlight = sanitize2(textToHighlight);
            return searchWords.filter(function(searchWord) {
              return searchWord;
            }).reduce(function(chunks, searchWord) {
              searchWord = sanitize2(searchWord);
              if (autoEscape) {
                searchWord = escapeRegExpFn(searchWord);
              }
              var regex = new RegExp(searchWord, caseSensitive ? "g" : "gi");
              var match4 = void 0;
              while (match4 = regex.exec(textToHighlight)) {
                var _start = match4.index;
                var _end = regex.lastIndex;
                if (_end > _start) {
                  chunks.push({ highlight: false, start: _start, end: _end });
                }
                if (match4.index === regex.lastIndex) {
                  regex.lastIndex++;
                }
              }
              return chunks;
            }, []);
          };
          exports2.findChunks = defaultFindChunks;
          var fillInChunks = exports2.fillInChunks = function fillInChunks2(_ref42) {
            var chunksToHighlight = _ref42.chunksToHighlight, totalLength = _ref42.totalLength;
            var allChunks = [];
            var append2 = function append3(start, end, highlight) {
              if (end - start > 0) {
                allChunks.push({
                  start,
                  end,
                  highlight
                });
              }
            };
            if (chunksToHighlight.length === 0) {
              append2(0, totalLength, false);
            } else {
              var lastIndex = 0;
              chunksToHighlight.forEach(function(chunk) {
                append2(lastIndex, chunk.start, false);
                append2(chunk.start, chunk.end, true);
                lastIndex = chunk.end;
              });
              append2(lastIndex, totalLength, false);
            }
            return allChunks;
          };
          function defaultSanitize(string) {
            return string;
          }
          function escapeRegExpFn(string) {
            return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
          }
        })
        /******/
      ]);
    }
  });

  // package-external:@wordpress/rich-text
  var require_rich_text = __commonJS({
    "package-external:@wordpress/rich-text"(exports, module) {
      module.exports = window.wp.richText;
    }
  });

  // package-external:@wordpress/a11y
  var require_a11y = __commonJS({
    "package-external:@wordpress/a11y"(exports, module) {
      module.exports = window.wp.a11y;
    }
  });

  // package-external:@wordpress/keycodes
  var require_keycodes = __commonJS({
    "package-external:@wordpress/keycodes"(exports, module) {
      module.exports = window.wp.keycodes;
    }
  });

  // node_modules/remove-accents/index.js
  var require_remove_accents = __commonJS({
    "node_modules/remove-accents/index.js"(exports, module) {
      var characterMap = {
        "\xC0": "A",
        "\xC1": "A",
        "\xC2": "A",
        "\xC3": "A",
        "\xC4": "A",
        "\xC5": "A",
        "\u1EA4": "A",
        "\u1EAE": "A",
        "\u1EB2": "A",
        "\u1EB4": "A",
        "\u1EB6": "A",
        "\xC6": "AE",
        "\u1EA6": "A",
        "\u1EB0": "A",
        "\u0202": "A",
        "\u1EA2": "A",
        "\u1EA0": "A",
        "\u1EA8": "A",
        "\u1EAA": "A",
        "\u1EAC": "A",
        "\xC7": "C",
        "\u1E08": "C",
        "\xC8": "E",
        "\xC9": "E",
        "\xCA": "E",
        "\xCB": "E",
        "\u1EBE": "E",
        "\u1E16": "E",
        "\u1EC0": "E",
        "\u1E14": "E",
        "\u1E1C": "E",
        "\u0206": "E",
        "\u1EBA": "E",
        "\u1EBC": "E",
        "\u1EB8": "E",
        "\u1EC2": "E",
        "\u1EC4": "E",
        "\u1EC6": "E",
        "\xCC": "I",
        "\xCD": "I",
        "\xCE": "I",
        "\xCF": "I",
        "\u1E2E": "I",
        "\u020A": "I",
        "\u1EC8": "I",
        "\u1ECA": "I",
        "\xD0": "D",
        "\xD1": "N",
        "\xD2": "O",
        "\xD3": "O",
        "\xD4": "O",
        "\xD5": "O",
        "\xD6": "O",
        "\xD8": "O",
        "\u1ED0": "O",
        "\u1E4C": "O",
        "\u1E52": "O",
        "\u020E": "O",
        "\u1ECE": "O",
        "\u1ECC": "O",
        "\u1ED4": "O",
        "\u1ED6": "O",
        "\u1ED8": "O",
        "\u1EDC": "O",
        "\u1EDE": "O",
        "\u1EE0": "O",
        "\u1EDA": "O",
        "\u1EE2": "O",
        "\xD9": "U",
        "\xDA": "U",
        "\xDB": "U",
        "\xDC": "U",
        "\u1EE6": "U",
        "\u1EE4": "U",
        "\u1EEC": "U",
        "\u1EEE": "U",
        "\u1EF0": "U",
        "\xDD": "Y",
        "\xE0": "a",
        "\xE1": "a",
        "\xE2": "a",
        "\xE3": "a",
        "\xE4": "a",
        "\xE5": "a",
        "\u1EA5": "a",
        "\u1EAF": "a",
        "\u1EB3": "a",
        "\u1EB5": "a",
        "\u1EB7": "a",
        "\xE6": "ae",
        "\u1EA7": "a",
        "\u1EB1": "a",
        "\u0203": "a",
        "\u1EA3": "a",
        "\u1EA1": "a",
        "\u1EA9": "a",
        "\u1EAB": "a",
        "\u1EAD": "a",
        "\xE7": "c",
        "\u1E09": "c",
        "\xE8": "e",
        "\xE9": "e",
        "\xEA": "e",
        "\xEB": "e",
        "\u1EBF": "e",
        "\u1E17": "e",
        "\u1EC1": "e",
        "\u1E15": "e",
        "\u1E1D": "e",
        "\u0207": "e",
        "\u1EBB": "e",
        "\u1EBD": "e",
        "\u1EB9": "e",
        "\u1EC3": "e",
        "\u1EC5": "e",
        "\u1EC7": "e",
        "\xEC": "i",
        "\xED": "i",
        "\xEE": "i",
        "\xEF": "i",
        "\u1E2F": "i",
        "\u020B": "i",
        "\u1EC9": "i",
        "\u1ECB": "i",
        "\xF0": "d",
        "\xF1": "n",
        "\xF2": "o",
        "\xF3": "o",
        "\xF4": "o",
        "\xF5": "o",
        "\xF6": "o",
        "\xF8": "o",
        "\u1ED1": "o",
        "\u1E4D": "o",
        "\u1E53": "o",
        "\u020F": "o",
        "\u1ECF": "o",
        "\u1ECD": "o",
        "\u1ED5": "o",
        "\u1ED7": "o",
        "\u1ED9": "o",
        "\u1EDD": "o",
        "\u1EDF": "o",
        "\u1EE1": "o",
        "\u1EDB": "o",
        "\u1EE3": "o",
        "\xF9": "u",
        "\xFA": "u",
        "\xFB": "u",
        "\xFC": "u",
        "\u1EE7": "u",
        "\u1EE5": "u",
        "\u1EED": "u",
        "\u1EEF": "u",
        "\u1EF1": "u",
        "\xFD": "y",
        "\xFF": "y",
        "\u0100": "A",
        "\u0101": "a",
        "\u0102": "A",
        "\u0103": "a",
        "\u0104": "A",
        "\u0105": "a",
        "\u0106": "C",
        "\u0107": "c",
        "\u0108": "C",
        "\u0109": "c",
        "\u010A": "C",
        "\u010B": "c",
        "\u010C": "C",
        "\u010D": "c",
        "C\u0306": "C",
        "c\u0306": "c",
        "\u010E": "D",
        "\u010F": "d",
        "\u0110": "D",
        "\u0111": "d",
        "\u0112": "E",
        "\u0113": "e",
        "\u0114": "E",
        "\u0115": "e",
        "\u0116": "E",
        "\u0117": "e",
        "\u0118": "E",
        "\u0119": "e",
        "\u011A": "E",
        "\u011B": "e",
        "\u011C": "G",
        "\u01F4": "G",
        "\u011D": "g",
        "\u01F5": "g",
        "\u011E": "G",
        "\u011F": "g",
        "\u0120": "G",
        "\u0121": "g",
        "\u0122": "G",
        "\u0123": "g",
        "\u0124": "H",
        "\u0125": "h",
        "\u0126": "H",
        "\u0127": "h",
        "\u1E2A": "H",
        "\u1E2B": "h",
        "\u0128": "I",
        "\u0129": "i",
        "\u012A": "I",
        "\u012B": "i",
        "\u012C": "I",
        "\u012D": "i",
        "\u012E": "I",
        "\u012F": "i",
        "\u0130": "I",
        "\u0131": "i",
        "\u0132": "IJ",
        "\u0133": "ij",
        "\u0134": "J",
        "\u0135": "j",
        "\u0136": "K",
        "\u0137": "k",
        "\u1E30": "K",
        "\u1E31": "k",
        "K\u0306": "K",
        "k\u0306": "k",
        "\u0139": "L",
        "\u013A": "l",
        "\u013B": "L",
        "\u013C": "l",
        "\u013D": "L",
        "\u013E": "l",
        "\u013F": "L",
        "\u0140": "l",
        "\u0141": "l",
        "\u0142": "l",
        "\u1E3E": "M",
        "\u1E3F": "m",
        "M\u0306": "M",
        "m\u0306": "m",
        "\u0143": "N",
        "\u0144": "n",
        "\u0145": "N",
        "\u0146": "n",
        "\u0147": "N",
        "\u0148": "n",
        "\u0149": "n",
        "N\u0306": "N",
        "n\u0306": "n",
        "\u014C": "O",
        "\u014D": "o",
        "\u014E": "O",
        "\u014F": "o",
        "\u0150": "O",
        "\u0151": "o",
        "\u0152": "OE",
        "\u0153": "oe",
        "P\u0306": "P",
        "p\u0306": "p",
        "\u0154": "R",
        "\u0155": "r",
        "\u0156": "R",
        "\u0157": "r",
        "\u0158": "R",
        "\u0159": "r",
        "R\u0306": "R",
        "r\u0306": "r",
        "\u0212": "R",
        "\u0213": "r",
        "\u015A": "S",
        "\u015B": "s",
        "\u015C": "S",
        "\u015D": "s",
        "\u015E": "S",
        "\u0218": "S",
        "\u0219": "s",
        "\u015F": "s",
        "\u0160": "S",
        "\u0161": "s",
        "\u0162": "T",
        "\u0163": "t",
        "\u021B": "t",
        "\u021A": "T",
        "\u0164": "T",
        "\u0165": "t",
        "\u0166": "T",
        "\u0167": "t",
        "T\u0306": "T",
        "t\u0306": "t",
        "\u0168": "U",
        "\u0169": "u",
        "\u016A": "U",
        "\u016B": "u",
        "\u016C": "U",
        "\u016D": "u",
        "\u016E": "U",
        "\u016F": "u",
        "\u0170": "U",
        "\u0171": "u",
        "\u0172": "U",
        "\u0173": "u",
        "\u0216": "U",
        "\u0217": "u",
        "V\u0306": "V",
        "v\u0306": "v",
        "\u0174": "W",
        "\u0175": "w",
        "\u1E82": "W",
        "\u1E83": "w",
        "X\u0306": "X",
        "x\u0306": "x",
        "\u0176": "Y",
        "\u0177": "y",
        "\u0178": "Y",
        "Y\u0306": "Y",
        "y\u0306": "y",
        "\u0179": "Z",
        "\u017A": "z",
        "\u017B": "Z",
        "\u017C": "z",
        "\u017D": "Z",
        "\u017E": "z",
        "\u017F": "s",
        "\u0192": "f",
        "\u01A0": "O",
        "\u01A1": "o",
        "\u01AF": "U",
        "\u01B0": "u",
        "\u01CD": "A",
        "\u01CE": "a",
        "\u01CF": "I",
        "\u01D0": "i",
        "\u01D1": "O",
        "\u01D2": "o",
        "\u01D3": "U",
        "\u01D4": "u",
        "\u01D5": "U",
        "\u01D6": "u",
        "\u01D7": "U",
        "\u01D8": "u",
        "\u01D9": "U",
        "\u01DA": "u",
        "\u01DB": "U",
        "\u01DC": "u",
        "\u1EE8": "U",
        "\u1EE9": "u",
        "\u1E78": "U",
        "\u1E79": "u",
        "\u01FA": "A",
        "\u01FB": "a",
        "\u01FC": "AE",
        "\u01FD": "ae",
        "\u01FE": "O",
        "\u01FF": "o",
        "\xDE": "TH",
        "\xFE": "th",
        "\u1E54": "P",
        "\u1E55": "p",
        "\u1E64": "S",
        "\u1E65": "s",
        "X\u0301": "X",
        "x\u0301": "x",
        "\u0403": "\u0413",
        "\u0453": "\u0433",
        "\u040C": "\u041A",
        "\u045C": "\u043A",
        "A\u030B": "A",
        "a\u030B": "a",
        "E\u030B": "E",
        "e\u030B": "e",
        "I\u030B": "I",
        "i\u030B": "i",
        "\u01F8": "N",
        "\u01F9": "n",
        "\u1ED2": "O",
        "\u1ED3": "o",
        "\u1E50": "O",
        "\u1E51": "o",
        "\u1EEA": "U",
        "\u1EEB": "u",
        "\u1E80": "W",
        "\u1E81": "w",
        "\u1EF2": "Y",
        "\u1EF3": "y",
        "\u0200": "A",
        "\u0201": "a",
        "\u0204": "E",
        "\u0205": "e",
        "\u0208": "I",
        "\u0209": "i",
        "\u020C": "O",
        "\u020D": "o",
        "\u0210": "R",
        "\u0211": "r",
        "\u0214": "U",
        "\u0215": "u",
        "B\u030C": "B",
        "b\u030C": "b",
        "\u010C\u0323": "C",
        "\u010D\u0323": "c",
        "\xCA\u030C": "E",
        "\xEA\u030C": "e",
        "F\u030C": "F",
        "f\u030C": "f",
        "\u01E6": "G",
        "\u01E7": "g",
        "\u021E": "H",
        "\u021F": "h",
        "J\u030C": "J",
        "\u01F0": "j",
        "\u01E8": "K",
        "\u01E9": "k",
        "M\u030C": "M",
        "m\u030C": "m",
        "P\u030C": "P",
        "p\u030C": "p",
        "Q\u030C": "Q",
        "q\u030C": "q",
        "\u0158\u0329": "R",
        "\u0159\u0329": "r",
        "\u1E66": "S",
        "\u1E67": "s",
        "V\u030C": "V",
        "v\u030C": "v",
        "W\u030C": "W",
        "w\u030C": "w",
        "X\u030C": "X",
        "x\u030C": "x",
        "Y\u030C": "Y",
        "y\u030C": "y",
        "A\u0327": "A",
        "a\u0327": "a",
        "B\u0327": "B",
        "b\u0327": "b",
        "\u1E10": "D",
        "\u1E11": "d",
        "\u0228": "E",
        "\u0229": "e",
        "\u0190\u0327": "E",
        "\u025B\u0327": "e",
        "\u1E28": "H",
        "\u1E29": "h",
        "I\u0327": "I",
        "i\u0327": "i",
        "\u0197\u0327": "I",
        "\u0268\u0327": "i",
        "M\u0327": "M",
        "m\u0327": "m",
        "O\u0327": "O",
        "o\u0327": "o",
        "Q\u0327": "Q",
        "q\u0327": "q",
        "U\u0327": "U",
        "u\u0327": "u",
        "X\u0327": "X",
        "x\u0327": "x",
        "Z\u0327": "Z",
        "z\u0327": "z",
        "\u0439": "\u0438",
        "\u0419": "\u0418",
        "\u0451": "\u0435",
        "\u0401": "\u0415"
      };
      var chars = Object.keys(characterMap).join("|");
      var allAccents = new RegExp(chars, "g");
      var firstAccent = new RegExp(chars, "");
      function matcher(match4) {
        return characterMap[match4];
      }
      var removeAccents4 = function(string) {
        return string.replace(allAccents, matcher);
      };
      var hasAccents = function(string) {
        return !!string.match(firstAccent);
      };
      module.exports = removeAccents4;
      module.exports.has = hasAccents;
      module.exports.remove = removeAccents4;
    }
  });

  // package-external:@wordpress/is-shallow-equal
  var require_is_shallow_equal = __commonJS({
    "package-external:@wordpress/is-shallow-equal"(exports, module) {
      module.exports = window.wp.isShallowEqual;
    }
  });

  // package-external:@wordpress/private-apis
  var require_private_apis = __commonJS({
    "package-external:@wordpress/private-apis"(exports, module) {
      module.exports = window.wp.privateApis;
    }
  });

  // node_modules/gradient-parser/build/node.js
  var require_node = __commonJS({
    "node_modules/gradient-parser/build/node.js"(exports) {
      var GradientParser = GradientParser || {};
      GradientParser.stringify = /* @__PURE__ */ (function() {
        var visitor = {
          "visit_linear-gradient": function(node2) {
            return visitor.visit_gradient(node2);
          },
          "visit_repeating-linear-gradient": function(node2) {
            return visitor.visit_gradient(node2);
          },
          "visit_radial-gradient": function(node2) {
            return visitor.visit_gradient(node2);
          },
          "visit_repeating-radial-gradient": function(node2) {
            return visitor.visit_gradient(node2);
          },
          "visit_gradient": function(node2) {
            var orientation = visitor.visit(node2.orientation);
            if (orientation) {
              orientation += ", ";
            }
            return node2.type + "(" + orientation + visitor.visit(node2.colorStops) + ")";
          },
          "visit_shape": function(node2) {
            var result = node2.value, at = visitor.visit(node2.at), style2 = visitor.visit(node2.style);
            if (style2) {
              result += " " + style2;
            }
            if (at) {
              result += " at " + at;
            }
            return result;
          },
          "visit_default-radial": function(node2) {
            var result = "", at = visitor.visit(node2.at);
            if (at) {
              result += at;
            }
            return result;
          },
          "visit_extent-keyword": function(node2) {
            var result = node2.value, at = visitor.visit(node2.at);
            if (at) {
              result += " at " + at;
            }
            return result;
          },
          "visit_position-keyword": function(node2) {
            return node2.value;
          },
          "visit_position": function(node2) {
            return visitor.visit(node2.value.x) + " " + visitor.visit(node2.value.y);
          },
          "visit_%": function(node2) {
            return node2.value + "%";
          },
          "visit_em": function(node2) {
            return node2.value + "em";
          },
          "visit_px": function(node2) {
            return node2.value + "px";
          },
          "visit_calc": function(node2) {
            return "calc(" + node2.value + ")";
          },
          "visit_literal": function(node2) {
            return visitor.visit_color(node2.value, node2);
          },
          "visit_hex": function(node2) {
            return visitor.visit_color("#" + node2.value, node2);
          },
          "visit_rgb": function(node2) {
            return visitor.visit_color("rgb(" + node2.value.join(", ") + ")", node2);
          },
          "visit_rgba": function(node2) {
            return visitor.visit_color("rgba(" + node2.value.join(", ") + ")", node2);
          },
          "visit_hsl": function(node2) {
            return visitor.visit_color("hsl(" + node2.value[0] + ", " + node2.value[1] + "%, " + node2.value[2] + "%)", node2);
          },
          "visit_hsla": function(node2) {
            return visitor.visit_color("hsla(" + node2.value[0] + ", " + node2.value[1] + "%, " + node2.value[2] + "%, " + node2.value[3] + ")", node2);
          },
          "visit_var": function(node2) {
            return visitor.visit_color("var(" + node2.value + ")", node2);
          },
          "visit_color": function(resultColor, node2) {
            var result = resultColor, length2 = visitor.visit(node2.length);
            if (length2) {
              result += " " + length2;
            }
            return result;
          },
          "visit_angular": function(node2) {
            return node2.value + "deg";
          },
          "visit_directional": function(node2) {
            return "to " + node2.value;
          },
          "visit_array": function(elements2) {
            var result = "", size4 = elements2.length;
            elements2.forEach(function(element, i3) {
              result += visitor.visit(element);
              if (i3 < size4 - 1) {
                result += ", ";
              }
            });
            return result;
          },
          "visit_object": function(obj) {
            if (obj.width && obj.height) {
              return visitor.visit(obj.width) + " " + visitor.visit(obj.height);
            }
            return "";
          },
          "visit": function(element) {
            if (!element) {
              return "";
            }
            var result = "";
            if (element instanceof Array) {
              return visitor.visit_array(element);
            } else if (typeof element === "object" && !element.type) {
              return visitor.visit_object(element);
            } else if (element.type) {
              var nodeVisitor = visitor["visit_" + element.type];
              if (nodeVisitor) {
                return nodeVisitor(element);
              } else {
                throw Error("Missing visitor visit_" + element.type);
              }
            } else {
              throw Error("Invalid node.");
            }
          }
        };
        return function(root) {
          return visitor.visit(root);
        };
      })();
      var GradientParser = GradientParser || {};
      GradientParser.parse = /* @__PURE__ */ (function() {
        var tokens = {
          linearGradient: /^(\-(webkit|o|ms|moz)\-)?(linear\-gradient)/i,
          repeatingLinearGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-linear\-gradient)/i,
          radialGradient: /^(\-(webkit|o|ms|moz)\-)?(radial\-gradient)/i,
          repeatingRadialGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-radial\-gradient)/i,
          sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
          extentKeywords: /^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,
          positionKeywords: /^(left|center|right|top|bottom)/i,
          pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
          percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,
          emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
          angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
          radianValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))rad/,
          startCall: /^\(/,
          endCall: /^\)/,
          comma: /^,/,
          hexColor: /^\#([0-9a-fA-F]+)/,
          literalColor: /^([a-zA-Z]+)/,
          rgbColor: /^rgb/i,
          rgbaColor: /^rgba/i,
          varColor: /^var/i,
          calcValue: /^calc/i,
          variableName: /^(--[a-zA-Z0-9-,\s\#]+)/,
          number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/,
          hslColor: /^hsl/i,
          hslaColor: /^hsla/i
        };
        var input = "";
        function error(msg) {
          var err = new Error(input + ": " + msg);
          err.source = input;
          throw err;
        }
        function getAST() {
          var ast = matchListDefinitions();
          if (input.length > 0) {
            error("Invalid input not EOF");
          }
          return ast;
        }
        function matchListDefinitions() {
          return matchListing(matchDefinition);
        }
        function matchDefinition() {
          return matchGradient(
            "linear-gradient",
            tokens.linearGradient,
            matchLinearOrientation
          ) || matchGradient(
            "repeating-linear-gradient",
            tokens.repeatingLinearGradient,
            matchLinearOrientation
          ) || matchGradient(
            "radial-gradient",
            tokens.radialGradient,
            matchListRadialOrientations
          ) || matchGradient(
            "repeating-radial-gradient",
            tokens.repeatingRadialGradient,
            matchListRadialOrientations
          );
        }
        function matchGradient(gradientType, pattern, orientationMatcher) {
          return matchCall(pattern, function(captures) {
            var orientation = orientationMatcher();
            if (orientation) {
              if (!scan(tokens.comma)) {
                error("Missing comma before color stops");
              }
            }
            return {
              type: gradientType,
              orientation,
              colorStops: matchListing(matchColorStop)
            };
          });
        }
        function matchCall(pattern, callback) {
          var captures = scan(pattern);
          if (captures) {
            if (!scan(tokens.startCall)) {
              error("Missing (");
            }
            var result = callback(captures);
            if (!scan(tokens.endCall)) {
              error("Missing )");
            }
            return result;
          }
        }
        function matchLinearOrientation() {
          var sideOrCorner = matchSideOrCorner();
          if (sideOrCorner) {
            return sideOrCorner;
          }
          var legacyDirection = match4("position-keyword", tokens.positionKeywords, 1);
          if (legacyDirection) {
            return {
              type: "directional",
              value: legacyDirection.value
            };
          }
          return matchAngle();
        }
        function matchSideOrCorner() {
          return match4("directional", tokens.sideOrCorner, 1);
        }
        function matchAngle() {
          return match4("angular", tokens.angleValue, 1) || match4("angular", tokens.radianValue, 1);
        }
        function matchListRadialOrientations() {
          var radialOrientations, radialOrientation = matchRadialOrientation(), lookaheadCache;
          if (radialOrientation) {
            radialOrientations = [];
            radialOrientations.push(radialOrientation);
            lookaheadCache = input;
            if (scan(tokens.comma)) {
              radialOrientation = matchRadialOrientation();
              if (radialOrientation) {
                radialOrientations.push(radialOrientation);
              } else {
                input = lookaheadCache;
              }
            }
          }
          return radialOrientations;
        }
        function matchRadialOrientation() {
          var radialType = matchCircle() || matchEllipse();
          if (radialType) {
            radialType.at = matchAtPosition();
          } else {
            var extent = matchExtentKeyword();
            if (extent) {
              radialType = extent;
              var positionAt = matchAtPosition();
              if (positionAt) {
                radialType.at = positionAt;
              }
            } else {
              var atPosition = matchAtPosition();
              if (atPosition) {
                radialType = {
                  type: "default-radial",
                  at: atPosition
                };
              } else {
                var defaultPosition = matchPositioning();
                if (defaultPosition) {
                  radialType = {
                    type: "default-radial",
                    at: defaultPosition
                  };
                }
              }
            }
          }
          return radialType;
        }
        function matchCircle() {
          var circle = match4("shape", /^(circle)/i, 0);
          if (circle) {
            circle.style = matchLength() || matchExtentKeyword();
          }
          return circle;
        }
        function matchEllipse() {
          var ellipse = match4("shape", /^(ellipse)/i, 0);
          if (ellipse) {
            ellipse.style = matchPositioning() || matchDistance() || matchExtentKeyword();
          }
          return ellipse;
        }
        function matchExtentKeyword() {
          return match4("extent-keyword", tokens.extentKeywords, 1);
        }
        function matchAtPosition() {
          if (match4("position", /^at/, 0)) {
            var positioning = matchPositioning();
            if (!positioning) {
              error("Missing positioning value");
            }
            return positioning;
          }
        }
        function matchPositioning() {
          var location = matchCoordinates();
          if (location.x || location.y) {
            return {
              type: "position",
              value: location
            };
          }
        }
        function matchCoordinates() {
          return {
            x: matchDistance(),
            y: matchDistance()
          };
        }
        function matchListing(matcher) {
          var captures = matcher(), result = [];
          if (captures) {
            result.push(captures);
            while (scan(tokens.comma)) {
              captures = matcher();
              if (captures) {
                result.push(captures);
              } else {
                error("One extra comma");
              }
            }
          }
          return result;
        }
        function matchColorStop() {
          var color2 = matchColor();
          if (!color2) {
            error("Expected color definition");
          }
          color2.length = matchDistance();
          return color2;
        }
        function matchColor() {
          return matchHexColor() || matchHSLAColor() || matchHSLColor() || matchRGBAColor() || matchRGBColor() || matchVarColor() || matchLiteralColor();
        }
        function matchLiteralColor() {
          return match4("literal", tokens.literalColor, 0);
        }
        function matchHexColor() {
          return match4("hex", tokens.hexColor, 1);
        }
        function matchRGBColor() {
          return matchCall(tokens.rgbColor, function() {
            return {
              type: "rgb",
              value: matchListing(matchNumber)
            };
          });
        }
        function matchRGBAColor() {
          return matchCall(tokens.rgbaColor, function() {
            return {
              type: "rgba",
              value: matchListing(matchNumber)
            };
          });
        }
        function matchVarColor() {
          return matchCall(tokens.varColor, function() {
            return {
              type: "var",
              value: matchVariableName()
            };
          });
        }
        function matchHSLColor() {
          return matchCall(tokens.hslColor, function() {
            var lookahead = scan(tokens.percentageValue);
            if (lookahead) {
              error("HSL hue value must be a number in degrees (0-360) or normalized (-360 to 360), not a percentage");
            }
            var hue = matchNumber();
            scan(tokens.comma);
            var captures = scan(tokens.percentageValue);
            var sat = captures ? captures[1] : null;
            scan(tokens.comma);
            captures = scan(tokens.percentageValue);
            var light = captures ? captures[1] : null;
            if (!sat || !light) {
              error("Expected percentage value for saturation and lightness in HSL");
            }
            return {
              type: "hsl",
              value: [hue, sat, light]
            };
          });
        }
        function matchHSLAColor() {
          return matchCall(tokens.hslaColor, function() {
            var hue = matchNumber();
            scan(tokens.comma);
            var captures = scan(tokens.percentageValue);
            var sat = captures ? captures[1] : null;
            scan(tokens.comma);
            captures = scan(tokens.percentageValue);
            var light = captures ? captures[1] : null;
            scan(tokens.comma);
            var alpha2 = matchNumber();
            if (!sat || !light) {
              error("Expected percentage value for saturation and lightness in HSLA");
            }
            return {
              type: "hsla",
              value: [hue, sat, light, alpha2]
            };
          });
        }
        function matchPercentage() {
          var captures = scan(tokens.percentageValue);
          return captures ? captures[1] : null;
        }
        function matchVariableName() {
          return scan(tokens.variableName)[1];
        }
        function matchNumber() {
          return scan(tokens.number)[1];
        }
        function matchDistance() {
          return match4("%", tokens.percentageValue, 1) || matchPositionKeyword() || matchCalc() || matchLength();
        }
        function matchPositionKeyword() {
          return match4("position-keyword", tokens.positionKeywords, 1);
        }
        function matchCalc() {
          return matchCall(tokens.calcValue, function() {
            var openParenCount = 1;
            var i3 = 0;
            while (openParenCount > 0 && i3 < input.length) {
              var char2 = input.charAt(i3);
              if (char2 === "(") {
                openParenCount++;
              } else if (char2 === ")") {
                openParenCount--;
              }
              i3++;
            }
            if (openParenCount > 0) {
              error("Missing closing parenthesis in calc() expression");
            }
            var calcContent = input.substring(0, i3 - 1);
            consume(i3 - 1);
            return {
              type: "calc",
              value: calcContent
            };
          });
        }
        function matchLength() {
          return match4("px", tokens.pixelValue, 1) || match4("em", tokens.emValue, 1);
        }
        function match4(type, pattern, captureIndex) {
          var captures = scan(pattern);
          if (captures) {
            return {
              type,
              value: captures[captureIndex]
            };
          }
        }
        function scan(regexp) {
          var captures, blankCaptures;
          blankCaptures = /^[\n\r\t\s]+/.exec(input);
          if (blankCaptures) {
            consume(blankCaptures[0].length);
          }
          captures = regexp.exec(input);
          if (captures) {
            consume(captures[0].length);
          }
          return captures;
        }
        function consume(size4) {
          input = input.substr(size4);
        }
        return function(code) {
          input = code.toString().trim();
          if (input.endsWith(";")) {
            input = input.slice(0, -1);
          }
          return getAST();
        };
      })();
      exports.parse = GradientParser.parse;
      exports.stringify = GradientParser.stringify;
    }
  });

  // package-external:@wordpress/dom
  var require_dom = __commonJS({
    "package-external:@wordpress/dom"(exports, module) {
      module.exports = window.wp.dom;
    }
  });

  // package-external:@wordpress/date
  var require_date = __commonJS({
    "package-external:@wordpress/date"(exports, module) {
      module.exports = window.wp.date;
    }
  });

  // package-external:@wordpress/escape-html
  var require_escape_html = __commonJS({
    "package-external:@wordpress/escape-html"(exports, module) {
      module.exports = window.wp.escapeHtml;
    }
  });

  // package-external:@wordpress/html-entities
  var require_html_entities = __commonJS({
    "package-external:@wordpress/html-entities"(exports, module) {
      module.exports = window.wp.htmlEntities;
    }
  });

  // node_modules/fast-memoize/src/index.js
  var require_src = __commonJS({
    "node_modules/fast-memoize/src/index.js"(exports, module) {
      function memoize3(fn, options2) {
        var cache2 = options2 && options2.cache ? options2.cache : cacheDefault;
        var serializer = options2 && options2.serializer ? options2.serializer : serializerDefault;
        var strategy = options2 && options2.strategy ? options2.strategy : strategyDefault;
        return strategy(fn, {
          cache: cache2,
          serializer
        });
      }
      function isPrimitive(value) {
        return value == null || typeof value === "number" || typeof value === "boolean";
      }
      function monadic(fn, cache2, serializer, arg) {
        var cacheKey = isPrimitive(arg) ? arg : serializer(arg);
        var computedValue = cache2.get(cacheKey);
        if (typeof computedValue === "undefined") {
          computedValue = fn.call(this, arg);
          cache2.set(cacheKey, computedValue);
        }
        return computedValue;
      }
      function variadic(fn, cache2, serializer) {
        var args = Array.prototype.slice.call(arguments, 3);
        var cacheKey = serializer(args);
        var computedValue = cache2.get(cacheKey);
        if (typeof computedValue === "undefined") {
          computedValue = fn.apply(this, args);
          cache2.set(cacheKey, computedValue);
        }
        return computedValue;
      }
      function assemble(fn, context, strategy, cache2, serialize2) {
        return strategy.bind(
          context,
          fn,
          cache2,
          serialize2
        );
      }
      function strategyDefault(fn, options2) {
        var strategy = fn.length === 1 ? monadic : variadic;
        return assemble(
          fn,
          this,
          strategy,
          options2.cache.create(),
          options2.serializer
        );
      }
      function strategyVariadic(fn, options2) {
        var strategy = variadic;
        return assemble(
          fn,
          this,
          strategy,
          options2.cache.create(),
          options2.serializer
        );
      }
      function strategyMonadic(fn, options2) {
        var strategy = monadic;
        return assemble(
          fn,
          this,
          strategy,
          options2.cache.create(),
          options2.serializer
        );
      }
      function serializerDefault() {
        return JSON.stringify(arguments);
      }
      function ObjectWithoutPrototypeCache() {
        this.cache = /* @__PURE__ */ Object.create(null);
      }
      ObjectWithoutPrototypeCache.prototype.has = function(key) {
        return key in this.cache;
      };
      ObjectWithoutPrototypeCache.prototype.get = function(key) {
        return this.cache[key];
      };
      ObjectWithoutPrototypeCache.prototype.set = function(key, value) {
        this.cache[key] = value;
      };
      var cacheDefault = {
        create: function create2() {
          return new ObjectWithoutPrototypeCache();
        }
      };
      module.exports = memoize3;
      module.exports.strategies = {
        variadic: strategyVariadic,
        monadic: strategyMonadic
      };
    }
  });

  // package-external:@wordpress/hooks
  var require_hooks = __commonJS({
    "package-external:@wordpress/hooks"(exports, module) {
      module.exports = window.wp.hooks;
    }
  });

  // packages/components/build-module/index.mjs
  var index_exports = {};
  __export(index_exports, {
    AlignmentMatrixControl: () => alignment_matrix_control_default,
    AnglePickerControl: () => angle_picker_control_default,
    Animate: () => animate_default,
    Autocomplete: () => Autocomplete,
    BaseControl: () => base_control_default,
    BlockQuotation: () => import_primitives35.BlockQuotation,
    BorderBoxControl: () => component_default24,
    BorderControl: () => component_default21,
    BoxControl: () => box_control_default,
    Button: () => button_default,
    ButtonGroup: () => button_group_default,
    Card: () => component_default27,
    CardBody: () => component_default29,
    CardDivider: () => component_default31,
    CardFooter: () => component_default32,
    CardHeader: () => component_default33,
    CardMedia: () => component_default34,
    CheckboxControl: () => checkbox_control_default,
    Circle: () => import_primitives35.Circle,
    ClipboardButton: () => ClipboardButton,
    ColorIndicator: () => color_indicator_default,
    ColorPalette: () => color_palette_default,
    ColorPicker: () => LegacyAdapter,
    ComboboxControl: () => combobox_control_default,
    Composite: () => Composite22,
    CustomGradientPicker: () => custom_gradient_picker_default,
    CustomSelectControl: () => custom_select_control_default,
    Dashicon: () => dashicon_default,
    DatePicker: () => date_picker_default,
    DateTimePicker: () => date_time_default2,
    Disabled: () => disabled_default,
    Draggable: () => draggable_default,
    DropZone: () => drop_zone_default,
    DropZoneProvider: () => DropZoneProvider,
    Dropdown: () => dropdown_default,
    DropdownMenu: () => dropdown_menu_default,
    DuotonePicker: () => duotone_picker_default,
    DuotoneSwatch: () => duotone_swatch_default,
    ExternalLink: () => external_link_default,
    Fill: () => Fill,
    Flex: () => component_default3,
    FlexBlock: () => component_default5,
    FlexItem: () => component_default4,
    FocalPointPicker: () => focal_point_picker_default,
    FocusReturnProvider: () => Provider3,
    FocusableIframe: () => FocusableIframe,
    FontSizePicker: () => font_size_picker_default,
    FormFileUpload: () => form_file_upload_default,
    FormToggle: () => form_toggle_default,
    FormTokenField: () => form_token_field_default,
    G: () => import_primitives35.G,
    GradientPicker: () => gradient_picker_default,
    Guide: () => guide_default,
    GuidePage: () => GuidePage,
    HorizontalRule: () => import_primitives35.HorizontalRule,
    Icon: () => icon_default3,
    IconButton: () => deprecated_default,
    IsolatedEventContainer: () => isolated_event_container_default,
    KeyboardShortcuts: () => keyboard_shortcuts_default,
    Line: () => import_primitives35.Line,
    MenuGroup: () => menu_group_default,
    MenuItem: () => menu_item_default,
    MenuItemsChoice: () => menu_items_choice_default,
    Modal: () => modal_default,
    NavigableMenu: () => menu_default2,
    Navigator: () => Navigator3,
    Notice: () => notice_default,
    NoticeList: () => list_default,
    Panel: () => panel_default,
    PanelBody: () => body_default,
    PanelHeader: () => header_default,
    PanelRow: () => row_default,
    Path: () => import_primitives35.Path,
    Placeholder: () => placeholder_default,
    Polygon: () => import_primitives35.Polygon,
    Popover: () => popover_default,
    ProgressBar: () => progress_bar_default,
    QueryControls: () => query_controls_default,
    RadioControl: () => radio_control_default,
    RangeControl: () => range_control_default,
    Rect: () => import_primitives35.Rect,
    ResizableBox: () => resizable_box_default,
    ResponsiveWrapper: () => responsive_wrapper_default,
    SVG: () => import_primitives35.SVG,
    SandBox: () => sandbox_default,
    ScrollLock: () => scroll_lock_default,
    SearchControl: () => search_control_default,
    SelectControl: () => select_control_default,
    Slot: () => Slot3,
    SlotFillProvider: () => Provider,
    Snackbar: () => snackbar_default,
    SnackbarList: () => list_default2,
    Spinner: () => spinner_default,
    TabPanel: () => tab_panel_default,
    TabbableContainer: () => tabbable_default,
    TextControl: () => text_control_default,
    TextHighlight: () => text_highlight_default,
    TextareaControl: () => textarea_control_default,
    TimePicker: () => time_picker_default,
    Tip: () => tip_default2,
    ToggleControl: () => toggle_control_default,
    Toolbar: () => toolbar_default,
    ToolbarButton: () => toolbar_button_default,
    ToolbarDropdownMenu: () => toolbar_dropdown_menu_default,
    ToolbarGroup: () => toolbar_group_default,
    ToolbarItem: () => toolbar_item_default,
    Tooltip: () => tooltip_default,
    TreeSelect: () => tree_select_default,
    VisuallyHidden: () => component_default2,
    __experimentalAlignmentMatrixControl: () => alignment_matrix_control_default,
    __experimentalBorderBoxControl: () => component_default24,
    __experimentalBorderControl: () => component_default21,
    __experimentalBoxControl: () => box_control_default,
    __experimentalConfirmDialog: () => component_default37,
    __experimentalDivider: () => component_default30,
    __experimentalDropdownContentWrapper: () => dropdown_content_wrapper_default,
    __experimentalElevation: () => component_default25,
    __experimentalGrid: () => component_default22,
    __experimentalHStack: () => component_default9,
    __experimentalHasSplitBorders: () => hasSplitBorders,
    __experimentalHeading: () => component_default19,
    __experimentalInputControl: () => input_control_default,
    __experimentalInputControlPrefixWrapper: () => input_prefix_wrapper_default,
    __experimentalInputControlSuffixWrapper: () => input_suffix_wrapper_default,
    __experimentalIsDefinedBorder: () => isDefinedBorder,
    __experimentalIsEmptyBorder: () => isEmptyBorder,
    __experimentalItem: () => component_default35,
    __experimentalItemGroup: () => component_default36,
    __experimentalNavigatorBackButton: () => NavigatorBackButton2,
    __experimentalNavigatorButton: () => NavigatorButton2,
    __experimentalNavigatorProvider: () => NavigatorProvider,
    __experimentalNavigatorScreen: () => NavigatorScreen2,
    __experimentalNavigatorToParentButton: () => NavigatorToParentButton2,
    __experimentalNumberControl: () => number_control_default,
    __experimentalPaletteEdit: () => palette_edit_default,
    __experimentalParseQuantityAndUnitFromRawValue: () => parseQuantityAndUnitFromRawValue,
    __experimentalRadio: () => radio_default,
    __experimentalRadioGroup: () => radio_group_default,
    __experimentalScrollable: () => component_default28,
    __experimentalSpacer: () => component_default6,
    __experimentalStyleProvider: () => style_provider_default,
    __experimentalSurface: () => component_default26,
    __experimentalText: () => component_default8,
    __experimentalToggleGroupControl: () => component_default12,
    __experimentalToggleGroupControlOption: () => component_default14,
    __experimentalToggleGroupControlOptionIcon: () => component_default15,
    __experimentalToolbarContext: () => toolbar_context_default,
    __experimentalToolsPanel: () => component_default39,
    __experimentalToolsPanelContext: () => ToolsPanelContext,
    __experimentalToolsPanelItem: () => component_default40,
    __experimentalTreeGrid: () => tree_grid_default,
    __experimentalTreeGridCell: () => cell_default,
    __experimentalTreeGridItem: () => item_default2,
    __experimentalTreeGridRow: () => row_default2,
    __experimentalTruncate: () => component_default7,
    __experimentalUnitControl: () => unit_control_default,
    __experimentalUseCustomUnits: () => useCustomUnits,
    __experimentalUseNavigator: () => useNavigator,
    __experimentalUseSlot: () => useSlot,
    __experimentalUseSlotFills: () => useSlotFills,
    __experimentalVStack: () => component_default18,
    __experimentalView: () => component_default,
    __experimentalZStack: () => component_default41,
    __unstableAnimatePresence: () => AnimatePresence,
    __unstableComposite: () => Composite4,
    __unstableCompositeGroup: () => CompositeGroup4,
    __unstableCompositeItem: () => CompositeItem4,
    __unstableDisclosureContent: () => DisclosureContent22,
    __unstableGetAnimateClassName: () => getAnimateClassName,
    __unstableMotion: () => motion,
    __unstableUseAutocompleteProps: () => useAutocompleteProps,
    __unstableUseCompositeState: () => useCompositeState,
    __unstableUseNavigateRegions: () => useNavigateRegions,
    createSlotFill: () => createSlotFill,
    navigateRegions: () => navigate_regions_default,
    privateApis: () => privateApis,
    useBaseControlProps: () => useBaseControlProps,
    useNavigator: () => useNavigator,
    withConstrainedTabbing: () => with_constrained_tabbing_default,
    withFallbackStyles: () => with_fallback_styles_default,
    withFilters: () => withFilters,
    withFocusOutside: () => with_focus_outside_default,
    withFocusReturn: () => with_focus_return_default,
    withNotices: () => with_notices_default,
    withSpokenMessages: () => with_spoken_messages_default
  });
  var import_primitives35 = __toESM(require_primitives(), 1);

  // node_modules/clsx/dist/clsx.mjs
  function r(e3) {
    var t4, f3, n3 = "";
    if ("string" == typeof e3 || "number" == typeof e3) n3 += e3;
    else if ("object" == typeof e3) if (Array.isArray(e3)) {
      var o4 = e3.length;
      for (t4 = 0; t4 < o4; t4++) e3[t4] && (f3 = r(e3[t4])) && (n3 && (n3 += " "), n3 += f3);
    } else for (f3 in e3) e3[f3] && (n3 && (n3 += " "), n3 += f3);
    return n3;
  }
  function clsx() {
    for (var e3, t4, f3 = 0, n3 = "", o4 = arguments.length; f3 < o4; f3++) (e3 = arguments[f3]) && (t4 = r(e3)) && (n3 && (n3 += " "), n3 += t4);
    return n3;
  }
  var clsx_default = clsx;

  // packages/components/build-module/alignment-matrix-control/index.mjs
  var import_i18n4 = __toESM(require_i18n(), 1);
  var import_compose2 = __toESM(require_compose(), 1);
  var import_element19 = __toESM(require_element(), 1);

  // node_modules/@ariakit/react-components/dist/focusable/focusable-context.js
  var import_react = __toESM(require_react(), 1);
  var FocusableContext = (0, import_react.createContext)(true);

  // node_modules/@ariakit/utils/dist/index.js
  function toArray(arg) {
    if (Array.isArray(arg)) return arg;
    return typeof arg !== "undefined" ? [arg] : [];
  }
  function flatten2DArray(array) {
    const flattened = [];
    for (const row of array) flattened.push(...row);
    return flattened;
  }
  function reverseArray(array) {
    return array.slice().reverse();
  }
  function noop(..._2) {
  }
  function shallowEqual(a3, b3) {
    if (a3 === b3) return true;
    if (!a3) return false;
    if (!b3) return false;
    if (typeof a3 !== "object") return false;
    if (typeof b3 !== "object") return false;
    const aKeys = Object.keys(a3);
    const bKeys = Object.keys(b3);
    const { length: length2 } = aKeys;
    if (bKeys.length !== length2) return false;
    for (const key of aKeys) if (a3[key] !== b3[key]) return false;
    return true;
  }
  function applyState(argument, currentValue) {
    if (isUpdater(argument)) return argument(isLazyValue(currentValue) ? currentValue() : currentValue);
    return argument;
  }
  function isUpdater(argument) {
    return typeof argument === "function";
  }
  function isLazyValue(value) {
    return typeof value === "function";
  }
  function hasOwnProperty(object, prop) {
    if (typeof Object.hasOwn === "function") return Object.hasOwn(object, prop);
    return Object.prototype.hasOwnProperty.call(object, prop);
  }
  function chain(...fns) {
    return (...args) => {
      for (const fn of fns) if (typeof fn === "function") fn(...args);
    };
  }
  function normalizeString(str) {
    return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
  }
  function omit(object, keys) {
    const result = { ...object };
    for (const key of keys) if (hasOwnProperty(result, key)) delete result[key];
    return result;
  }
  function pick(object, paths) {
    const result = {};
    for (const key of paths) if (hasOwnProperty(object, key)) result[key] = object[key];
    return result;
  }
  function identity(value) {
    return value;
  }
  function afterPaint(cb = noop) {
    let raf = requestAnimationFrame(() => {
      raf = requestAnimationFrame(cb);
    });
    return () => cancelAnimationFrame(raf);
  }
  function invariant(condition, message2) {
    if (condition) return;
    if (typeof message2 !== "string") throw new Error("Invariant failed");
    throw new Error(message2);
  }
  function getKeys(obj) {
    return Object.keys(obj);
  }
  function isFalsyBooleanCallback(booleanOrCallback, ...args) {
    const result = typeof booleanOrCallback === "function" ? booleanOrCallback(...args) : booleanOrCallback;
    if (result == null) return false;
    return !result;
  }
  function disabledFromProps(props) {
    return props.disabled || props["aria-disabled"] === true || props["aria-disabled"] === "true";
  }
  function disabledFromElement(element) {
    if (element.getAttribute("aria-disabled") === "true") return true;
    if ("disabled" in element && element.disabled === true) return true;
    return false;
  }
  function removeUndefinedValues(obj) {
    const result = {};
    for (const key in obj) if (obj[key] !== void 0) result[key] = obj[key];
    return result;
  }
  function defaultValue(...values) {
    for (const value of values) if (value !== void 0) return value;
  }
  var canUseDOM = checkIsBrowser();
  function checkIsBrowser() {
    return typeof window !== "undefined" && !!window.document?.createElement;
  }
  function getDocument(node2) {
    if (!node2) return document;
    if ("self" in node2) return node2.document;
    return node2.ownerDocument || document;
  }
  function getWindow(node2) {
    if (!node2) return self;
    if ("self" in node2) return node2.self;
    return getDocument(node2).defaultView || window;
  }
  function getActiveElement(node2, activeDescendant = false) {
    const { activeElement } = getDocument(node2);
    if (!activeElement?.nodeName) return null;
    if (isFrame(activeElement) && activeElement.contentDocument?.body) return getActiveElement(activeElement.contentDocument.body, activeDescendant);
    if (activeDescendant) {
      const id3 = activeElement.getAttribute("aria-activedescendant");
      if (id3) {
        const element = getDocument(activeElement).getElementById(id3);
        if (element) return element;
      }
    }
    return activeElement;
  }
  function contains(parent, child) {
    return parent === child || parent.contains(child);
  }
  function isElement(target) {
    return target?.nodeType === 1;
  }
  function isNode(target) {
    return typeof target?.nodeType === "number";
  }
  function isFrame(element) {
    return element.tagName === "IFRAME";
  }
  function isButton(element) {
    const tagName = element.tagName.toLowerCase();
    if (tagName === "button") return true;
    if (tagName === "input" && element.type) return buttonInputTypes.indexOf(element.type) !== -1;
    return false;
  }
  var buttonInputTypes = [
    "button",
    "color",
    "file",
    "image",
    "reset",
    "submit"
  ];
  function isVisible(element) {
    if (typeof element.checkVisibility === "function") return element.checkVisibility();
    const htmlElement = element;
    return htmlElement.offsetWidth > 0 || htmlElement.offsetHeight > 0 || element.getClientRects().length > 0;
  }
  function isTextField(element) {
    try {
      if (element.tagName === "TEXTAREA") return true;
      if (element.tagName !== "INPUT") return false;
      return element.selectionStart !== null;
    } catch (_error) {
      return false;
    }
  }
  function isTextbox(element) {
    return element.isContentEditable || isTextField(element);
  }
  function getTextboxValue(element) {
    if (isTextField(element)) return element.value;
    if (element.isContentEditable) {
      const range = getDocument(element).createRange();
      range.selectNodeContents(element);
      return range.toString();
    }
    return "";
  }
  function getTextboxSelection(element) {
    let start = 0;
    let end = 0;
    if (isTextField(element)) {
      start = element.selectionStart || 0;
      end = element.selectionEnd || 0;
    } else if (element.isContentEditable) {
      const selection = getDocument(element).getSelection();
      if (selection?.rangeCount && selection.anchorNode && contains(element, selection.anchorNode) && selection.focusNode && contains(element, selection.focusNode)) {
        const range = selection.getRangeAt(0);
        const nextRange = range.cloneRange();
        nextRange.selectNodeContents(element);
        nextRange.setEnd(range.startContainer, range.startOffset);
        start = nextRange.toString().length;
        nextRange.setEnd(range.endContainer, range.endOffset);
        end = nextRange.toString().length;
      }
    }
    return {
      start,
      end
    };
  }
  var allowedPopupRoles = [
    "dialog",
    "menu",
    "listbox",
    "tree",
    "grid"
  ];
  var itemRoleByPopupRole = {
    menu: "menuitem",
    listbox: "option",
    tree: "treeitem"
  };
  function getPopupRole(element, fallback) {
    const role = element?.getAttribute("role");
    if (role && allowedPopupRoles.indexOf(role) !== -1) return role;
    return fallback;
  }
  function getItemRoleByPopupRole(popupRole) {
    if (popupRole == null) return;
    if (!hasOwnProperty(itemRoleByPopupRole, popupRole)) return;
    return itemRoleByPopupRole[popupRole];
  }
  function getPopupItemRole(element, fallback) {
    const popupRole = getPopupRole(element);
    if (typeof popupRole !== "string") return fallback;
    return getItemRoleByPopupRole(popupRole) ?? fallback;
  }
  function getScrollingElement(element) {
    if (!element) return null;
    const isScrollableOverflow = (overflow) => {
      if (overflow === "auto") return true;
      if (overflow === "scroll") return true;
      return false;
    };
    if (element.clientHeight && element.scrollHeight > element.clientHeight) {
      const { overflowY } = getComputedStyle(element);
      if (isScrollableOverflow(overflowY)) return element;
    } else if (element.clientWidth && element.scrollWidth > element.clientWidth) {
      const { overflowX } = getComputedStyle(element);
      if (isScrollableOverflow(overflowX)) return element;
    }
    const doc = getDocument(element);
    return getScrollingElement(element.parentElement) || doc.scrollingElement || doc.body;
  }
  function sortBasedOnDOMPosition(items, getElement) {
    const pairs = items.map((item2, index2) => [index2, item2]);
    let isOrderDifferent = false;
    pairs.sort(([indexA, a3], [indexB, b3]) => {
      const elementA = getElement(a3);
      const elementB = getElement(b3);
      if (elementA === elementB) return 0;
      if (!elementA || !elementB) return 0;
      if (isElementPreceding(elementA, elementB)) {
        if (indexA > indexB) isOrderDifferent = true;
        return -1;
      }
      if (indexA < indexB) isOrderDifferent = true;
      return 1;
    });
    if (isOrderDifferent) return pairs.map(([_2, item2]) => item2);
    return items;
  }
  function isElementPreceding(a3, b3) {
    return Boolean(b3.compareDocumentPosition(a3) & Node.DOCUMENT_POSITION_PRECEDING);
  }
  function isTouchDevice() {
    return canUseDOM && !!navigator.maxTouchPoints;
  }
  function isApple() {
    if (!canUseDOM) return false;
    return /mac|iphone|ipad|ipod/i.test(navigator.platform);
  }
  function isSafari() {
    return canUseDOM && isApple() && /apple/i.test(navigator.vendor);
  }
  function isFirefox() {
    return canUseDOM && /firefox\//i.test(navigator.userAgent);
  }
  function isMac() {
    return canUseDOM && navigator.platform.startsWith("Mac") && !isTouchDevice();
  }
  function isPortalEvent(event) {
    const { currentTarget, target } = event;
    if (!currentTarget) return false;
    if (!isNode(target)) return true;
    return !contains(currentTarget, target);
  }
  function isSelfTarget(event) {
    return event.target === event.currentTarget;
  }
  function isActivatableNavigationTarget(element) {
    if (!isElement(element)) return false;
    const target = element;
    const tagName = target.tagName.toLowerCase();
    if (tagName === "a") return true;
    if (tagName === "button" && target.type === "submit") return true;
    if (tagName === "input" && target.type === "submit") return true;
    return false;
  }
  function isOpeningInNewTab(event) {
    const isAppleDevice = isApple();
    if (isAppleDevice && !event.metaKey) return false;
    if (!isAppleDevice && !event.ctrlKey) return false;
    return isActivatableNavigationTarget(event.currentTarget);
  }
  function isDownloading(event) {
    if (!event.altKey) return false;
    return isActivatableNavigationTarget(event.currentTarget);
  }
  function fireEvent(element, type, eventInit) {
    const event = new Event(type, eventInit);
    return element.dispatchEvent(event);
  }
  function fireBlurEvent(element, eventInit) {
    const event = new FocusEvent("blur", eventInit);
    const defaultAllowed = element.dispatchEvent(event);
    const bubbleInit = {
      ...eventInit,
      bubbles: true
    };
    element.dispatchEvent(new FocusEvent("focusout", bubbleInit));
    return defaultAllowed;
  }
  function fireKeyboardEvent(element, type, eventInit) {
    const event = new KeyboardEvent(type, eventInit);
    return element.dispatchEvent(event);
  }
  function fireClickEvent(element, eventInit) {
    const event = new MouseEvent("click", eventInit);
    return element.dispatchEvent(event);
  }
  function isFocusEventOutside(event, container) {
    const containerElement = container || event.currentTarget;
    const relatedTarget = event.relatedTarget;
    return !isNode(relatedTarget) || !contains(containerElement, relatedTarget);
  }
  function queueBeforeEvent(element, type, callback, timeout) {
    const createTimer = (callback2) => {
      if (timeout) {
        const timerId2 = setTimeout(callback2, timeout);
        return () => clearTimeout(timerId2);
      }
      const timerId = requestAnimationFrame(callback2);
      return () => cancelAnimationFrame(timerId);
    };
    const cancelTimer = createTimer(() => {
      element.removeEventListener(type, callSync, true);
      callback();
    });
    const callSync = () => {
      cancelTimer();
      callback();
    };
    element.addEventListener(type, callSync, {
      once: true,
      capture: true
    });
    return () => {
      cancelTimer();
      element.removeEventListener(type, callSync, true);
    };
  }
  function addGlobalEventListener(type, listener, options2, scope = window) {
    const children = [];
    try {
      scope.document.addEventListener(type, listener, options2);
      for (const frame2 of Array.from(scope.frames)) children.push(addGlobalEventListener(type, listener, options2, frame2));
    } catch {
    }
    const removeEventListener = () => {
      try {
        scope.document.removeEventListener(type, listener, options2);
      } catch {
      }
      for (const remove of children) remove();
    };
    return removeEventListener;
  }
  var selector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], summary, iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false'])";
  function hasNegativeTabIndex(element) {
    return Number.parseInt(element.getAttribute("tabindex") || "0", 10) < 0;
  }
  function isFocusable(element) {
    if (!element.matches(selector)) return false;
    if (!isVisible(element)) return false;
    if (element.closest("[inert]")) return false;
    return true;
  }
  function isTabbable(element) {
    if (!isFocusable(element)) return false;
    if (hasNegativeTabIndex(element)) return false;
    if (!("form" in element)) return true;
    if (!element.form) return true;
    if (element.checked) return true;
    if (element.type !== "radio") return true;
    const radioGroup = element.form.elements.namedItem(element.name);
    if (!radioGroup) return true;
    if (!("length" in radioGroup)) return true;
    const activeElement = getActiveElement(element);
    if (!activeElement) return true;
    if (activeElement === element) return true;
    if (!("form" in activeElement)) return true;
    if (activeElement.form !== element.form) return true;
    if (activeElement.name !== element.name) return true;
    return false;
  }
  function getAllFocusableIn(container, includeContainer) {
    const elements2 = Array.from(container.querySelectorAll(selector));
    if (includeContainer) elements2.unshift(container);
    const focusableElements2 = elements2.filter(isFocusable);
    focusableElements2.forEach((element, i3) => {
      if (!isFrame(element)) return;
      const frameBody = element.contentDocument?.body;
      if (!frameBody) return;
      focusableElements2.splice(i3, 1, ...getAllFocusableIn(frameBody));
    });
    return focusableElements2;
  }
  function getFirstFocusableIn(container, includeContainer) {
    const [first] = getAllFocusableIn(container, includeContainer);
    return first || null;
  }
  function getAllTabbableIn(container, includeContainer, fallbackToFocusable) {
    const tabbableElements = Array.from(container.querySelectorAll(selector)).filter(isTabbable);
    if (includeContainer && isTabbable(container)) tabbableElements.unshift(container);
    tabbableElements.forEach((element, i3) => {
      if (!isFrame(element)) return;
      const frameBody = element.contentDocument?.body;
      if (!frameBody) return;
      const allFrameTabbable = getAllTabbableIn(frameBody, false, fallbackToFocusable);
      tabbableElements.splice(i3, 1, ...allFrameTabbable);
    });
    if (!tabbableElements.length && fallbackToFocusable) return getAllFocusableIn(container);
    return tabbableElements;
  }
  function getFirstTabbableIn(container, includeContainer, fallbackToFocusable) {
    if (includeContainer && isTabbable(container)) {
      if (!isFrame(container)) return container;
      const containerFrameBody = container.contentDocument?.body;
      if (!containerFrameBody) return container;
      const frameTabbable = getFirstTabbableIn(containerFrameBody, false, fallbackToFocusable);
      if (frameTabbable) return frameTabbable;
    }
    const elements2 = container.querySelectorAll(selector);
    for (const element of elements2) {
      if (!isTabbable(element)) continue;
      if (isFrame(element)) {
        const frameBody = element.contentDocument?.body;
        if (!frameBody) return element;
        const frameTabbable = getFirstTabbableIn(frameBody, false, fallbackToFocusable);
        if (frameTabbable) return frameTabbable;
        continue;
      }
      return element;
    }
    if (fallbackToFocusable) return getFirstFocusableIn(container);
    return null;
  }
  function getTabbableInDirection({ container, includeContainer, reverse, fallbackToEdge, fallbackToFocusable }) {
    const activeElement = getActiveElement(container);
    const allFocusable = getAllFocusableIn(container, includeContainer);
    if (reverse) allFocusable.reverse();
    const activeIndex = allFocusable.indexOf(activeElement);
    const candidates = allFocusable.slice(activeIndex + 1);
    return candidates.find(isTabbable) || (fallbackToEdge ? allFocusable.find(isTabbable) : null) || (fallbackToFocusable ? candidates[0] : null) || null;
  }
  function getNextTabbableIn(container, includeContainer, fallbackToFirst, fallbackToFocusable) {
    return getTabbableInDirection({
      container,
      includeContainer,
      fallbackToEdge: fallbackToFirst,
      fallbackToFocusable
    });
  }
  function getNextTabbable(fallbackToFirst, fallbackToFocusable) {
    return getNextTabbableIn(document.body, false, fallbackToFirst, fallbackToFocusable);
  }
  function getPreviousTabbableIn(container, includeContainer, fallbackToLast, fallbackToFocusable) {
    return getTabbableInDirection({
      container,
      includeContainer,
      reverse: true,
      fallbackToEdge: fallbackToLast,
      fallbackToFocusable
    });
  }
  function getPreviousTabbable(fallbackToLast, fallbackToFocusable) {
    return getPreviousTabbableIn(document.body, false, fallbackToLast, fallbackToFocusable);
  }
  function hasFocus(element) {
    const activeElement = getActiveElement(element);
    if (!activeElement) return false;
    if (activeElement === element) return true;
    const activeDescendant = activeElement.getAttribute("aria-activedescendant");
    if (!activeDescendant) return false;
    return activeDescendant === element.id;
  }
  function hasFocusWithin(element) {
    const activeElement = getActiveElement(element);
    if (!activeElement) return false;
    if (contains(element, activeElement)) return true;
    const activeDescendant = activeElement.getAttribute("aria-activedescendant");
    if (!activeDescendant) return false;
    if (!("id" in element)) return false;
    if (activeDescendant === element.id) return true;
    return !!element.querySelector(`#${CSS.escape(activeDescendant)}`);
  }
  function disableFocus(element) {
    const currentTabindex = element.getAttribute("tabindex") ?? "";
    element.setAttribute("data-tabindex", currentTabindex);
    element.setAttribute("tabindex", "-1");
  }
  function disableFocusIn(container, includeContainer) {
    const tabbableElements = getAllTabbableIn(container, includeContainer);
    for (const element of tabbableElements) disableFocus(element);
  }
  function restoreFocusIn(container) {
    const elements2 = container.querySelectorAll("[data-tabindex]");
    const restoreTabIndex = (element) => {
      const tabindex = element.getAttribute("data-tabindex");
      element.removeAttribute("data-tabindex");
      if (tabindex) element.setAttribute("tabindex", tabindex);
      else element.removeAttribute("tabindex");
    };
    if (container.hasAttribute("data-tabindex")) restoreTabIndex(container);
    for (const element of elements2) restoreTabIndex(element);
  }
  function focusIntoView(element, options2) {
    if (!("scrollIntoView" in element)) element.focus();
    else {
      element.focus({ preventScroll: true });
      element.scrollIntoView({
        block: "nearest",
        inline: "nearest",
        ...options2
      });
    }
  }
  function createUndoCallback(callback) {
    return async () => {
      const redo = await callback?.();
      return createUndoCallback(async () => {
        await redo?.();
        return callback;
      });
    };
  }
  var UndoManager = createUndoManager();
  function createUndoManager({ limit = 100 } = {}) {
    const undoStack = [];
    let redoStack = [];
    let currentGroup = null;
    const canUndo = () => undoStack.length > 0;
    const canRedo = () => redoStack.length > 0;
    const undo = async () => {
      if (!canUndo()) return;
      currentGroup = null;
      redoStack.push(await undoStack.pop()?.());
    };
    const redo = async () => {
      if (!canRedo()) return;
      currentGroup = null;
      undoStack.push(await redoStack.pop()?.());
    };
    const execute = async (callback, group) => {
      if (!callback) return;
      const sameGroup = group === currentGroup;
      currentGroup = group ?? null;
      const nextIndex = sameGroup ? Math.max(0, undoStack.length - 1) : undoStack.length;
      const undoCallback = await callback();
      if (!undoCallback) return;
      redoStack = [];
      const currentUndo = undoStack[nextIndex];
      undoStack[nextIndex] = createUndoCallback(async () => {
        await undoCallback?.();
        const currentRedo = await currentUndo?.();
        return async () => {
          await currentRedo?.();
          await callback?.();
        };
      });
      while (undoStack.length > limit) undoStack.shift();
    };
    return {
      canUndo,
      canRedo,
      undo,
      redo,
      execute
    };
  }

  // node_modules/@ariakit/react-utils/dist/index.js
  var React = __toESM(require_react(), 1);
  var import_react2 = __toESM(require_react(), 1);
  var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
  function setRef(ref, value) {
    if (typeof ref === "function") {
      const cleanup = ref(value);
      if (typeof cleanup === "function") return cleanup;
    } else if (ref) ref.current = value;
  }
  function isValidElementWithRef(element) {
    if (!element) return false;
    if (!(0, import_react2.isValidElement)(element)) return false;
    if ("ref" in element.props) return true;
    if ("ref" in element) return true;
    return false;
  }
  function getRefProperty(element) {
    if (!isValidElementWithRef(element)) return null;
    return { ...element.props }.ref || element.ref;
  }
  function mergeProps(base, overrides) {
    const props = { ...base };
    for (const key in overrides) {
      if (!hasOwnProperty(overrides, key)) continue;
      if (key === "className") {
        const prop = "className";
        const baseClass = base[prop];
        const overrideClass = overrides[prop];
        if (baseClass && overrideClass) props[prop] = `${baseClass} ${overrideClass}`;
        else props[prop] = overrideClass || baseClass;
        continue;
      }
      if (key === "style") {
        const prop = "style";
        props[prop] = base[prop] ? {
          ...base[prop],
          ...overrides[prop]
        } : overrides[prop];
        continue;
      }
      const overrideValue = overrides[key];
      if (key.startsWith("on")) {
        if (typeof overrideValue !== "function") continue;
        const baseValue = base[key];
        if (typeof baseValue === "function") {
          props[key] = (...args) => {
            overrideValue(...args);
            baseValue(...args);
          };
          continue;
        }
      }
      props[key] = overrideValue;
    }
    return props;
  }
  var _React = { ...React };
  var useReactId = _React.useId;
  var useReactDeferredValue = _React.useDeferredValue;
  var useReactInsertionEffect = _React.useInsertionEffect;
  var useSafeLayoutEffect = canUseDOM ? import_react2.useLayoutEffect : import_react2.useEffect;
  function useInitialValue(value) {
    const [initialValue2] = (0, import_react2.useState)(value);
    return initialValue2;
  }
  function useLiveRef(value) {
    const ref = (0, import_react2.useRef)(value);
    useSafeLayoutEffect(() => {
      ref.current = value;
    });
    return ref;
  }
  function useEvent(callback) {
    const ref = (0, import_react2.useRef)(() => {
      throw new Error("Cannot call an event handler while rendering.");
    });
    if (useReactInsertionEffect) useReactInsertionEffect(() => {
      ref.current = callback;
    });
    else ref.current = callback;
    return (0, import_react2.useCallback)((...args) => ref.current?.(...args), []);
  }
  function useTransactionState(callback) {
    const [state, setState] = (0, import_react2.useState)(null);
    useSafeLayoutEffect(() => {
      if (state == null) return;
      if (!callback) return;
      let prevState = null;
      callback((prev2) => {
        prevState = prev2;
        return state;
      });
      return () => {
        callback(prevState);
      };
    }, [state, callback]);
    return [state, setState];
  }
  function useMergeRefs(...refs) {
    return (0, import_react2.useMemo)(() => {
      if (!refs.some(Boolean)) return;
      return (value) => {
        const refEffects = [];
        for (const ref of refs) {
          if (!ref) continue;
          const cleanup = setRef(ref, value);
          refEffects.push({
            ref,
            cleanup: typeof cleanup === "function" ? cleanup : void 0
          });
        }
        if (!refEffects.some((effect) => effect.cleanup)) return;
        return () => {
          for (const { ref, cleanup } of refEffects) if (cleanup) cleanup();
          else setRef(ref, null);
        };
      };
    }, refs);
  }
  function useId(defaultId) {
    if (useReactId) {
      const reactId = useReactId();
      if (defaultId) return defaultId;
      return reactId;
    }
    const [id3, setId] = (0, import_react2.useState)(defaultId);
    useSafeLayoutEffect(() => {
      if (defaultId || id3) return;
      setId(`id-${Math.random().toString(36).slice(2, 8)}`);
    }, [defaultId, id3]);
    return defaultId || id3;
  }
  function useTagName(refOrElement, type) {
    const stringOrUndefined = (type2) => {
      if (typeof type2 !== "string") return;
      return type2;
    };
    const [tagName, setTagName] = (0, import_react2.useState)(() => stringOrUndefined(type));
    useSafeLayoutEffect(() => {
      setTagName((refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement)?.tagName.toLowerCase() || stringOrUndefined(type));
    }, [refOrElement, type]);
    return tagName;
  }
  function useUpdateEffect(effect, deps) {
    const mounted = (0, import_react2.useRef)(false);
    (0, import_react2.useEffect)(() => {
      if (mounted.current) return effect();
      mounted.current = true;
    }, deps);
    (0, import_react2.useEffect)(() => () => {
      mounted.current = false;
    }, []);
  }
  function useForceUpdate() {
    return (0, import_react2.useReducer)(() => [], []);
  }
  function useBooleanEvent(booleanOrCallback) {
    return useEvent(typeof booleanOrCallback === "function" ? booleanOrCallback : () => booleanOrCallback);
  }
  function useWrapElement(props, callback, deps = []) {
    const wrapElement = (0, import_react2.useCallback)((element) => {
      if (props.wrapElement) element = props.wrapElement(element);
      return callback(element);
    }, [...deps, props.wrapElement]);
    return {
      ...props,
      wrapElement
    };
  }
  function usePortalRef(portalProp = false, portalRefProp) {
    const [portalNode, setPortalNode] = (0, import_react2.useState)(null);
    return {
      portalRef: useMergeRefs(setPortalNode, portalRefProp),
      portalNode,
      domReady: !portalProp || portalNode
    };
  }
  function useMetadataProps(props, key, value) {
    const parent = props.onLoadedMetadataCapture;
    const onLoadedMetadataCapture = (0, import_react2.useMemo)(() => {
      return Object.assign(() => {
      }, parent, ...value !== void 0 ? [{ [key]: value }] : []);
    }, [
      parent,
      key,
      value
    ]);
    return [parent?.[key], { onLoadedMetadataCapture }];
  }
  var hasInstalledGlobalEventListeners = false;
  function useIsMouseMoving() {
    (0, import_react2.useEffect)(() => {
      if (hasInstalledGlobalEventListeners) return;
      addGlobalEventListener("mousemove", setMouseMoving, true);
      addGlobalEventListener("mousedown", resetMouseMoving, true);
      addGlobalEventListener("mouseup", resetMouseMoving, true);
      addGlobalEventListener("keydown", resetMouseMoving, true);
      addGlobalEventListener("scroll", resetMouseMoving, true);
      hasInstalledGlobalEventListeners = true;
    }, []);
    return useEvent(() => mouseMoving);
  }
  var mouseMoving = false;
  var previousScreenX = 0;
  var previousScreenY = 0;
  function hasMouseMovement(event) {
    const movementX = event.movementX || event.screenX - previousScreenX;
    const movementY = event.movementY || event.screenY - previousScreenY;
    previousScreenX = event.screenX;
    previousScreenY = event.screenY;
    return movementX || movementY || false;
  }
  function setMouseMoving(event) {
    if (!hasMouseMovement(event)) return;
    mouseMoving = true;
  }
  function resetMouseMoving() {
    mouseMoving = false;
  }
  function forwardRef2(render) {
    const Role3 = React.forwardRef((props, ref) => render({
      ...props,
      ref
    }));
    Role3.displayName = render.displayName || render.name;
    return Role3;
  }
  function memo2(Component7, propsAreEqual) {
    return React.memo(Component7, propsAreEqual);
  }
  function createElement(Type, props) {
    const { wrapElement, render, ...rest } = props;
    const mergedRef = useMergeRefs(props.ref, getRefProperty(render));
    let element;
    if (React.isValidElement(render)) {
      const renderProps = {
        ...render.props,
        ref: mergedRef
      };
      element = React.cloneElement(render, mergeProps(rest, renderProps));
    } else if (render) element = render(rest);
    else element = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Type, { ...rest });
    if (wrapElement) return wrapElement(element);
    return element;
  }
  function createHook(useProps) {
    const useRole3 = (props = {}) => {
      return useProps(props);
    };
    useRole3.displayName = useProps.name;
    return useRole3;
  }
  function createStoreContext(providers = [], scopedProviders = []) {
    const context = React.createContext(void 0);
    const scopedContext = React.createContext(void 0);
    const useContext66 = () => React.useContext(context);
    const useScopedContext = (onlyScoped = false) => {
      const scoped = React.useContext(scopedContext);
      const store = useContext66();
      if (onlyScoped) return scoped;
      return scoped || store;
    };
    const useProviderContext = () => {
      const scoped = React.useContext(scopedContext);
      const store = useContext66();
      if (scoped && scoped === store) return;
      return store;
    };
    const ContextProvider = (props) => {
      return providers.reduceRight((children, Provider4) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Provider4, {
        ...props,
        children
      }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(context.Provider, { ...props }));
    };
    const ScopedContextProvider = (props) => {
      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContextProvider, {
        ...props,
        children: scopedProviders.reduceRight((children, Provider4) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Provider4, {
          ...props,
          children
        }), /* @__PURE__ */ (0, import_jsx_runtime.jsx)(scopedContext.Provider, { ...props }))
      });
    };
    return {
      context,
      scopedContext,
      useContext: useContext66,
      useScopedContext,
      useProviderContext,
      ContextProvider,
      ScopedContextProvider
    };
  }

  // node_modules/@ariakit/react-components/dist/focusable/focusable.js
  var import_react3 = __toESM(require_react(), 1);
  var TagName = "div";
  var accessibleWhenDisabledSymbol = /* @__PURE__ */ Symbol("accessibleWhenDisabled");
  var isSafariBrowser = isSafari();
  var alwaysFocusVisibleInputTypes = [
    "text",
    "search",
    "url",
    "tel",
    "email",
    "password",
    "number",
    "date",
    "month",
    "week",
    "time",
    "datetime",
    "datetime-local"
  ];
  function isAlwaysFocusVisible(element) {
    const { tagName, readOnly, type } = element;
    if (tagName === "TEXTAREA" && !readOnly) return true;
    if (tagName === "SELECT" && !readOnly) return true;
    if (tagName === "INPUT" && !readOnly) return alwaysFocusVisibleInputTypes.includes(type);
    if (element.isContentEditable) return true;
    if (element.getAttribute("role") === "combobox" && element.dataset.name) return true;
    return false;
  }
  function isNativeTabbable(tagName) {
    if (!tagName) return true;
    return tagName === "button" || tagName === "summary" || tagName === "input" || tagName === "select" || tagName === "textarea" || tagName === "a";
  }
  function supportsDisabledAttribute(tagName) {
    if (!tagName) return true;
    return tagName === "button" || tagName === "input" || tagName === "select" || tagName === "textarea";
  }
  function isNativeSubmitControl(element) {
    if (element.tagName === "BUTTON") {
      const { type } = element;
      return type === "submit";
    }
    if (element.tagName === "INPUT") {
      const { type } = element;
      return type === "submit" || type === "image";
    }
    return false;
  }
  function getTabIndex({ focusable, trulyDisabled, nativeTabbable, supportsDisabled, safariTabIndex, tabIndexProp }) {
    if (!focusable) return tabIndexProp;
    if (trulyDisabled) {
      if (nativeTabbable && !supportsDisabled) return -1;
      return;
    }
    if (nativeTabbable) {
      if (safariTabIndex && tabIndexProp == null) return 0;
      return tabIndexProp;
    }
    return tabIndexProp ?? 0;
  }
  function useDisableEvent(onEvent, disabled) {
    return useEvent((event) => {
      onEvent?.(event);
      if (event.defaultPrevented) return;
      if (disabled) {
        event.stopPropagation();
        event.preventDefault();
      }
    });
  }
  var hasInstalledGlobalEventListeners2 = false;
  var isKeyboardModality = true;
  function onGlobalMouseDown(event) {
    const target = event.target;
    if (isElement(target) && !target.hasAttribute("data-focus-visible")) isKeyboardModality = false;
  }
  function onGlobalKeyDown(event) {
    if (event.metaKey) return;
    if (event.ctrlKey) return;
    if (event.altKey) return;
    isKeyboardModality = true;
  }
  var useFocusable = createHook(function useFocusable2({ focusable = true, accessibleWhenDisabled, autoFocus, onFocusVisible, ...props }) {
    const ref = (0, import_react3.useRef)(null);
    const [parentAccessibleWhenDisabled, metadataProps] = useMetadataProps(props, accessibleWhenDisabledSymbol, accessibleWhenDisabled);
    accessibleWhenDisabled ??= parentAccessibleWhenDisabled;
    (0, import_react3.useEffect)(() => {
      if (!focusable) return;
      if (hasInstalledGlobalEventListeners2) return;
      addGlobalEventListener("mousedown", onGlobalMouseDown, true);
      addGlobalEventListener("keydown", onGlobalKeyDown, true);
      hasInstalledGlobalEventListeners2 = true;
    }, [focusable]);
    const disabled = focusable && disabledFromProps(props);
    const trulyDisabled = disabled && !accessibleWhenDisabled;
    const [focusVisible, setFocusVisible] = (0, import_react3.useState)(false);
    const focusVisibleRef = (0, import_react3.useRef)(false);
    const nativeSubmitObserverCleanupRef = (0, import_react3.useRef)(null);
    const cleanupFocusVisible = useEvent((element) => {
      nativeSubmitObserverCleanupRef.current?.();
      nativeSubmitObserverCleanupRef.current = null;
      focusVisibleRef.current = false;
      element?.removeAttribute("data-focus-visible");
    });
    (0, import_react3.useEffect)(() => {
      if (!focusable) return;
      if (!trulyDisabled) return;
      cleanupFocusVisible(ref.current);
      if (focusVisible) setFocusVisible(false);
    }, [
      focusable,
      trulyDisabled,
      focusVisible,
      cleanupFocusVisible
    ]);
    (0, import_react3.useEffect)(() => {
      if (!focusable) return;
      if (!focusVisible) return;
      const element = ref.current;
      if (!element) return;
      if (typeof IntersectionObserver === "undefined") return;
      const observer = new IntersectionObserver(() => {
        if (!isFocusable(element)) {
          focusVisibleRef.current = false;
          setFocusVisible(false);
        }
      });
      observer.observe(element);
      return () => observer.disconnect();
    }, [focusable, focusVisible]);
    (0, import_react3.useEffect)(() => {
      return () => nativeSubmitObserverCleanupRef.current?.();
    }, []);
    const onKeyPressCapture = useDisableEvent(props.onKeyPressCapture, disabled);
    const onMouseDownCapture = useDisableEvent(props.onMouseDownCapture, disabled);
    const onClickCapture = useDisableEvent(props.onClickCapture, disabled);
    const handleFocusVisible = (event, currentTarget) => {
      if (currentTarget) event.currentTarget = currentTarget;
      if (!focusable) return;
      const element = event.currentTarget;
      if (!element) return;
      if (!hasFocus(element)) return;
      onFocusVisible?.(event);
      if (event.defaultPrevented) return;
      element.dataset.focusVisible = "true";
      focusVisibleRef.current = true;
      if (isNativeSubmitControl(element)) {
        nativeSubmitObserverCleanupRef.current?.();
        nativeSubmitObserverCleanupRef.current = null;
        if (typeof IntersectionObserver !== "undefined") {
          const observer = new IntersectionObserver(() => {
            if (isFocusable(element)) return;
            cleanupFocusVisible(element);
          });
          observer.observe(element);
          nativeSubmitObserverCleanupRef.current = () => observer.disconnect();
        }
        return;
      }
      setFocusVisible(true);
    };
    const onKeyDownCaptureProp = props.onKeyDownCapture;
    const onKeyDownCapture = useEvent((event) => {
      onKeyDownCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (!focusable) return;
      if (focusVisible) return;
      if (focusVisibleRef.current) return;
      if (event.metaKey) return;
      if (event.altKey) return;
      if (event.ctrlKey) return;
      if (!isSelfTarget(event)) return;
      const element = event.currentTarget;
      const applyFocusVisible = () => handleFocusVisible(event, element);
      queueBeforeEvent(element, "focusout", applyFocusVisible);
    });
    const onFocusCaptureProp = props.onFocusCapture;
    const onFocusCapture = useEvent((event) => {
      onFocusCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (!focusable) return;
      if (!isSelfTarget(event)) {
        setFocusVisible(false);
        return;
      }
      const element = event.currentTarget;
      const applyFocusVisible = () => handleFocusVisible(event, element);
      if (isKeyboardModality || isAlwaysFocusVisible(event.target)) queueBeforeEvent(event.target, "focusout", applyFocusVisible);
      else setFocusVisible(false);
    });
    const onBlurProp = props.onBlur;
    const onBlur = useEvent((event) => {
      onBlurProp?.(event);
      if (!focusable) return;
      if (!isFocusEventOutside(event)) return;
      cleanupFocusVisible(event.currentTarget);
      setFocusVisible(false);
    });
    const autoFocusOnShow = (0, import_react3.useContext)(FocusableContext);
    const autoFocusRef = useEvent((element) => {
      if (!focusable) return;
      if (!autoFocus) return;
      if (!element) return;
      if (!autoFocusOnShow) return;
      queueMicrotask(() => {
        if (hasFocus(element)) return;
        if (!isFocusable(element)) return;
        element.focus();
      });
    });
    const tagName = useTagName(ref);
    const nativeTabbable = focusable && isNativeTabbable(tagName);
    const supportsDisabled = focusable && supportsDisabledAttribute(tagName);
    const [safariTabIndex, setSafariTabIndex] = (0, import_react3.useState)(false);
    if (isSafariBrowser) (0, import_react3.useEffect)(() => {
      if (!focusable) return;
      const element = ref.current;
      if (!element) return;
      const { type } = element;
      const isNativeCheckboxOrRadio = element.tagName === "INPUT" && (type === "checkbox" || type === "radio");
      setSafariTabIndex(isButton(element) || isNativeCheckboxOrRadio);
    }, [focusable]);
    const styleProp = props.style;
    const style2 = (0, import_react3.useMemo)(() => {
      if (trulyDisabled) return {
        pointerEvents: "none",
        ...styleProp
      };
      return styleProp;
    }, [trulyDisabled, styleProp]);
    props = {
      "data-focus-visible": focusable && focusVisible || void 0,
      "data-autofocus": autoFocus || void 0,
      "aria-disabled": disabled || void 0,
      ...props,
      ...metadataProps,
      ref: useMergeRefs(ref, autoFocusRef, props.ref),
      style: style2,
      tabIndex: getTabIndex({
        focusable,
        trulyDisabled,
        nativeTabbable,
        supportsDisabled,
        safariTabIndex,
        tabIndexProp: props.tabIndex
      }),
      disabled: supportsDisabled && trulyDisabled ? true : void 0,
      contentEditable: disabled ? void 0 : props.contentEditable,
      onKeyPressCapture,
      onClickCapture,
      onMouseDownCapture,
      onKeyDownCapture,
      onFocusCapture,
      onBlur
    };
    return removeUndefinedValues(props);
  });
  var Focusable = forwardRef2(function Focusable2(props) {
    return createElement(TagName, useFocusable(props));
  });

  // node_modules/@ariakit/react-components/dist/command/command.js
  var import_react4 = __toESM(require_react(), 1);
  var TagName2 = "button";
  function isNativeClick(event) {
    if (!event.isTrusted) return false;
    const element = event.currentTarget;
    if (event.key === "Enter") return isButton(element) || element.tagName === "SUMMARY" || element.tagName === "A";
    if (event.key === " ") return isButton(element) || element.tagName === "SUMMARY" || element.tagName === "INPUT" || element.tagName === "SELECT";
    return false;
  }
  var symbol = /* @__PURE__ */ Symbol("command");
  var useCommand = createHook(function useCommand2({ clickOnEnter = true, clickOnSpace = true, ...props }) {
    const ref = (0, import_react4.useRef)(null);
    const [isNativeButton, setIsNativeButton] = (0, import_react4.useState)(false);
    (0, import_react4.useEffect)(() => {
      if (!ref.current) return;
      setIsNativeButton(isButton(ref.current));
    }, []);
    const [active, setActive] = (0, import_react4.useState)(false);
    const activeRef = (0, import_react4.useRef)(false);
    const disabled = disabledFromProps(props);
    const [isDuplicate, metadataProps] = useMetadataProps(props, symbol, true);
    useSafeLayoutEffect(() => {
      if (!disabled) return;
      activeRef.current = false;
      setActive(false);
    }, [disabled]);
    const onKeyDownProp = props.onKeyDown;
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      const element = event.currentTarget;
      if (event.defaultPrevented) return;
      if (isDuplicate) return;
      if (disabled) return;
      if (!isSelfTarget(event)) return;
      if (isTextField(element)) return;
      if (element.isContentEditable) return;
      const isEnter = clickOnEnter && event.key === "Enter";
      const isSpace = clickOnSpace && event.key === " ";
      const shouldPreventEnter = event.key === "Enter" && !clickOnEnter;
      const shouldPreventSpace = event.key === " " && !clickOnSpace;
      if (shouldPreventEnter || shouldPreventSpace) {
        event.preventDefault();
        return;
      }
      if (isEnter || isSpace) {
        const nativeClick = isNativeClick(event);
        if (isEnter) {
          if (!nativeClick) {
            event.preventDefault();
            const { view, ...eventInit } = event;
            const click = () => fireClickEvent(element, eventInit);
            if (isFirefox()) queueBeforeEvent(element, "keyup", click);
            else queueMicrotask(click);
          }
        } else if (isSpace) {
          activeRef.current = true;
          if (!nativeClick) {
            event.preventDefault();
            setActive(true);
          }
        }
      }
    });
    const onKeyUpProp = props.onKeyUp;
    const onKeyUp = useEvent((event) => {
      onKeyUpProp?.(event);
      if (isDuplicate) return;
      const isSpace = clickOnSpace && event.key === " ";
      if (!activeRef.current || !isSpace) return;
      const nativeClick = isNativeClick(event);
      activeRef.current = false;
      if (!nativeClick) setActive(false);
      if (event.defaultPrevented) return;
      if (!isSelfTarget(event)) return;
      if (disabled) return;
      if (event.metaKey) return;
      if (nativeClick) return;
      event.preventDefault();
      const element = event.currentTarget;
      const { view, ...eventInit } = event;
      queueMicrotask(() => fireClickEvent(element, eventInit));
    });
    const onBlurProp = props.onBlur;
    const onBlur = useEvent((event) => {
      onBlurProp?.(event);
      if (!activeRef.current) return;
      activeRef.current = false;
      setActive(false);
    });
    props = {
      "data-active": active || void 0,
      type: isNativeButton ? "button" : void 0,
      ...metadataProps,
      ...props,
      ref: useMergeRefs(ref, props.ref),
      onKeyDown,
      onKeyUp,
      onBlur
    };
    props = useFocusable(props);
    return props;
  });
  var Command = forwardRef2(function Command2(props) {
    return createElement(TagName2, useCommand(props));
  });

  // node_modules/@ariakit/react-components/dist/collection/collection-context.js
  var ctx = createStoreContext();
  var useCollectionContext = ctx.useContext;
  var useCollectionScopedContext = ctx.useScopedContext;
  var useCollectionProviderContext = ctx.useProviderContext;
  var CollectionContextProvider = ctx.ContextProvider;
  var CollectionScopedContextProvider = ctx.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/collection/collection-item.js
  var import_react5 = __toESM(require_react(), 1);
  var TagName3 = "div";
  var useCollectionItem = createHook(function useCollectionItem2({ store, shouldRegisterItem = true, getItem = identity, element, ...props }) {
    const context = useCollectionContext();
    store = store || context;
    const id3 = useId(props.id);
    const ref = (0, import_react5.useRef)(element);
    (0, import_react5.useEffect)(() => {
      const element2 = ref.current;
      if (!id3) return;
      if (!element2) return;
      if (!shouldRegisterItem) return;
      const item2 = getItem({
        id: id3,
        element: element2
      });
      return store?.renderItem(item2);
    }, [
      id3,
      shouldRegisterItem,
      getItem,
      store
    ]);
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref)
    };
    return removeUndefinedValues(props);
  });
  var CollectionItem = forwardRef2(function CollectionItem2(props) {
    return createElement(TagName3, useCollectionItem(props));
  });

  // node_modules/@ariakit/react-components/dist/composite/composite-context.js
  var import_react6 = __toESM(require_react(), 1);
  var ctx2 = createStoreContext([CollectionContextProvider], [CollectionScopedContextProvider]);
  var useCompositeContext = ctx2.useContext;
  var useCompositeScopedContext = ctx2.useScopedContext;
  var useCompositeProviderContext = ctx2.useProviderContext;
  var CompositeContextProvider = ctx2.ContextProvider;
  var CompositeScopedContextProvider = ctx2.ScopedContextProvider;
  var CompositeItemContext = (0, import_react6.createContext)(void 0);
  var CompositeRowContext = (0, import_react6.createContext)(void 0);

  // node_modules/@ariakit/store/dist/index.js
  function getInternal(store, key) {
    const internals = store.__unstableInternals;
    invariant(internals, "Invalid store");
    return internals[key];
  }
  function hasUpdatedKey(keys, updatedKey) {
    if (!keys) return true;
    for (const currentKey of keys) if (updatedKey instanceof Set) {
      if (updatedKey.has(currentKey)) return true;
    } else if (currentKey === updatedKey) return true;
    return false;
  }
  function isSameValue(value, other) {
    return value === other || value !== value && other !== other;
  }
  function getCleanupPrevState(prevState, state, stateBeforeCleanup, updatedKey) {
    let cleanupPrevState;
    for (const key of getKeys(state)) {
      if (isSameValue(state[key], stateBeforeCleanup[key])) continue;
      if (updatedKey !== void 0 && hasUpdatedKey([key], updatedKey)) continue;
      cleanupPrevState ??= { ...prevState };
      cleanupPrevState[key] = state[key];
    }
    return cleanupPrevState;
  }
  var MAX_REPAIR_PASSES = 100;
  function addKeyedListener(map, keys, listener) {
    if (!keys) return;
    for (const key of keys) {
      let listeners = map.get(key);
      if (!listeners) {
        listeners = /* @__PURE__ */ new Set();
        map.set(key, listeners);
      }
      listeners.add(listener);
    }
  }
  function deleteKeyedListener(map, keys, listener) {
    if (!map) return;
    if (!keys) return;
    for (const key of keys) {
      const listeners = map.get(key);
      if (!listeners) continue;
      listeners.delete(listener);
      if (!listeners.size) map.delete(key);
    }
  }
  function getFastPathNotifiedListeners(frame2) {
    const notifiedListeners = /* @__PURE__ */ new Set();
    const currentListener = frame2.currentListener;
    if (!currentListener) return notifiedListeners;
    for (const listener of frame2.keyedListeners) {
      notifiedListeners.add(listener);
      if (listener === currentListener) return notifiedListeners;
    }
    notifiedListeners.clear();
    notifiedListeners.add(currentListener);
    return notifiedListeners;
  }
  function preserveFastPathNotifiedListeners(frame2) {
    frame2.notifiedListeners ??= getFastPathNotifiedListeners(frame2);
  }
  function hasFastPathPassedListener(frame2, listener) {
    if (!frame2.currentListener) return false;
    let foundCurrentKeyedListener = false;
    for (const currentListener of frame2.keyedListeners) {
      if (currentListener === frame2.currentListener) {
        foundCurrentKeyedListener = true;
        continue;
      }
      if (!foundCurrentKeyedListener) continue;
      if (currentListener === listener) return false;
    }
    let foundListener = false;
    for (const currentListener of frame2.group.listeners) {
      if (currentListener === frame2.currentListener) return foundListener;
      if (currentListener === listener) foundListener = true;
    }
    return false;
  }
  function preserveFastPathFrames(fastPathFrames, group, listener) {
    for (const frame2 of fastPathFrames) {
      if (frame2.group !== group) continue;
      if (frame2.recovering) continue;
      if (listener && !frame2.keyedListeners.has(listener)) continue;
      preserveFastPathNotifiedListeners(frame2);
      for (const currentListener of frame2.group.listeners) {
        if (currentListener === frame2.currentListener) break;
        if (!hasFastPathPassedListener(frame2, currentListener)) continue;
        frame2.notifiedListeners?.add(currentListener);
      }
    }
  }
  function preserveFastPathPassedListeners(fastPathFrames, group, listener) {
    for (const frame2 of fastPathFrames) {
      if (frame2.group !== group) continue;
      if (frame2.recovering) continue;
      if (!hasFastPathPassedListener(frame2, listener)) continue;
      preserveFastPathNotifiedListeners(frame2);
      frame2.notifiedListeners?.add(listener);
    }
  }
  function preserveFastPathPassedKeyedListeners({ fastPathFrames, group, keys, listener }) {
    const wasRegistered = group.listeners.has(listener);
    for (const frame2 of fastPathFrames) {
      if (frame2.group !== group) continue;
      if (frame2.recovering) continue;
      if (!keys.includes(frame2.updatedKey)) continue;
      if (hasFastPathPassedListener(frame2, listener)) {
        preserveFastPathNotifiedListeners(frame2);
        frame2.notifiedListeners?.add(listener);
      } else if (wasRegistered) {
        preserveFastPathNotifiedListeners(frame2);
        frame2.recoverToLive = true;
      }
    }
  }
  function clearFastPathNotifiedListener(fastPathFrames, group, listener) {
    for (const frame2 of fastPathFrames) {
      if (frame2.group !== group) continue;
      frame2.notifiedListeners?.delete(listener);
    }
  }
  function addFastPathKeyedListener({ fastPathFrames, group, keys, listener }) {
    for (const frame2 of fastPathFrames) {
      if (frame2.group !== group) continue;
      if (frame2.recovering) continue;
      if (!keys.includes(frame2.updatedKey)) continue;
      frame2.keyedListeners.add(listener);
    }
  }
  function runPendingCleanup(group, listener) {
    if (!group.disposables.size) return;
    const cleanup = group.disposables.get(listener);
    if (!cleanup) return;
    group.disposables.delete(listener);
    cleanup();
  }
  function setListenerCleanup(group, listener, cleanup) {
    const currentCleanup = group.disposables.get(listener);
    if (!currentCleanup) {
      group.disposables.set(listener, cleanup);
      return;
    }
    group.disposables.set(listener, () => {
      currentCleanup();
      cleanup();
    });
  }
  function notifyStoreListener(group, listener, state, prevState, getState, updatedKey) {
    if (group.suspendCounts?.has(listener)) return;
    const { disposables } = group;
    const cleanup = disposables.size ? disposables.get(listener) : void 0;
    if (cleanup) {
      disposables.delete(listener);
      const stateBeforeCleanup = state;
      cleanup();
      state = getState?.() ?? state;
      if (state !== stateBeforeCleanup) prevState = getCleanupPrevState(prevState, state, stateBeforeCleanup, updatedKey) ?? prevState;
    }
    const result = listener(state, prevState);
    if (result) setListenerCleanup(group, listener, result);
  }
  function runLiveListeners({ group, getState, prevState, updatedKey, notifiedListeners }) {
    const allKeysListeners = group.allKeysListeners;
    for (const listener of group.listeners) {
      if (notifiedListeners?.has(listener)) continue;
      if (!allKeysListeners?.has(listener)) {
        if (!hasUpdatedKey(group.listenerKeys.get(listener), updatedKey)) continue;
      }
      notifiedListeners?.add(listener);
      notifyStoreListener(group, listener, getState(), prevState, getState, updatedKey);
    }
  }
  function createStore(initialState2, ...stores) {
    let state = initialState2;
    let prevStateBatch = state;
    let destroy = noop;
    let batchPending = false;
    let inDispatch = false;
    let updatedKeys = /* @__PURE__ */ new Set();
    const instances = /* @__PURE__ */ new Set();
    const setups = /* @__PURE__ */ new Set();
    const syncListenerGroup = {
      listeners: /* @__PURE__ */ new Set(),
      disposables: /* @__PURE__ */ new Map(),
      listenerKeys: /* @__PURE__ */ new WeakMap()
    };
    const batchListenerGroup = {
      listeners: /* @__PURE__ */ new Set(),
      disposables: /* @__PURE__ */ new Map(),
      listenerKeys: /* @__PURE__ */ new WeakMap()
    };
    const storeSetup = (callback) => {
      setups.add(callback);
      return () => setups.delete(callback);
    };
    const storeInit = () => {
      const initializedInstances = instances.size;
      const instance = /* @__PURE__ */ Symbol();
      instances.add(instance);
      const maybeDestroy = () => {
        if (!instances.delete(instance)) return;
        if (instances.size) return;
        destroy();
      };
      if (initializedInstances) return maybeDestroy;
      const stateKeys = getKeys(state);
      const desyncs = [];
      for (const store of stores) {
        const storeState = store?.getState?.();
        if (!storeState) continue;
        const keys = stateKeys.filter((key) => hasOwnProperty(storeState, key));
        if (!keys.length) continue;
        if (stores.length === 1 || keys.length === stateKeys.length) {
          for (const key of keys) desyncs.push(sync(store, [key], (state2) => {
            setState(key, state2[key], true);
          }));
          continue;
        }
        desyncs.push(subscribe(store, keys, (state2, prevState) => {
          for (const key of keys) {
            if (state2[key] === prevState[key]) continue;
            setState(key, state2[key], true);
          }
        }));
        for (const key of keys) {
          const liveState = store?.getState?.();
          if (!liveState) continue;
          setState(key, liveState[key], true);
        }
      }
      const teardowns = [];
      for (const setup2 of setups) teardowns.push(setup2());
      const cleanups2 = stores.map(init);
      destroy = chain(...desyncs, ...teardowns, ...cleanups2);
      return maybeDestroy;
    };
    const deleteListenerIndexes = (group, listener, keys) => {
      if (keys === void 0) return;
      if (keys) deleteKeyedListener(group.listenersByKey, keys, listener);
      else group.allKeysListeners?.delete(listener);
    };
    const fastPathFrames = [];
    const registerListener = (keys, listener, group = syncListenerGroup) => {
      const listenerKeysValue = keys ? [...keys] : null;
      const wasRegistered = group.listeners.has(listener);
      if (!wasRegistered) clearFastPathNotifiedListener(fastPathFrames, group, listener);
      if (!listenerKeysValue) {
        if (wasRegistered) preserveFastPathFrames(fastPathFrames, group);
        preserveFastPathPassedListeners(fastPathFrames, group, listener);
      } else preserveFastPathPassedKeyedListeners({
        fastPathFrames,
        group,
        keys: listenerKeysValue,
        listener
      });
      if (wasRegistered) {
        preserveFastPathFrames(fastPathFrames, group, listener);
        deleteListenerIndexes(group, listener, group.listenerKeys.get(listener));
      }
      group.listeners.add(listener);
      if (listenerKeysValue) {
        group.listenersByKey ??= /* @__PURE__ */ new Map();
        addKeyedListener(group.listenersByKey, listenerKeysValue, listener);
        addFastPathKeyedListener({
          fastPathFrames,
          group,
          keys: listenerKeysValue,
          listener
        });
      } else {
        group.allKeysListeners ??= /* @__PURE__ */ new Set();
        group.allKeysListeners.add(listener);
      }
      group.listenerKeys.set(listener, listenerKeysValue);
      return () => {
        const cleanup = group.disposables.get(listener);
        group.disposables.delete(listener);
        preserveFastPathFrames(fastPathFrames, group, listener);
        const currentKeys = group.listenerKeys.get(listener);
        deleteListenerIndexes(group, listener, listenerKeysValue);
        if (currentKeys !== listenerKeysValue) deleteListenerIndexes(group, listener, currentKeys);
        group.listenerKeys.delete(listener);
        group.listeners.delete(listener);
        cleanup?.();
      };
    };
    const storeSubscribe = (keys, listener) => registerListener(keys, listener);
    const runInitialListener = (group, listener, prevState) => {
      const shouldSuspend = group.listeners.has(listener);
      if (shouldSuspend) {
        group.suspendCounts ??= /* @__PURE__ */ new Map();
        const count = group.suspendCounts.get(listener) ?? 0;
        group.suspendCounts.set(listener, count + 1);
      }
      let cleanupPrevState;
      try {
        const stateBeforeCleanups = state;
        runPendingCleanup(group, listener);
        if (state !== stateBeforeCleanups) cleanupPrevState = getCleanupPrevState(prevState, state, stateBeforeCleanups);
        const cleanup = listener(state, cleanupPrevState ?? prevState);
        if (cleanup) setListenerCleanup(group, listener, cleanup);
      } finally {
        if (shouldSuspend) {
          const suspendCounts = group.suspendCounts;
          const count = suspendCounts?.get(listener);
          if (count && count > 1) suspendCounts?.set(listener, count - 1);
          else suspendCounts?.delete(listener);
          if (!suspendCounts?.size) delete group.suspendCounts;
        }
      }
    };
    const storeSync = (keys, listener) => {
      runInitialListener(syncListenerGroup, listener, state);
      return registerListener(keys, listener);
    };
    const storeBatch = (keys, listener) => {
      if (!batchListenerGroup.listeners.size && !inDispatch) prevStateBatch = state;
      runInitialListener(batchListenerGroup, listener, prevStateBatch);
      return registerListener(keys, listener, batchListenerGroup);
    };
    const storePick = (keys) => createStore(pick(state, keys), finalStore);
    const storeOmit = (keys) => createStore(omit(state, keys), finalStore);
    const getState = () => state;
    const runListeners = (group, prevState, updatedKey) => {
      if (!(updatedKey instanceof Set) && !group.allKeysListeners?.size) {
        const keyedListeners = group.listenersByKey?.get(updatedKey);
        if (!keyedListeners) return;
        const frame2 = {
          group,
          keyedListeners,
          updatedKey,
          currentListener: null
        };
        fastPathFrames.push(frame2);
        try {
          for (const listener of keyedListeners) {
            if (frame2.notifiedListeners?.has(listener)) continue;
            frame2.currentListener = listener;
            frame2.notifiedListeners?.add(listener);
            notifyStoreListener(group, listener, state, prevState, getState, updatedKey);
            if (!group.allKeysListeners?.size && !frame2.recoverToLive) continue;
            const notifiedListeners = frame2.notifiedListeners ?? getFastPathNotifiedListeners(frame2);
            frame2.notifiedListeners = notifiedListeners;
            frame2.recovering = true;
            runLiveListeners({
              group,
              getState,
              prevState,
              updatedKey,
              notifiedListeners
            });
            return;
          }
        } finally {
          fastPathFrames.pop();
        }
        return;
      }
      runLiveListeners({
        group,
        getState,
        prevState,
        updatedKey
      });
    };
    const setState = (key, value, fromStores = false) => {
      if (!hasOwnProperty(state, key)) return;
      const currentValue = state[key];
      const nextValue = typeof value === "function" ? value(currentValue) : value;
      if (isSameValue(nextValue, currentValue)) return;
      const wasInDispatch = inDispatch;
      inDispatch = true;
      const prevState = state;
      const nextState = {
        ...state,
        [key]: nextValue
      };
      state = nextState;
      let superseded = false;
      try {
        if (!fromStores && stores.length) {
          for (const store of stores) {
            store?.setState?.(key, nextValue);
            if (isSameValue(state[key], nextValue)) continue;
            superseded = true;
            break;
          }
          if (superseded) {
            let pass = 0;
            for (; pass < MAX_REPAIR_PASSES; pass += 1) {
              let changed = false;
              for (const store of stores) {
                const previousValue = state[key];
                store?.setState?.(key, previousValue);
                if (!isSameValue(state[key], previousValue)) changed = true;
              }
              if (!changed) break;
            }
            if (pass === MAX_REPAIR_PASSES) console.warn("Parent stores did not converge after a superseded fan-out; a parent listener may be rewriting this key in a cycle.");
          }
        }
        if (!superseded) runListeners(syncListenerGroup, state === nextState ? prevState : {
          ...state,
          [key]: prevState[key]
        }, key);
      } finally {
        inDispatch = wasInDispatch;
      }
      if (!batchListenerGroup.listeners.size) {
        if (!inDispatch) prevStateBatch = state;
        return;
      }
      updatedKeys.add(key);
      if (batchPending) return;
      batchPending = true;
      queueMicrotask(() => {
        batchPending = false;
        const snapshot = state;
        const updatedKeysSnapshot = updatedKeys;
        updatedKeys = /* @__PURE__ */ new Set();
        const prevStateBatchBefore = prevStateBatch;
        runListeners(batchListenerGroup, prevStateBatchBefore, updatedKeysSnapshot);
        if (prevStateBatch === prevStateBatchBefore) prevStateBatch = snapshot;
      });
    };
    const finalStore = {
      getState,
      setState,
      __unstableInternals: {
        setup: storeSetup,
        init: storeInit,
        subscribe: storeSubscribe,
        sync: storeSync,
        batch: storeBatch,
        pick: storePick,
        omit: storeOmit
      }
    };
    return finalStore;
  }
  function setup(store, ...args) {
    if (!store) return;
    return getInternal(store, "setup")(...args);
  }
  function init(store, ...args) {
    if (!store) return;
    return getInternal(store, "init")(...args);
  }
  function subscribe(store, ...args) {
    if (!store) return;
    return getInternal(store, "subscribe")(...args);
  }
  function sync(store, ...args) {
    if (!store) return;
    return getInternal(store, "sync")(...args);
  }
  function batch(store, ...args) {
    if (!store) return;
    return getInternal(store, "batch")(...args);
  }
  function omit2(store, ...args) {
    if (!store) return;
    return getInternal(store, "omit")(...args);
  }
  function pick2(store, ...args) {
    if (!store) return;
    return getInternal(store, "pick")(...args);
  }
  function mergeStore(...stores) {
    const initialState2 = {};
    for (const store2 of stores) {
      const nextState = store2?.getState?.();
      if (nextState) Object.assign(initialState2, nextState);
    }
    const store = createStore(initialState2, ...stores);
    return Object.assign({}, ...stores, store);
  }
  function throwOnConflictingProps(props, store) {
    if (false) return;
    if (!store) return;
    const defaultKeys = Object.entries(props).filter(([key, value]) => key.startsWith("default") && value !== void 0).map(([key]) => {
      const stateKey = key.replace("default", "");
      return `${stateKey[0]?.toLowerCase() || ""}${stateKey.slice(1)}`;
    });
    if (!defaultKeys.length) return;
    const storeState = store.getState();
    if (!defaultKeys.filter((key) => hasOwnProperty(storeState, key)).length) return;
    throw new Error(`Passing a store prop in conjunction with a default state is not supported.

const store = useSelectStore();
<SelectProvider store={store} defaultValue="Apple" />
                ^             ^

Instead, pass the default state to the topmost store:

const store = useSelectStore({ defaultValue: "Apple" });
<SelectProvider store={store} />

See https://github.com/ariakit/ariakit/pull/2745 for more details.

If there's a particular need for this, please submit a feature request at https://github.com/ariakit/ariakit
`);
  }

  // node_modules/@ariakit/components/dist/collection/collection-store.js
  function getCommonParent(items) {
    const firstItem = items.find((item2) => !!item2.element);
    const lastElement = [...items].reverse().find((item2) => !!item2.element)?.element;
    let parentElement = firstItem?.element?.parentElement;
    if (!lastElement) return getDocument(parentElement).body;
    while (parentElement) {
      if (parentElement.contains(lastElement)) return parentElement;
      parentElement = parentElement.parentElement;
    }
    return getDocument(parentElement).body;
  }
  function getPrivateStore(store) {
    return store?.__unstablePrivateStore;
  }
  function createCollectionStore(props = {}) {
    throwOnConflictingProps(props, props.store);
    const syncState = props.store?.getState();
    const items = defaultValue(props.items, syncState?.items, props.defaultItems, []);
    const itemsMap = new Map(items.map((item2) => [item2.id, item2]));
    const initialState2 = {
      items,
      renderedItems: defaultValue(syncState?.renderedItems, [])
    };
    const syncPrivateStore = getPrivateStore(props.store);
    const privateStore = createStore({
      items,
      renderedItems: initialState2.renderedItems
    }, syncPrivateStore);
    const collection = createStore(initialState2, props.store);
    const sortItems = (renderedItems) => {
      const sortedItems = sortBasedOnDOMPosition(renderedItems, (i3) => i3.element);
      privateStore.setState("renderedItems", sortedItems);
      collection.setState("renderedItems", sortedItems);
    };
    setup(collection, () => init(privateStore));
    setup(privateStore, () => {
      return batch(privateStore, ["items"], (state) => {
        collection.setState("items", state.items);
      });
    });
    setup(privateStore, () => {
      return batch(privateStore, ["renderedItems"], (state) => {
        let firstRun = true;
        let raf = requestAnimationFrame(() => {
          const { renderedItems } = collection.getState();
          if (state.renderedItems === renderedItems) return;
          sortItems(state.renderedItems);
        });
        if (typeof IntersectionObserver !== "function") return () => cancelAnimationFrame(raf);
        const ioCallback = () => {
          if (firstRun) {
            firstRun = false;
            return;
          }
          cancelAnimationFrame(raf);
          raf = requestAnimationFrame(() => sortItems(state.renderedItems));
        };
        const root = getCommonParent(state.renderedItems);
        const observer = new IntersectionObserver(ioCallback, { root });
        for (const item2 of state.renderedItems) {
          if (!item2.element) continue;
          observer.observe(item2.element);
        }
        return () => {
          cancelAnimationFrame(raf);
          observer.disconnect();
        };
      });
    });
    const mergeItem = (item2, setItems, canDeleteFromMap = false) => {
      let prevItem;
      setItems((items2) => {
        const index2 = items2.findIndex(({ id: id3 }) => id3 === item2.id);
        const nextItems = items2.slice();
        if (index2 !== -1) {
          prevItem = items2[index2];
          const nextItem = {
            ...prevItem,
            ...item2
          };
          nextItems[index2] = nextItem;
          itemsMap.set(item2.id, nextItem);
        } else {
          nextItems.push(item2);
          itemsMap.set(item2.id, item2);
        }
        return nextItems;
      });
      const unmergeItem = () => {
        setItems((items2) => {
          if (!prevItem) {
            if (canDeleteFromMap) itemsMap.delete(item2.id);
            return items2.filter(({ id: id3 }) => id3 !== item2.id);
          }
          const index2 = items2.findIndex(({ id: id3 }) => id3 === item2.id);
          if (index2 === -1) return items2;
          const nextItems = items2.slice();
          nextItems[index2] = prevItem;
          itemsMap.set(item2.id, prevItem);
          return nextItems;
        });
      };
      return unmergeItem;
    };
    const registerItem = (item2) => mergeItem(item2, (getItems) => privateStore.setState("items", getItems), true);
    return {
      ...collection,
      registerItem,
      renderItem: (item2) => chain(registerItem(item2), mergeItem(item2, (getItems) => privateStore.setState("renderedItems", getItems))),
      item: (id3) => {
        if (!id3) return null;
        let item2 = itemsMap.get(id3);
        if (!item2) {
          const { items: items2 } = privateStore.getState();
          item2 = items2.find((item3) => item3.id === id3);
          if (item2) itemsMap.set(id3, item2);
        }
        return item2 || null;
      },
      __unstablePrivateStore: privateStore
    };
  }

  // node_modules/@ariakit/components/dist/composite/composite-store.js
  var NULL_ITEM = { id: null };
  function findFirstEnabledItem(items, excludeId) {
    return items.find((item2) => {
      if (excludeId) return !item2.disabled && item2.id !== excludeId;
      return !item2.disabled;
    });
  }
  function getEnabledItems(items, excludeId) {
    return items.filter((item2) => {
      if (excludeId) return !item2.disabled && item2.id !== excludeId;
      return !item2.disabled;
    });
  }
  function getItemsInRow(items, rowId) {
    return items.filter((item2) => item2.rowId === rowId);
  }
  function findEnabledItemId({ items, fromIndex, step, rowId, excludeId }) {
    for (let i3 = fromIndex; i3 >= 0 && i3 < items.length; i3 += step) {
      const item2 = items[i3];
      if (!item2) continue;
      if (item2.rowId !== rowId) continue;
      if (item2.disabled) continue;
      if (excludeId != null && item2.id === excludeId) continue;
      return item2.id;
    }
  }
  function flipItems(items, activeId, shouldInsertNullItem = false) {
    const index2 = items.findIndex((item2) => item2.id === activeId);
    return [
      ...items.slice(index2 + 1),
      ...shouldInsertNullItem ? [NULL_ITEM] : [],
      ...items.slice(0, index2)
    ];
  }
  function groupItemsByRows(items) {
    const rows = [];
    for (const item2 of items) {
      const row = rows.find((currentRow) => currentRow[0]?.rowId === item2.rowId);
      if (row) row.push(item2);
      else rows.push([item2]);
    }
    return rows;
  }
  function getMaxRowLength(array) {
    let maxLength = 0;
    for (const { length: length2 } of array) if (length2 > maxLength) maxLength = length2;
    return maxLength;
  }
  function createEmptyItem(rowId) {
    return {
      id: "__EMPTY_ITEM__",
      disabled: true,
      rowId
    };
  }
  function normalizeRows(rows, activeId, focusShift) {
    const maxLength = getMaxRowLength(rows);
    for (const row of rows) for (let i3 = 0; i3 < maxLength; i3 += 1) {
      const item2 = row[i3];
      if (!item2 || focusShift && item2.disabled) {
        const previousItem = i3 === 0 && focusShift ? findFirstEnabledItem(row) : row[i3 - 1];
        row[i3] = previousItem && activeId !== previousItem.id && focusShift ? previousItem : createEmptyItem(previousItem?.rowId);
      }
    }
    return rows;
  }
  function verticalizeItems(items) {
    const rows = groupItemsByRows(items);
    const maxLength = getMaxRowLength(rows);
    const verticalized = [];
    for (let i3 = 0; i3 < maxLength; i3 += 1) for (const row of rows) {
      const item2 = row[i3];
      if (item2) verticalized.push({
        ...item2,
        rowId: item2.rowId ? `${i3}` : void 0
      });
    }
    return verticalized;
  }
  function createCompositeStore(props = {}) {
    const syncState = props.store?.getState();
    const collection = createCollectionStore(props);
    const activeId = defaultValue(props.activeId, syncState?.activeId, props.defaultActiveId);
    const composite = createStore({
      ...collection.getState(),
      id: defaultValue(props.id, syncState?.id) ?? `id-${Math.random().toString(36).slice(2, 8)}`,
      activeId,
      baseElement: defaultValue(syncState?.baseElement, null),
      includesBaseElement: defaultValue(props.includesBaseElement, syncState?.includesBaseElement, activeId === null),
      moves: defaultValue(syncState?.moves, 0),
      orientation: defaultValue(props.orientation, syncState?.orientation, "both"),
      rtl: defaultValue(props.rtl, syncState?.rtl, false),
      virtualFocus: defaultValue(props.virtualFocus, syncState?.virtualFocus, false),
      focusLoop: defaultValue(props.focusLoop, syncState?.focusLoop, false),
      focusWrap: defaultValue(props.focusWrap, syncState?.focusWrap, false),
      focusShift: defaultValue(props.focusShift, syncState?.focusShift, false)
    }, collection, props.store);
    setup(composite, () => sync(composite, ["renderedItems", "activeId"], (state) => {
      composite.setState("activeId", (activeId2) => {
        if (activeId2 !== void 0) return activeId2;
        return findFirstEnabledItem(state.renderedItems)?.id;
      });
    }));
    const getNextId = (direction = "next", options2 = {}) => {
      const defaultState = composite.getState();
      const { skip = 0, activeId: activeId2 = defaultState.activeId, focusShift = defaultState.focusShift, focusLoop = defaultState.focusLoop, focusWrap = defaultState.focusWrap, includesBaseElement = defaultState.includesBaseElement, renderedItems = defaultState.renderedItems, rtl: rtl2 = defaultState.rtl } = options2;
      const isVerticalDirection = direction === "up" || direction === "down";
      const isNextDirection = direction === "next" || direction === "down";
      const canReverse = isNextDirection ? rtl2 && !isVerticalDirection : !rtl2 || isVerticalDirection;
      const canShift = focusShift && !skip;
      if (!skip && !focusWrap && !includesBaseElement && activeId2 != null) {
        if (!isVerticalDirection ? true : !canShift && !renderedItems.some((item2) => item2.rowId != null)) {
          const activeIndex2 = renderedItems.findIndex((item2) => item2.id === activeId2);
          const activeItem2 = renderedItems[activeIndex2];
          if (activeItem2) {
            const step = canReverse ? -1 : 1;
            const nextId = findEnabledItemId({
              items: renderedItems,
              fromIndex: activeIndex2 + step,
              step,
              rowId: activeItem2.rowId,
              excludeId: activeId2
            });
            if (nextId !== void 0) return nextId;
            if (!(focusLoop && (isVerticalDirection ? focusLoop !== "horizontal" : focusLoop !== "vertical"))) return void 0;
            return findEnabledItemId({
              items: renderedItems,
              fromIndex: step === 1 ? 0 : renderedItems.length - 1,
              step,
              rowId: activeItem2.rowId,
              excludeId: activeId2
            });
          }
        }
      }
      let items = !isVerticalDirection ? renderedItems : flatten2DArray(normalizeRows(groupItemsByRows(renderedItems), activeId2, canShift));
      items = canReverse ? reverseArray(items) : items;
      items = isVerticalDirection ? verticalizeItems(items) : items;
      if (activeId2 == null) return findFirstEnabledItem(items)?.id;
      const activeItem = items.find((item2) => item2.id === activeId2);
      if (!activeItem) return findFirstEnabledItem(items)?.id;
      const isGrid2 = items.some((item2) => item2.rowId);
      const activeIndex = items.indexOf(activeItem);
      const nextItems = items.slice(activeIndex + 1);
      const nextItemsInRow = getItemsInRow(nextItems, activeItem.rowId);
      if (skip) {
        const nextEnabledItemsInRow = getEnabledItems(nextItemsInRow, activeId2);
        return (nextEnabledItemsInRow.slice(skip)[0] || nextEnabledItemsInRow[nextEnabledItemsInRow.length - 1])?.id;
      }
      const canLoop = focusLoop && (isVerticalDirection ? focusLoop !== "horizontal" : focusLoop !== "vertical");
      const canWrap = isGrid2 && focusWrap && (isVerticalDirection ? focusWrap !== "horizontal" : focusWrap !== "vertical");
      const hasNullItem = isNextDirection ? (!isGrid2 || isVerticalDirection) && canLoop && includesBaseElement : isVerticalDirection ? includesBaseElement : false;
      if (canLoop) return findFirstEnabledItem(flipItems(canWrap && !hasNullItem ? items : getItemsInRow(items, activeItem.rowId), activeId2, hasNullItem), activeId2)?.id;
      if (canWrap) {
        const nextItem2 = findFirstEnabledItem(hasNullItem ? nextItemsInRow : nextItems, activeId2);
        return hasNullItem ? nextItem2?.id || null : nextItem2?.id;
      }
      const nextItem = findFirstEnabledItem(nextItemsInRow, activeId2);
      if (!nextItem && hasNullItem) return null;
      return nextItem?.id;
    };
    const getNextIdFromOptions = (direction, options2) => {
      if (typeof options2 === "number") return getNextId(direction, { skip: options2 });
      return getNextId(direction, options2);
    };
    return {
      ...collection,
      ...composite,
      setBaseElement: (element) => composite.setState("baseElement", element),
      setActiveId: (id3) => composite.setState("activeId", id3),
      move: (id3) => {
        if (id3 === void 0) return;
        composite.setState("activeId", id3);
        composite.setState("moves", (moves) => moves + 1);
      },
      first: () => findFirstEnabledItem(composite.getState().renderedItems)?.id,
      last: () => findFirstEnabledItem(reverseArray(composite.getState().renderedItems))?.id,
      next: (options2) => getNextIdFromOptions("next", options2),
      previous: (options2) => getNextIdFromOptions("previous", options2),
      down: (options2) => getNextIdFromOptions("down", options2),
      up: (options2) => getNextIdFromOptions("up", options2)
    };
  }

  // node_modules/@ariakit/react-components/dist/composite/utils.js
  var flipItems2 = flipItems;
  var findFirstEnabledItem2 = findFirstEnabledItem;
  var groupItemsByRows2 = groupItemsByRows;
  function getEnabledItem(store, id3) {
    if (!id3) return null;
    return store.item(id3) || null;
  }
  function selectTextField(element, collapseToEnd = false) {
    if (isTextField(element)) element.setSelectionRange(collapseToEnd ? element.value.length : 0, element.value.length);
    else if (element.isContentEditable) {
      const selection = getDocument(element).getSelection();
      selection?.selectAllChildren(element);
      if (collapseToEnd) selection?.collapseToEnd();
    }
  }
  var FOCUS_SILENTLY = /* @__PURE__ */ Symbol("FOCUS_SILENTLY");
  function focusSilently(element) {
    element[FOCUS_SILENTLY] = true;
    element.focus({ preventScroll: true });
  }
  function silentlyFocused(element) {
    const isSilentlyFocused = element[FOCUS_SILENTLY];
    delete element[FOCUS_SILENTLY];
    return isSilentlyFocused;
  }
  function isItem(store, element, exclude) {
    if (!element) return false;
    if (element === exclude) return false;
    const item2 = store.item(element.id);
    if (!item2) return false;
    if (exclude && item2.element === exclude) return false;
    return true;
  }

  // node_modules/@ariakit/react-components/dist/composite/composite-item.js
  var import_react7 = __toESM(require_react(), 1);
  var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);

  // node_modules/@ariakit/react-store/dist/index.js
  var React2 = __toESM(require_react(), 1);
  var import_shim = __toESM(require_shim(), 1);
  var noopSubscribe = () => () => {
  };
  function useStoreState(store, keyOrSelector = identity) {
    const storeSubscribe = React2.useCallback((callback) => {
      if (!store) return noopSubscribe();
      return subscribe(store, null, callback);
    }, [store]);
    const getSnapshot = () => {
      const key = typeof keyOrSelector === "string" ? keyOrSelector : null;
      const selector2 = typeof keyOrSelector === "function" ? keyOrSelector : null;
      const state = store?.getState();
      if (selector2) return selector2(state);
      if (!state) return;
      if (!key) return;
      if (!hasOwnProperty(state, key)) return;
      return state[key];
    };
    return (0, import_shim.useSyncExternalStore)(storeSubscribe, getSnapshot, getSnapshot);
  }
  function useStoreStateObject(store, object) {
    const objRef = React2.useRef({});
    const storeSubscribe = React2.useCallback((callback) => {
      if (!store) return noopSubscribe();
      return subscribe(store, null, callback);
    }, [store]);
    const getSnapshot = () => {
      const state = store?.getState();
      let updated = false;
      const obj = objRef.current;
      for (const prop in object) {
        const keyOrSelector = object[prop];
        if (typeof keyOrSelector === "function") {
          const value = keyOrSelector(state);
          if (!Object.is(value, obj[prop])) {
            obj[prop] = value;
            updated = true;
          }
        }
        if (typeof keyOrSelector === "string") {
          if (!state) continue;
          if (!hasOwnProperty(state, keyOrSelector)) continue;
          const value = state[keyOrSelector];
          if (!Object.is(value, obj[prop])) {
            obj[prop] = value;
            updated = true;
          }
        }
      }
      if (updated) objRef.current = { ...obj };
      return objRef.current;
    };
    return (0, import_shim.useSyncExternalStore)(storeSubscribe, getSnapshot, getSnapshot);
  }
  function useStoreProps(store, props, key, setKey) {
    const value = hasOwnProperty(props, key) ? props[key] : void 0;
    const propsRef = useLiveRef({
      value,
      setValue: setKey ? props[setKey] : void 0
    });
    useSafeLayoutEffect(() => {
      return sync(store, [key], (state, prev2) => {
        const { value: value2, setValue } = propsRef.current;
        if (!setValue) return;
        if (state[key] === prev2[key]) return;
        if (state[key] === value2) return;
        setValue(state[key]);
      });
    }, [store, key]);
    useSafeLayoutEffect(() => {
      if (value === void 0) return;
      store.setState(key, value);
      return batch(store, [key], () => {
        if (value === void 0) return;
        store.setState(key, value);
      });
    });
  }
  function useStore(createStore2, props) {
    const [store, setStore] = React2.useState(() => createStore2(props));
    useSafeLayoutEffect(() => init(store), [store]);
    const useState78 = React2.useCallback((keyOrSelector) => useStoreState(store, keyOrSelector), [store]);
    return [React2.useMemo(() => ({
      ...store,
      useState: useState78
    }), [store, useState78]), useEvent(() => {
      setStore((store2) => createStore2({
        ...props,
        ...store2.getState()
      }));
    })];
  }

  // node_modules/@ariakit/react-components/dist/composite/composite-item.js
  var TagName4 = "button";
  function isEditableElement(element) {
    if (isTextbox(element)) return true;
    return element.tagName === "INPUT" && !isButton(element);
  }
  function getNextPageOffset(scrollingElement, pageUp = false) {
    const height = scrollingElement.clientHeight;
    const { top } = scrollingElement.getBoundingClientRect();
    const pageSize = Math.max(height * 0.875, height - 40) * 1.5;
    const pageOffset = pageUp ? height - pageSize + top : pageSize + top;
    if (scrollingElement.tagName === "HTML") return pageOffset + scrollingElement.scrollTop;
    return pageOffset;
  }
  function getItemOffset(itemElement, pageUp = false) {
    const { top } = itemElement.getBoundingClientRect();
    if (pageUp) return top + itemElement.clientHeight;
    return top;
  }
  function findNextPageItemId(element, store, next2, pageUp = false) {
    if (!store) return;
    if (!next2) return;
    const { renderedItems } = store.getState();
    const scrollingElement = getScrollingElement(element);
    if (!scrollingElement) return;
    const nextPageOffset = getNextPageOffset(scrollingElement, pageUp);
    let id3;
    let prevDifference;
    for (let i3 = 0; i3 < renderedItems.length; i3 += 1) {
      const previousId = id3;
      id3 = next2(i3);
      if (!id3) break;
      if (id3 === previousId) continue;
      const itemElement = getEnabledItem(store, id3)?.element;
      if (!itemElement) continue;
      const difference = getItemOffset(itemElement, pageUp) - nextPageOffset;
      const absDifference = Math.abs(difference);
      if (pageUp && difference <= 0 || !pageUp && difference >= 0) {
        if (prevDifference !== void 0 && prevDifference < absDifference) id3 = previousId;
        break;
      }
      prevDifference = absDifference;
    }
    return id3;
  }
  function targetIsAnotherItem(event, store) {
    if (isSelfTarget(event)) return false;
    return isItem(store, event.target);
  }
  var useCompositeItem = createHook(function useCompositeItem2({ store, rowId: rowIdProp, preventScrollOnKeyDown = false, moveOnKeyPress = true, tabbable = false, getItem: getItemProp, "aria-setsize": ariaSetSizeProp, "aria-posinset": ariaPosInSetProp, ...props }) {
    const context = useCompositeScopedContext();
    store = store || context;
    const id3 = useId(props.id);
    const ref = (0, import_react7.useRef)(null);
    const row = (0, import_react7.useContext)(CompositeRowContext);
    const trulyDisabled = disabledFromProps(props) && !props.accessibleWhenDisabled;
    const shouldRegisterItem = props.shouldRegisterItem;
    const getRowId = (state) => {
      if (rowIdProp) return rowIdProp;
      if (!state) return;
      if (!row?.baseElement) return;
      if (row.baseElement !== state.baseElement) return;
      return row.id;
    };
    const { rowId, baseElement, isActiveItem, ariaSetSize, ariaPosInSet, isTabbable: isTabbable2 } = useStoreStateObject(store, {
      rowId: getRowId,
      baseElement(state) {
        return state?.baseElement || void 0;
      },
      isActiveItem(state) {
        return !!state && state.activeId === id3;
      },
      ariaSetSize(state) {
        if (ariaSetSizeProp != null) return ariaSetSizeProp;
        if (!state) return;
        if (!row?.ariaSetSize) return;
        if (row.baseElement !== state.baseElement) return;
        return row.ariaSetSize;
      },
      ariaPosInSet(state) {
        if (ariaPosInSetProp != null) return ariaPosInSetProp;
        if (!state) return;
        if (!row?.ariaPosInSet) return;
        if (row.baseElement !== state.baseElement) return;
        const rowId2 = getRowId(state);
        const itemsInRow = state.renderedItems.filter((item2) => item2.rowId === rowId2);
        return row.ariaPosInSet + itemsInRow.findIndex((item2) => item2.id === id3);
      },
      isTabbable(state) {
        if (!state?.renderedItems.length) return true;
        if (state.virtualFocus) return false;
        if (tabbable) return true;
        if (state.activeId === null) return false;
        const item2 = store?.item(state.activeId);
        if (item2?.disabled) return true;
        if (!item2?.element) return true;
        return state.activeId === id3;
      }
    });
    const getItem = (0, import_react7.useCallback)((item2) => {
      const nextItem = {
        ...item2,
        id: id3 || item2.id,
        rowId,
        disabled: trulyDisabled,
        children: item2.element?.textContent
      };
      if (getItemProp) return getItemProp(nextItem);
      return nextItem;
    }, [
      id3,
      rowId,
      trulyDisabled,
      getItemProp
    ]);
    const onFocusProp = props.onFocus;
    const hasFocusedComposite = (0, import_react7.useRef)(false);
    const cancelScheduledFocusRedirectRef = (0, import_react7.useRef)(null);
    const onFocus = useEvent((event) => {
      onFocusProp?.(event);
      if (event.defaultPrevented) return;
      if (isPortalEvent(event)) return;
      if (!id3) return;
      if (!store) return;
      if (targetIsAnotherItem(event, store)) return;
      const { virtualFocus, baseElement: baseElement2 } = store.getState();
      store.setActiveId(id3);
      if (isTextbox(event.currentTarget)) selectTextField(event.currentTarget);
      if (!virtualFocus) return;
      if (!isSelfTarget(event)) return;
      if (isEditableElement(event.currentTarget)) return;
      const redirectFocusToBaseElement = (currentTarget2, relatedTarget2, baseElement3) => {
        if (isSafari() && currentTarget2.hasAttribute("data-autofocus")) currentTarget2.scrollIntoView({
          block: "nearest",
          inline: "nearest"
        });
        hasFocusedComposite.current = true;
        if (relatedTarget2 === baseElement3 || isItem(store, relatedTarget2)) focusSilently(baseElement3);
        else baseElement3.focus();
      };
      if (baseElement2?.isConnected) {
        redirectFocusToBaseElement(event.currentTarget, event.relatedTarget, baseElement2);
        return;
      }
      if (shouldRegisterItem === false) return;
      const { currentTarget, relatedTarget } = event;
      const cancelScheduledFocusRedirect = () => {
        cancelScheduledFocusRedirectRef.current?.();
        cancelScheduledFocusRedirectRef.current = null;
      };
      cancelScheduledFocusRedirect();
      cancelScheduledFocusRedirectRef.current = subscribe(store, null, () => {
        if (getActiveElement(currentTarget) !== currentTarget) {
          cancelScheduledFocusRedirect();
          return;
        }
        const state = store.getState();
        const nextBaseElement = state.baseElement;
        if (!nextBaseElement?.isConnected) return;
        cancelScheduledFocusRedirect();
        if (!state.virtualFocus) return;
        redirectFocusToBaseElement(currentTarget, relatedTarget, nextBaseElement);
      });
    });
    const onBlurCaptureProp = props.onBlurCapture;
    const onBlurCapture = useEvent((event) => {
      onBlurCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (store?.getState()?.virtualFocus && hasFocusedComposite.current) {
        hasFocusedComposite.current = false;
        event.preventDefault();
        event.stopPropagation();
      }
    });
    const onKeyDownProp = props.onKeyDown;
    const preventScrollOnKeyDownProp = useBooleanEvent(preventScrollOnKeyDown);
    const moveOnKeyPressProp = useBooleanEvent(moveOnKeyPress);
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (event.defaultPrevented) return;
      if (!isSelfTarget(event)) return;
      if (!store) return;
      const { currentTarget } = event;
      const state = store.getState();
      const isGrid2 = !!store.item(id3)?.rowId;
      const isVertical = state.orientation !== "horizontal";
      const isHorizontal = state.orientation !== "vertical";
      const canHomeEnd = () => {
        if (isGrid2) return true;
        if (isHorizontal) return true;
        if (!state.baseElement) return true;
        if (!isTextField(state.baseElement)) return true;
        return false;
      };
      const action = {
        ArrowUp: (isGrid2 || isVertical) && store.up,
        ArrowRight: (isGrid2 || isHorizontal) && store.next,
        ArrowDown: (isGrid2 || isVertical) && store.down,
        ArrowLeft: (isGrid2 || isHorizontal) && store.previous,
        Home: () => {
          if (!canHomeEnd()) return;
          if (!isGrid2 || event.ctrlKey) return store?.first();
          return store?.previous(-1);
        },
        End: () => {
          if (!canHomeEnd()) return;
          if (!isGrid2 || event.ctrlKey) return store?.last();
          return store?.next(-1);
        },
        PageUp: () => {
          return findNextPageItemId(currentTarget, store, store?.up, true);
        },
        PageDown: () => {
          return findNextPageItemId(currentTarget, store, store?.down);
        }
      }[event.key];
      if (action) {
        if (isTextbox(currentTarget)) {
          const selection = getTextboxSelection(currentTarget);
          const isLeft = isHorizontal && event.key === "ArrowLeft";
          const isRight = isHorizontal && event.key === "ArrowRight";
          const isUp = isVertical && event.key === "ArrowUp";
          const isDown = isVertical && event.key === "ArrowDown";
          if (isRight || isDown) {
            const { length: valueLength } = getTextboxValue(currentTarget);
            if (selection.end !== valueLength) return;
          } else if ((isLeft || isUp) && selection.start !== 0) return;
        }
        const nextId = action();
        if (preventScrollOnKeyDownProp(event) || nextId !== void 0) {
          if (!moveOnKeyPressProp(event)) return;
          event.preventDefault();
          store.move(nextId);
        }
      }
    });
    const providerValue = (0, import_react7.useMemo)(() => ({
      id: id3,
      baseElement
    }), [id3, baseElement]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CompositeItemContext.Provider, {
      value: providerValue,
      children: element
    }), [providerValue]);
    props = {
      "data-active-item": isActiveItem || void 0,
      ...props,
      id: id3,
      ref: useMergeRefs(ref, props.ref),
      tabIndex: isTabbable2 ? props.tabIndex : -1,
      onFocus,
      onBlurCapture,
      onKeyDown
    };
    props = useCommand(props);
    props = useCollectionItem({
      store,
      ...props,
      getItem,
      shouldRegisterItem: id3 ? shouldRegisterItem : false
    });
    return removeUndefinedValues({
      ...props,
      "aria-setsize": ariaSetSize,
      "aria-posinset": ariaPosInSet
    });
  });
  var CompositeItem = memo2(forwardRef2(function CompositeItem2(props) {
    return createElement(TagName4, useCompositeItem(props));
  }));

  // node_modules/@ariakit/react-components/dist/tab/tab-context.js
  var ctx3 = createStoreContext([CompositeContextProvider], [CompositeScopedContextProvider]);
  var useTabContext = ctx3.useContext;
  var useTabScopedContext = ctx3.useScopedContext;
  var useTabProviderContext = ctx3.useProviderContext;
  var TabContextProvider = ctx3.ContextProvider;
  var TabScopedContextProvider = ctx3.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/tab/tab.js
  var import_react8 = __toESM(require_react(), 1);
  var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
  var TagName5 = "button";
  var useTab = createHook(function useTab2({ store, getItem: getItemProp, ...props }) {
    const context = useTabScopedContext();
    store = store || context;
    invariant(store, "Tab must be wrapped in a TabList component.");
    const defaultId = useId();
    const id3 = props.id || defaultId;
    const dimmed = disabledFromProps(props);
    const getItem = (0, import_react8.useCallback)((item2) => {
      const nextItem = {
        ...item2,
        dimmed
      };
      if (getItemProp) return getItemProp(nextItem);
      return nextItem;
    }, [dimmed, getItemProp]);
    const onClickProp = props.onClick;
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      store?.setSelectedId(id3);
    });
    const panelId = useStoreState(store.panels, () => store.panel(id3)?.id);
    const shouldRegisterItem = defaultId ? props.shouldRegisterItem : false;
    const isActive = useStoreState(store, (state) => !!id3 && state.activeId === id3);
    const selected = useStoreState(store, (state) => !!id3 && state.selectedId === id3);
    const hasActiveItem2 = useStoreState(store, (state) => !!store.item(state.activeId));
    const canRegisterComposedItem = isActive || selected && !hasActiveItem2;
    const accessibleWhenDisabled = selected || (props.accessibleWhenDisabled ?? true);
    if (useStoreState(store.combobox || store.composite, "virtualFocus")) props = {
      ...props,
      tabIndex: -1
    };
    props = {
      role: "tab",
      "aria-selected": selected,
      "aria-controls": panelId || void 0,
      ...props,
      id: id3,
      onClick
    };
    if (store.composite) {
      const defaultProps = {
        id: id3,
        accessibleWhenDisabled,
        store: store.composite,
        shouldRegisterItem: canRegisterComposedItem && shouldRegisterItem,
        rowId: props.rowId,
        render: props.render
      };
      props = {
        ...props,
        render: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(CompositeItem, {
          ...defaultProps,
          render: store.combobox && store.composite !== store.combobox ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(CompositeItem, {
            ...defaultProps,
            store: store.combobox
          }) : defaultProps.render
        })
      };
    }
    props = useCompositeItem({
      store,
      ...props,
      accessibleWhenDisabled,
      getItem,
      shouldRegisterItem
    });
    return props;
  });
  var Tab = memo2(forwardRef2(function Tab2(props) {
    return createElement(TagName5, useTab(props));
  }));

  // node_modules/@ariakit/react-components/dist/composite/composite.js
  var import_react9 = __toESM(require_react(), 1);
  var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
  var TagName6 = "div";
  function isGrid(items) {
    return items.some((item2) => !!item2.rowId);
  }
  function isPrintableKey(event) {
    const target = event.target;
    if (target && !isTextField(target)) return false;
    return event.key.length === 1 && !event.ctrlKey && !event.metaKey;
  }
  function isModifierKey(event) {
    return event.key === "Shift" || event.key === "Control" || event.key === "Alt" || event.key === "Meta";
  }
  function useKeyboardEventProxy(store, onKeyboardEvent, previousElementRef) {
    return useEvent((event) => {
      onKeyboardEvent?.(event);
      if (event.defaultPrevented) return;
      if (event.isPropagationStopped()) return;
      if (!isSelfTarget(event)) return;
      if (isModifierKey(event)) return;
      if (isPrintableKey(event)) return;
      const activeElement = getEnabledItem(store, store.getState().activeId)?.element;
      if (!activeElement) return;
      const { view, ...eventInit } = event;
      if (activeElement !== previousElementRef?.current) activeElement.focus();
      if (!fireKeyboardEvent(activeElement, event.type, eventInit)) event.preventDefault();
      if (event.currentTarget.contains(activeElement)) event.stopPropagation();
    });
  }
  function findFirstEnabledItemInTheLastRow(items) {
    return findFirstEnabledItem2(flatten2DArray(reverseArray(groupItemsByRows2(items))));
  }
  function withBaseScrollPreserved(store, callback) {
    const { virtualFocus, baseElement } = store.getState();
    if (!virtualFocus || !baseElement || !isTextField(baseElement)) {
      callback();
      return;
    }
    const savedScrollLeft = baseElement.scrollLeft;
    const savedScrollTop = baseElement.scrollTop;
    callback();
    baseElement.scrollLeft = savedScrollLeft;
    baseElement.scrollTop = savedScrollTop;
  }
  function useScheduleFocus(store) {
    const [scheduled, setScheduled] = (0, import_react9.useState)(false);
    const schedule = (0, import_react9.useCallback)(() => setScheduled(true), []);
    const activeItem = useStoreState(store, (state) => scheduled ? getEnabledItem(store, state.activeId) : null);
    (0, import_react9.useEffect)(() => {
      const activeElement = activeItem?.element;
      if (!scheduled) return;
      if (!activeElement) return;
      setScheduled(false);
      withBaseScrollPreserved(store, () => {
        activeElement.focus({ preventScroll: true });
      });
    }, [
      store,
      activeItem,
      scheduled
    ]);
    return schedule;
  }
  var CompositeFocusOnMove = memo2(function CompositeFocusOnMove2({ store, focusOnMove, previousElementRef }) {
    const moves = useStoreState(store, "moves");
    const baseElement = useStoreState(store, "baseElement");
    (0, import_react9.useEffect)(() => {
      if (!moves) return;
      if (!focusOnMove) return;
      const { activeId } = store.getState();
      const itemElement = getEnabledItem(store, activeId)?.element;
      if (!itemElement) return;
      withBaseScrollPreserved(store, () => focusIntoView(itemElement));
    }, [
      store,
      moves,
      focusOnMove
    ]);
    useSafeLayoutEffect(() => {
      if (!moves) return;
      if (!baseElement) return;
      const { activeId } = store.getState();
      if (!(activeId === null)) return;
      const previousElement = previousElementRef.current;
      previousElementRef.current = null;
      if (previousElement) fireBlurEvent(previousElement, { relatedTarget: baseElement });
      if (!hasFocus(baseElement)) baseElement.focus();
    }, [
      store,
      moves,
      baseElement
    ]);
    return null;
  });
  var useComposite = createHook(function useComposite2({ store, composite = true, focusOnMove = composite, moveOnKeyPress = true, ...props }) {
    const context = useCompositeProviderContext();
    store = store || context;
    invariant(store, "Composite must receive a `store` prop or be wrapped in a CompositeProvider component.");
    const ref = (0, import_react9.useRef)(null);
    const previousElementRef = (0, import_react9.useRef)(null);
    const scheduleFocus = useScheduleFocus(store);
    const [, setBaseElement] = useTransactionState(composite ? store.setBaseElement : null);
    const virtualFocus = useStoreState(store, "virtualFocus");
    const activeId = useStoreState(store, (state) => state.virtualFocus ? state.activeId : null);
    useSafeLayoutEffect(() => {
      if (!store) return;
      if (!composite) return;
      if (!virtualFocus) return;
      const previousElement = previousElementRef.current;
      previousElementRef.current = null;
      if (!previousElement) return;
      const relatedTarget = getEnabledItem(store, activeId)?.element || getActiveElement(previousElement);
      if (relatedTarget === previousElement) return;
      fireBlurEvent(previousElement, { relatedTarget });
    }, [
      store,
      activeId,
      virtualFocus,
      composite
    ]);
    const onKeyDownCapture = useKeyboardEventProxy(store, props.onKeyDownCapture, previousElementRef);
    const onKeyUpCapture = useKeyboardEventProxy(store, props.onKeyUpCapture, previousElementRef);
    const onFocusCaptureProp = props.onFocusCapture;
    const onFocusCapture = useEvent((event) => {
      onFocusCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (!store) return;
      const { virtualFocus: virtualFocus2 } = store.getState();
      if (!virtualFocus2) return;
      const previousActiveElement = event.relatedTarget;
      const isSilentlyFocused = silentlyFocused(event.currentTarget);
      if (isSelfTarget(event) && isSilentlyFocused) {
        event.stopPropagation();
        previousElementRef.current = previousActiveElement;
      }
    });
    const onFocusProp = props.onFocus;
    const onFocus = useEvent((event) => {
      onFocusProp?.(event);
      if (event.defaultPrevented) return;
      if (!composite) return;
      if (!store) return;
      const { relatedTarget } = event;
      const { virtualFocus: virtualFocus2 } = store.getState();
      if (virtualFocus2) {
        if (isSelfTarget(event) && !isItem(store, relatedTarget)) queueMicrotask(scheduleFocus);
      } else if (isSelfTarget(event)) store.setActiveId(null);
    });
    const onBlurCaptureProp = props.onBlurCapture;
    const onBlurCapture = useEvent((event) => {
      onBlurCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (!store) return;
      const { virtualFocus: virtualFocus2, activeId: activeId2 } = store.getState();
      if (!virtualFocus2) return;
      const activeElement = getEnabledItem(store, activeId2)?.element;
      const nextActiveElement = event.relatedTarget;
      const nextActiveElementIsItem = isItem(store, nextActiveElement);
      const previousElement = previousElementRef.current;
      previousElementRef.current = null;
      if (isSelfTarget(event) && nextActiveElementIsItem) {
        if (nextActiveElement === activeElement) {
          if (previousElement && previousElement !== nextActiveElement) fireBlurEvent(previousElement, event);
        } else if (activeElement) fireBlurEvent(activeElement, event);
        else if (previousElement) fireBlurEvent(previousElement, event);
        event.stopPropagation();
      } else if (!isItem(store, event.target) && activeElement) fireBlurEvent(activeElement, event);
    });
    const onKeyDownProp = props.onKeyDown;
    const moveOnKeyPressProp = useBooleanEvent(moveOnKeyPress);
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (event.nativeEvent.isComposing) return;
      if (event.defaultPrevented) return;
      if (!store) return;
      if (!isSelfTarget(event)) return;
      const { orientation, renderedItems, activeId: activeId2, rtl: rtl2 } = store.getState();
      if (getEnabledItem(store, activeId2)?.element?.isConnected) return;
      const isVertical = orientation !== "horizontal";
      const isHorizontal = orientation !== "vertical";
      const grid = isGrid(renderedItems);
      if ((event.key === "ArrowLeft" || event.key === "ArrowRight" || event.key === "Home" || event.key === "End") && isTextField(event.currentTarget)) return;
      const up = () => {
        if (grid) return findFirstEnabledItemInTheLastRow(renderedItems)?.id;
        return store?.last();
      };
      const action = {
        ArrowUp: (grid || isVertical) && up,
        ArrowRight: (grid || isHorizontal) && (rtl2 ? store.last : store.first),
        ArrowDown: (grid || isVertical) && store.first,
        ArrowLeft: (grid || isHorizontal) && (rtl2 ? store.first : store.last),
        Home: store.first,
        End: store.last,
        PageUp: store.first,
        PageDown: store.last
      }[event.key];
      if (action) {
        const id3 = action();
        if (id3 !== void 0) {
          if (!moveOnKeyPressProp(event)) return;
          event.preventDefault();
          store.move(id3);
        }
      }
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(CompositeScopedContextProvider, {
      value: store,
      children: [element, composite && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CompositeFocusOnMove, {
        store,
        focusOnMove,
        previousElementRef
      })]
    }), [
      store,
      composite,
      focusOnMove
    ]);
    props = {
      "aria-activedescendant": useStoreState(store, (state) => {
        if (!store) return;
        if (!composite) return;
        if (!state.virtualFocus) return;
        return getEnabledItem(store, state.activeId)?.id;
      }),
      ...props,
      ref: useMergeRefs(ref, setBaseElement, props.ref),
      onKeyDownCapture,
      onKeyUpCapture,
      onFocusCapture,
      onFocus,
      onBlurCapture,
      onKeyDown
    };
    props = useFocusable({
      focusable: useStoreState(store, (state) => composite && (state.virtualFocus || state.activeId === null)),
      ...props
    });
    return props;
  });
  var Composite = forwardRef2(function Composite2(props) {
    return createElement(TagName6, useComposite(props));
  });

  // node_modules/@ariakit/react-components/dist/tab/tab-list.js
  var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
  var TagName7 = "div";
  var useTabList = createHook(function useTabList2({ store, ...props }) {
    const context = useTabProviderContext();
    store = store || context;
    invariant(store, "TabList must receive a `store` prop or be wrapped in a TabProvider component.");
    const orientation = useStoreState(store, (state) => state.orientation === "both" ? void 0 : state.orientation);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TabScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    if (store.composite) props = {
      focusable: false,
      ...props
    };
    props = {
      role: "tablist",
      "aria-orientation": orientation,
      ...props
    };
    props = useComposite({
      store,
      ...props
    });
    return props;
  });
  var TabList = forwardRef2(function TabList2(props) {
    return createElement(TagName7, useTabList(props));
  });

  // node_modules/@ariakit/react-components/dist/disclosure/disclosure-context.js
  var ctx4 = createStoreContext();
  var useDisclosureContext = ctx4.useContext;
  var useDisclosureScopedContext = ctx4.useScopedContext;
  var useDisclosureProviderContext = ctx4.useProviderContext;
  var DisclosureContextProvider = ctx4.ContextProvider;
  var DisclosureScopedContextProvider = ctx4.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/dialog/dialog-context.js
  var import_react10 = __toESM(require_react(), 1);
  var ctx5 = createStoreContext([DisclosureContextProvider], [DisclosureScopedContextProvider]);
  var useDialogContext = ctx5.useContext;
  var useDialogScopedContext = ctx5.useScopedContext;
  var useDialogProviderContext = ctx5.useProviderContext;
  var DialogContextProvider = ctx5.ContextProvider;
  var DialogScopedContextProvider = ctx5.ScopedContextProvider;
  var DialogHeadingContext = (0, import_react10.createContext)(void 0);
  var DialogDescriptionContext = (0, import_react10.createContext)(void 0);

  // node_modules/@ariakit/react-components/dist/disclosure/disclosure-content.js
  var import_react11 = __toESM(require_react(), 1);
  var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
  var import_react_dom = __toESM(require_react_dom(), 1);
  var TagName8 = "div";
  function afterTimeout(timeoutMs, cb) {
    const timeoutId = setTimeout(cb, timeoutMs);
    return () => clearTimeout(timeoutId);
  }
  function parseCSSTime(time2) {
    const value = time2?.trim() || "0s";
    const multiplier = value.endsWith("ms") ? 1 : 1e3;
    const parsed = Number.parseFloat(value) * multiplier;
    return Number.isNaN(parsed) ? 0 : parsed;
  }
  function getEndTime(names, delays, durations) {
    const nameList = names.split(",");
    const delayList = delays.split(",");
    const durationList = durations.split(",");
    let endTime = 0;
    for (const [index2, name] of nameList.entries()) {
      if (name.trim() === "none") continue;
      const delay2 = parseCSSTime(delayList[index2 % delayList.length]);
      const duration = parseCSSTime(durationList[index2 % durationList.length]);
      endTime = Math.max(endTime, delay2 + duration);
    }
    return endTime;
  }
  function getElementEndTime(element) {
    const { transitionProperty, transitionDuration, transitionDelay, animationName, animationDuration, animationDelay } = getComputedStyle(element);
    return Math.max(getEndTime(transitionProperty, transitionDelay, transitionDuration), getEndTime(animationName, animationDelay, animationDuration));
  }
  function isHidden(mounted, hidden, alwaysVisible) {
    return !alwaysVisible && hidden !== false && (!mounted || !!hidden);
  }
  var useDisclosureContent = createHook(function useDisclosureContent2({ store, alwaysVisible, unstable_otherElementRef: otherElementRef, ...props }) {
    const context = useDisclosureProviderContext();
    store = store || context;
    invariant(store, "DisclosureContent must receive a `store` prop or be wrapped in a DisclosureProvider component.");
    const ref = (0, import_react11.useRef)(null);
    const id3 = useId(props.id);
    const [transition, setTransition] = (0, import_react11.useState)(null);
    const open = useStoreState(store, "open");
    const mounted = useStoreState(store, "mounted");
    const animated = useStoreState(store, "animated");
    const contentElement = useStoreState(store, "contentElement");
    const otherElement = useStoreState(store.disclosure, "contentElement");
    const hasClosedRef = (0, import_react11.useRef)(false);
    useSafeLayoutEffect(() => {
      if (!ref.current) return;
      store?.setContentElement(ref.current);
    }, [store]);
    useSafeLayoutEffect(() => {
      let previousAnimated;
      store?.setState("animated", (animated2) => {
        previousAnimated = animated2;
        return true;
      });
      return () => {
        if (previousAnimated === void 0) return;
        store?.setState("animated", previousAnimated);
      };
    }, [store]);
    useSafeLayoutEffect(() => {
      if (!animated) {
        if (!open) {
          hasClosedRef.current = true;
          setTransition(null);
        } else if (hasClosedRef.current) {
          hasClosedRef.current = false;
          setTransition("enter");
        }
        return;
      }
      if (!contentElement?.isConnected) {
        setTransition(null);
        return;
      }
      return afterPaint(() => {
        setTransition(open ? "enter" : mounted ? "leave" : null);
      });
    }, [
      animated,
      contentElement,
      open,
      mounted
    ]);
    useSafeLayoutEffect(() => {
      if (!store) return;
      if (!animated) return;
      if (!transition) return;
      if (!contentElement) return;
      const stopAnimation = () => store?.setState("animating", false);
      const stopAnimationSync = () => (0, import_react_dom.flushSync)(stopAnimation);
      if (transition === "leave" && open) return;
      if (transition === "enter" && !open) return;
      if (typeof animated === "number") return afterTimeout(animated, stopAnimationSync);
      const elements2 = [contentElement];
      if (otherElement) elements2.push(otherElement);
      const relatedElement = otherElementRef?.current;
      if (relatedElement) elements2.push(relatedElement);
      const timeout = Math.max(...elements2.map(getElementEndTime));
      if (!timeout) {
        if (transition === "enter") store.setState("animated", false);
        stopAnimation();
        return;
      }
      return afterTimeout(Math.max(timeout - 1e3 / 60, 0), stopAnimationSync);
    }, [
      store,
      animated,
      contentElement,
      otherElement,
      otherElementRef,
      open,
      transition
    ]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DialogScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    const hidden = isHidden(mounted, props.hidden, alwaysVisible);
    const styleProp = props.style;
    const style2 = (0, import_react11.useMemo)(() => {
      if (hidden) return {
        ...styleProp,
        display: "none"
      };
      return styleProp;
    }, [hidden, styleProp]);
    props = {
      "data-open": open || void 0,
      "data-enter": transition === "enter" || void 0,
      "data-leave": transition === "leave" || void 0,
      hidden,
      ...props,
      id: id3,
      ref: useMergeRefs(id3 ? store.setContentElement : null, ref, props.ref),
      style: style2
    };
    return removeUndefinedValues(props);
  });
  var DisclosureContentImpl = forwardRef2(function DisclosureContentImpl2(props) {
    return createElement(TagName8, useDisclosureContent(props));
  });
  var DisclosureContent = forwardRef2(function DisclosureContent2({ unmountOnHide, ...props }) {
    const context = useDisclosureProviderContext();
    if (useStoreState(props.store || context, (state) => !unmountOnHide || state?.mounted) === false) return null;
    return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DisclosureContentImpl, { ...props });
  });

  // node_modules/@ariakit/components/dist/disclosure/disclosure-store.js
  function createDisclosureStore(props = {}) {
    const store = mergeStore(props.store, omit2(props.disclosure, ["contentElement", "disclosureElement"]));
    throwOnConflictingProps(props, store);
    const syncState = store?.getState();
    const open = defaultValue(props.open, syncState?.open, props.defaultOpen, false);
    const animated = defaultValue(props.animated, syncState?.animated, false);
    const disclosure = createStore({
      open,
      animated,
      animating: !!animated && open,
      mounted: open,
      contentElement: defaultValue(syncState?.contentElement, null),
      disclosureElement: defaultValue(syncState?.disclosureElement, null)
    }, store);
    setup(disclosure, () => sync(disclosure, ["animated", "animating"], (state) => {
      if (state.animated) return;
      disclosure.setState("animating", false);
    }));
    setup(disclosure, () => subscribe(disclosure, ["open"], () => {
      if (!disclosure.getState().animated) return;
      disclosure.setState("animating", true);
    }));
    setup(disclosure, () => sync(disclosure, ["open", "animating"], (state) => {
      disclosure.setState("mounted", state.open || state.animating);
    }));
    return {
      ...disclosure,
      disclosure: props.disclosure,
      setOpen: (value) => disclosure.setState("open", value),
      show: () => disclosure.setState("open", true),
      hide: () => disclosure.setState("open", false),
      toggle: () => disclosure.setState("open", (open2) => !open2),
      stopAnimation: () => disclosure.setState("animating", false),
      setContentElement: (value) => disclosure.setState("contentElement", value),
      setDisclosureElement: (value) => disclosure.setState("disclosureElement", value)
    };
  }

  // node_modules/@ariakit/react-components/dist/disclosure/disclosure-store.js
  function useDisclosureStoreProps(store, update, props) {
    useUpdateEffect(update, [props.store, props.disclosure]);
    useStoreProps(store, props, "open", "setOpen");
    useStoreProps(store, props, "mounted", "setMounted");
    useStoreProps(store, props, "animated");
    return Object.assign(store, { disclosure: props.disclosure });
  }
  function useDisclosureStore(props = {}) {
    const [store, update] = useStore(createDisclosureStore, props);
    return useDisclosureStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/tab/tab-panel.js
  var import_react12 = __toESM(require_react(), 1);
  var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
  var TagName9 = "div";
  var useTabPanel = createHook(function useTabPanel2({ store, unmountOnHide, tabId: tabIdProp, getItem: getItemProp, scrollRestoration, scrollElement, ...props }) {
    const context = useTabProviderContext();
    store = store || context;
    invariant(store, "TabPanel must receive a `store` prop or be wrapped in a TabProvider component.");
    const ref = (0, import_react12.useRef)(null);
    const id3 = useId(props.id);
    const tabId = useStoreState(store.panels, () => tabIdProp || store?.panels.item(id3)?.tabId);
    const disclosure = useDisclosureStore({ open: useStoreState(store, (state) => !!tabId && state.selectedId === tabId) });
    const mounted = useStoreState(disclosure, "mounted");
    const scrollPositionRef = (0, import_react12.useRef)(/* @__PURE__ */ new Map());
    const getScrollElement = useEvent(() => {
      const panelElement = ref.current;
      if (!panelElement) return null;
      if (!scrollElement) return panelElement;
      if (typeof scrollElement === "function") return scrollElement(panelElement);
      if ("current" in scrollElement) return scrollElement.current;
      return scrollElement;
    });
    (0, import_react12.useEffect)(() => {
      if (!scrollRestoration) return;
      if (!mounted) return;
      const element = getScrollElement();
      if (!element) return;
      if (scrollRestoration === "reset") {
        element.scroll(0, 0);
        return;
      }
      if (!tabId) return;
      const position2 = scrollPositionRef.current.get(tabId);
      element.scroll(position2?.x ?? 0, position2?.y ?? 0);
      const onScroll = () => {
        scrollPositionRef.current.set(tabId, {
          x: element.scrollLeft,
          y: element.scrollTop
        });
      };
      element.addEventListener("scroll", onScroll);
      return () => {
        element.removeEventListener("scroll", onScroll);
      };
    }, [
      scrollRestoration,
      mounted,
      tabId,
      getScrollElement
    ]);
    const [hasTabbableChildren, setHasTabbableChildren] = (0, import_react12.useState)(false);
    useSafeLayoutEffect(() => {
      if (!mounted) return;
      const element = ref.current;
      if (!element) return;
      setHasTabbableChildren(!!getFirstTabbableIn(element));
    }, [mounted, tabId]);
    const getItem = (0, import_react12.useCallback)((item2) => {
      const nextItem = {
        ...item2,
        id: id3 || item2.id,
        tabId: tabIdProp
      };
      if (getItemProp) return getItemProp(nextItem);
      return nextItem;
    }, [
      id3,
      tabIdProp,
      getItemProp
    ]);
    const onKeyDownProp = props.onKeyDown;
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (event.defaultPrevented) return;
      if (!store?.composite) return;
      const action = {
        ArrowLeft: store.previous,
        ArrowRight: store.next,
        Home: store.first,
        End: store.last
      }[event.key];
      if (!action) return;
      const { selectedId } = store.getState();
      const nextId = action({ activeId: selectedId });
      if (!nextId) return;
      event.preventDefault();
      store.move(nextId);
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(TabScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    props = {
      role: "tabpanel",
      "aria-labelledby": props["aria-label"] != null ? void 0 : tabId || void 0,
      ...props,
      id: id3,
      children: unmountOnHide && !mounted ? null : props.children,
      ref: useMergeRefs(ref, props.ref),
      onKeyDown
    };
    props = useFocusable({
      focusable: !store.composite && !hasTabbableChildren,
      ...props
    });
    props = useDisclosureContent({
      store: disclosure,
      ...props
    });
    props = useCollectionItem({
      store: store.panels,
      ...props,
      getItem
    });
    return props;
  });
  var TabPanel = forwardRef2(function TabPanel2(props) {
    return createElement(TagName9, useTabPanel(props));
  });

  // node_modules/@ariakit/react-components/dist/popover/popover-context.js
  var ctx6 = createStoreContext([DialogContextProvider], [DialogScopedContextProvider]);
  var usePopoverContext = ctx6.useContext;
  var usePopoverScopedContext = ctx6.useScopedContext;
  var usePopoverProviderContext = ctx6.useProviderContext;
  var PopoverContextProvider = ctx6.ContextProvider;
  var PopoverScopedContextProvider = ctx6.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/combobox/combobox-context.js
  var import_react13 = __toESM(require_react(), 1);
  var ComboboxListRoleContext = (0, import_react13.createContext)(void 0);
  var ctx7 = createStoreContext([PopoverContextProvider, CompositeContextProvider], [PopoverScopedContextProvider, CompositeScopedContextProvider]);
  var useComboboxContext = ctx7.useContext;
  var useComboboxScopedContext = ctx7.useScopedContext;
  var useComboboxProviderContext = ctx7.useProviderContext;
  var ComboboxContextProvider = ctx7.ContextProvider;
  var ComboboxScopedContextProvider = ctx7.ScopedContextProvider;
  var ComboboxItemValueContext = (0, import_react13.createContext)(void 0);
  var ComboboxItemCheckedContext = (0, import_react13.createContext)(false);

  // node_modules/@ariakit/react-components/dist/collection/collection-store.js
  function useCollectionStoreProps(store, update, props) {
    useUpdateEffect(update, [props.store]);
    useStoreProps(store, props, "items", "setItems");
    return store;
  }

  // node_modules/@ariakit/react-components/dist/composite/composite-store.js
  function useCompositeStoreOptions(props) {
    return {
      id: useId(props.id),
      ...props
    };
  }
  function useCompositeStoreProps(store, update, props) {
    store = useCollectionStoreProps(store, update, props);
    useStoreProps(store, props, "activeId", "setActiveId");
    useStoreProps(store, props, "includesBaseElement");
    useStoreProps(store, props, "virtualFocus");
    useStoreProps(store, props, "orientation");
    useStoreProps(store, props, "rtl");
    useStoreProps(store, props, "focusLoop");
    useStoreProps(store, props, "focusWrap");
    useStoreProps(store, props, "focusShift");
    return store;
  }
  function useCompositeStore(props = {}) {
    props = useCompositeStoreOptions(props);
    const [store, update] = useStore(createCompositeStore, props);
    return useCompositeStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/select/select-context.js
  var import_react14 = __toESM(require_react(), 1);
  var ctx8 = createStoreContext([PopoverContextProvider, CompositeContextProvider], [PopoverScopedContextProvider, CompositeScopedContextProvider]);
  var useSelectContext = ctx8.useContext;
  var useSelectScopedContext = ctx8.useScopedContext;
  var useSelectProviderContext = ctx8.useProviderContext;
  var SelectContextProvider = ctx8.ContextProvider;
  var SelectScopedContextProvider = ctx8.ScopedContextProvider;
  var SelectItemCheckedContext = (0, import_react14.createContext)(false);
  var SelectHeadingContext = (0, import_react14.createContext)(null);

  // node_modules/@ariakit/react-components/dist/tab/tab-store.js
  var import_react15 = __toESM(require_react(), 1);

  // node_modules/@ariakit/components/dist/tab/tab-store.js
  function getFocusedTab(items) {
    const activeElement = items[0]?.element?.ownerDocument.activeElement;
    if (!activeElement) return;
    return items.find((item2) => item2.element === activeElement);
  }
  function getTabById(items, id3) {
    if (id3 == null) return;
    return items.find((item2) => item2.id === id3);
  }
  function isEnabledTab(item2) {
    if (!item2) return false;
    if (item2.disabled) return false;
    if (item2.dimmed) return false;
    return true;
  }
  function createPanelsStore() {
    const panels = createCollectionStore();
    const panelsByTabId = /* @__PURE__ */ new Map();
    sync(panels, ["items"], (state) => {
      panelsByTabId.clear();
      for (const panel of state.items) {
        const { tabId } = panel;
        if (tabId == null) continue;
        if (panelsByTabId.has(tabId)) continue;
        panelsByTabId.set(tabId, panel);
      }
    });
    return {
      panels,
      panel: (tabId) => {
        if (tabId == null) return null;
        return panelsByTabId.get(tabId) || null;
      }
    };
  }
  function createTabStore({ composite: parentComposite, combobox, ...props } = {}) {
    const independentKeys = [
      "items",
      "renderedItems",
      "moves",
      "orientation",
      "virtualFocus",
      "includesBaseElement",
      "baseElement",
      "focusLoop",
      "focusShift",
      "focusWrap"
    ];
    const store = mergeStore(props.store, omit2(parentComposite, independentKeys), omit2(combobox, independentKeys));
    const syncState = store?.getState();
    const composite = createCompositeStore({
      ...props,
      store,
      includesBaseElement: defaultValue(props.includesBaseElement, syncState?.includesBaseElement, false),
      orientation: defaultValue(props.orientation, syncState?.orientation, "horizontal"),
      focusLoop: defaultValue(props.focusLoop, syncState?.focusLoop, true)
    });
    const { panels, panel } = createPanelsStore();
    const tab = createStore({
      ...composite.getState(),
      selectedId: defaultValue(props.selectedId, syncState?.selectedId, props.defaultSelectedId),
      selectOnMove: defaultValue(props.selectOnMove, syncState?.selectOnMove, true)
    }, composite, store);
    setup(tab, () => sync(tab, ["moves"], () => {
      const { activeId, selectOnMove } = tab.getState();
      if (!selectOnMove) return;
      if (!activeId) return;
      const tabItem = composite.item(activeId);
      if (!isEnabledTab(tabItem)) return;
      tab.setState("selectedId", tabItem.id);
    }));
    let pendingRestore = false;
    let restoredSelectedId;
    setup(tab, () => {
      pendingRestore = false;
      return batch(tab, ["selectedId"], (state, prev2) => {
        if (pendingRestore) {
          pendingRestore = false;
          if (state.selectedId === restoredSelectedId) return;
        }
        if (parentComposite && state.selectedId === prev2.selectedId) return;
        const { activeId, renderedItems } = tab.getState();
        const focusedTab = getFocusedTab(renderedItems);
        const selectedTab = getTabById(renderedItems, state.selectedId);
        if (focusedTab && isEnabledTab(selectedTab) && activeId !== selectedTab.id) {
          composite.move(selectedTab.id);
          return;
        }
        tab.setState("activeId", state.selectedId);
      });
    });
    setup(tab, () => sync(tab, ["selectedId", "renderedItems"], (state) => {
      if (state.selectedId !== void 0) return;
      const { activeId, renderedItems } = tab.getState();
      const tabItem = composite.item(activeId);
      if (isEnabledTab(tabItem)) tab.setState("selectedId", tabItem.id);
      else {
        const tabItem2 = renderedItems.find(isEnabledTab);
        tab.setState("selectedId", tabItem2?.id);
      }
    }));
    setup(tab, () => sync(tab, ["renderedItems"], (state) => {
      const tabs = state.renderedItems;
      if (!tabs.length) return;
      return sync(panels, ["renderedItems"], (state2) => {
        const items = state2.renderedItems;
        if (!items.some((panel2) => !panel2.tabId)) return;
        items.forEach((panel2, i3) => {
          if (panel2.tabId) return;
          const tabItem = tabs[i3];
          if (!tabItem) return;
          panels.renderItem({
            ...panel2,
            tabId: tabItem.id
          });
        });
      });
    }));
    let selectedIdFromSelectedValue = null;
    setup(tab, () => {
      const backupSelectedId = () => {
        selectedIdFromSelectedValue = tab.getState().selectedId;
      };
      const restoreSelectedId = () => {
        const { selectedId } = tab.getState();
        if (selectedId === selectedIdFromSelectedValue) return;
        pendingRestore = true;
        restoredSelectedId = selectedIdFromSelectedValue;
        tab.setState("selectedId", selectedIdFromSelectedValue);
      };
      if (parentComposite && "setSelectElement" in parentComposite) return chain(sync(parentComposite, ["value"], backupSelectedId), sync(parentComposite, ["mounted"], restoreSelectedId));
      if (!combobox) return;
      return chain(sync(combobox, ["selectedValue"], backupSelectedId), sync(combobox, ["mounted"], restoreSelectedId));
    });
    return {
      ...composite,
      ...tab,
      panels,
      panel,
      setSelectedId: (id3) => tab.setState("selectedId", id3),
      select: (id3) => {
        tab.setState("selectedId", id3);
        composite.move(id3);
      }
    };
  }

  // node_modules/@ariakit/react-components/dist/tab/tab-store.js
  function useTabStoreProps(store, update, props) {
    useUpdateEffect(update, [props.composite, props.combobox]);
    store = useCompositeStoreProps(store, update, props);
    useStoreProps(store, props, "selectedId", "setSelectedId");
    useStoreProps(store, props, "selectOnMove");
    const [panels, updatePanels] = useStore(() => store.panels, {});
    useUpdateEffect(updatePanels, [store, updatePanels]);
    return Object.assign((0, import_react15.useMemo)(() => ({
      ...store,
      panels
    }), [store, panels]), {
      composite: props.composite,
      combobox: props.combobox
    });
  }
  function useTabStore(props = {}) {
    const combobox = useComboboxContext();
    const composite = useSelectContext() || combobox;
    props = {
      ...props,
      composite: props.composite !== void 0 ? props.composite : composite,
      combobox: props.combobox !== void 0 ? props.combobox : combobox
    };
    const [store, update] = useStore(createTabStore, props);
    return useTabStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/toolbar/toolbar-context.js
  var ctx9 = createStoreContext([CompositeContextProvider], [CompositeScopedContextProvider]);
  var useToolbarContext = ctx9.useContext;
  var useToolbarScopedContext = ctx9.useScopedContext;
  var useToolbarProviderContext = ctx9.useProviderContext;
  var ToolbarContextProvider = ctx9.ContextProvider;
  var ToolbarScopedContextProvider = ctx9.ScopedContextProvider;

  // node_modules/@ariakit/components/dist/toolbar/toolbar-store.js
  function createToolbarStore(props = {}) {
    const syncState = props.store?.getState();
    return createCompositeStore({
      ...props,
      orientation: defaultValue(props.orientation, syncState?.orientation, "horizontal"),
      focusLoop: defaultValue(props.focusLoop, syncState?.focusLoop, true)
    });
  }

  // node_modules/@ariakit/react-components/dist/toolbar/toolbar-store.js
  function useToolbarStoreProps(store, update, props) {
    return useCompositeStoreProps(store, update, props);
  }
  function useToolbarStore(props = {}) {
    const [store, update] = useStore(createToolbarStore, props);
    return useToolbarStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/toolbar/toolbar.js
  var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
  var TagName10 = "div";
  var useToolbar = createHook(function useToolbar2({ store: storeProp, orientation: orientationProp, virtualFocus, focusLoop, rtl: rtl2, ...props }) {
    const context = useToolbarProviderContext();
    storeProp = storeProp || context;
    const store = useToolbarStore({
      store: storeProp,
      orientation: orientationProp,
      virtualFocus,
      focusLoop,
      rtl: rtl2
    });
    const orientation = useStoreState(store, (state) => state.orientation === "both" ? void 0 : state.orientation);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ToolbarScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    props = {
      role: "toolbar",
      "aria-orientation": orientation,
      ...props
    };
    props = useComposite({
      store,
      ...props
    });
    return props;
  });
  var Toolbar = forwardRef2(function Toolbar2(props) {
    return createElement(TagName10, useToolbar(props));
  });

  // node_modules/@ariakit/react-components/dist/toolbar/toolbar-item.js
  var TagName11 = "button";
  var useToolbarItem = createHook(function useToolbarItem2({ store, ...props }) {
    const context = useToolbarContext();
    store = store || context;
    props = useCompositeItem({
      store,
      ...props
    });
    return props;
  });
  var ToolbarItem = memo2(forwardRef2(function ToolbarItem2(props) {
    return createElement(TagName11, useToolbarItem(props));
  }));

  // node_modules/@ariakit/react-components/dist/separator/separator.js
  var TagName12 = "hr";
  var useSeparator = createHook(function useSeparator2({ orientation = "horizontal", ...props }) {
    props = {
      role: "separator",
      "aria-orientation": orientation,
      ...props
    };
    return props;
  });
  var Separator = forwardRef2(function Separator2(props) {
    return createElement(TagName12, useSeparator(props));
  });

  // node_modules/@ariakit/react-components/dist/composite/composite-separator.js
  var TagName13 = "hr";
  var useCompositeSeparator = createHook(function useCompositeSeparator2({ store, orientation: orientationProp, ...props }) {
    const context = useCompositeScopedContext();
    store = store || context;
    invariant(store, "CompositeSeparator must be wrapped in a Composite component.");
    const orientation = useStoreState(store, (state) => orientationProp ?? (state.orientation === "horizontal" ? "vertical" : "horizontal"));
    props = useSeparator({
      ...props,
      orientation
    });
    return props;
  });
  var CompositeSeparator = forwardRef2(function CompositeSeparator2(props) {
    return createElement(TagName13, useCompositeSeparator(props));
  });

  // node_modules/@ariakit/react-components/dist/focusable/focusable-container.js
  var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
  var TagName14 = "div";
  var useFocusableContainer = createHook(function useFocusableContainer2({ autoFocusOnShow = true, ...props }) {
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(FocusableContext.Provider, {
      value: autoFocusOnShow,
      children: element
    }), [autoFocusOnShow]);
    return props;
  });
  var FocusableContainer = forwardRef2(function FocusableContainer2(props) {
    return createElement(TagName14, useFocusableContainer(props));
  });

  // node_modules/@ariakit/react-components/dist/heading/heading-context.js
  var import_react16 = __toESM(require_react(), 1);
  var HeadingContext = (0, import_react16.createContext)(0);

  // node_modules/@ariakit/react-components/dist/heading/heading-level.js
  var import_react17 = __toESM(require_react(), 1);
  var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
  function HeadingLevel({ level, children }) {
    const contextLevel = (0, import_react17.useContext)(HeadingContext);
    const nextLevel = Math.max(Math.min(level || contextLevel + 1, 6), 1);
    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(HeadingContext.Provider, {
      value: nextLevel,
      children
    });
  }

  // node_modules/@ariakit/react-components/dist/visually-hidden/visually-hidden.js
  var TagName15 = "span";
  function getVisuallyHiddenStyle(style2) {
    return {
      borderWidth: 0,
      clipPath: "inset(50%)",
      height: "1px",
      margin: "-1px",
      overflow: "hidden",
      padding: 0,
      position: "absolute",
      whiteSpace: "nowrap",
      width: "1px",
      ...style2
    };
  }
  var useVisuallyHidden = createHook(function useVisuallyHidden2(props) {
    props = {
      ...props,
      style: getVisuallyHiddenStyle(props.style)
    };
    return props;
  });
  var VisuallyHidden = forwardRef2(function VisuallyHidden2(props) {
    return createElement(TagName15, useVisuallyHidden(props));
  });

  // node_modules/@ariakit/react-components/dist/focus-trap/focus-trap.js
  var TagName16 = "span";
  var useFocusTrap = createHook(function useFocusTrap2(props) {
    props = {
      "data-focus-trap": "",
      tabIndex: 0,
      "aria-hidden": true,
      ...props,
      style: {
        position: "fixed",
        top: 0,
        left: 0,
        ...props.style
      }
    };
    props = useVisuallyHidden(props);
    return props;
  });
  var FocusTrap = forwardRef2(function FocusTrap2(props) {
    return createElement(TagName16, useFocusTrap(props));
  });

  // node_modules/@ariakit/react-components/dist/portal/portal-context.js
  var import_react18 = __toESM(require_react(), 1);
  var PortalContext = (0, import_react18.createContext)(null);

  // node_modules/@ariakit/react-components/dist/portal/portal.js
  var import_react19 = __toESM(require_react(), 1);
  var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
  var import_react_dom2 = __toESM(require_react_dom(), 1);
  var TagName17 = "div";
  function getRootElement(element) {
    const doc = getDocument(element);
    const { fullscreenElement } = doc;
    const HTMLElementClass = doc.defaultView?.HTMLElement;
    if (HTMLElementClass && fullscreenElement instanceof HTMLElementClass) return fullscreenElement;
    return doc.body;
  }
  function getPortalElement(element, portalElement) {
    if (!portalElement) return getDocument(element).createElement("div");
    if (typeof portalElement === "function") return portalElement(element);
    return portalElement;
  }
  function getRandomId(prefix2 = "id") {
    return `${prefix2 ? `${prefix2}-` : ""}${Math.random().toString(36).slice(2, 8)}`;
  }
  function queueFocus(element) {
    queueMicrotask(() => {
      element?.focus();
    });
  }
  function attachPortalRef(ref, node2) {
    return {
      ref,
      node: node2,
      cleanup: setRef(ref, node2)
    };
  }
  function detachPortalRef(attached) {
    if (typeof attached.cleanup === "function") attached.cleanup();
    else setRef(attached.ref, null);
  }
  var usePortal = createHook(function usePortal2({ preserveTabOrder, preserveTabOrderAnchor, portalElement, portalRef, portal = true, ...props }) {
    const ref = (0, import_react19.useRef)(null);
    const refProp = useMergeRefs(ref, props.ref);
    const context = (0, import_react19.useContext)(PortalContext);
    const [portalNode, setPortalNode] = (0, import_react19.useState)(null);
    const [anchorPortalNode, setAnchorPortalNode] = (0, import_react19.useState)(null);
    const outerBeforeRef = (0, import_react19.useRef)(null);
    const innerBeforeRef = (0, import_react19.useRef)(null);
    const innerAfterRef = (0, import_react19.useRef)(null);
    const outerAfterRef = (0, import_react19.useRef)(null);
    const portalRefProp = useLiveRef(portalRef);
    const attachedPortalRefRef = (0, import_react19.useRef)(null);
    useSafeLayoutEffect(() => {
      const element = ref.current;
      if (!element || !portal) {
        setPortalNode(null);
        return;
      }
      const portalEl = getPortalElement(element, portalElement);
      if (!portalEl) {
        setPortalNode(null);
        return;
      }
      const isPortalInDocument = portalEl.isConnected;
      if (!isPortalInDocument) (context || getRootElement(element)).appendChild(portalEl);
      if (!portalEl.id) portalEl.id = element.id ? `portal/${element.id}` : getRandomId();
      setPortalNode(portalEl);
      attachedPortalRefRef.current = attachPortalRef(portalRefProp.current, portalEl);
      return () => {
        const attached = attachedPortalRefRef.current;
        if (attached) {
          attachedPortalRefRef.current = null;
          detachPortalRef(attached);
        }
        if (!isPortalInDocument) portalEl.remove();
      };
    }, [
      portal,
      portalElement,
      context
    ]);
    useSafeLayoutEffect(() => {
      const attached = attachedPortalRefRef.current;
      if (!attached) return;
      if (attached.ref === portalRef) return;
      detachPortalRef(attached);
      attachedPortalRefRef.current = attachPortalRef(portalRef, attached.node);
    }, [portalRef]);
    (0, import_react19.useEffect)(() => {
      if (!portalNode) return;
      if (context) return;
      if (portalElement) return;
      const doc = getDocument(portalNode);
      const onFullscreenChange = () => {
        const rootElement = getRootElement(portalNode);
        if (portalNode.parentElement !== rootElement) rootElement.appendChild(portalNode);
      };
      if (portalNode.isConnected) onFullscreenChange();
      doc.addEventListener("fullscreenchange", onFullscreenChange);
      return () => {
        doc.removeEventListener("fullscreenchange", onFullscreenChange);
      };
    }, [
      portalNode,
      context,
      portalElement
    ]);
    useSafeLayoutEffect(() => {
      if (!portal) return;
      if (!preserveTabOrder) return;
      if (!preserveTabOrderAnchor) return;
      const element = getDocument(preserveTabOrderAnchor).createElement("span");
      element.style.position = "fixed";
      preserveTabOrderAnchor.insertAdjacentElement("afterend", element);
      setAnchorPortalNode(element);
      return () => {
        element.remove();
        setAnchorPortalNode(null);
      };
    }, [
      portal,
      preserveTabOrder,
      preserveTabOrderAnchor
    ]);
    (0, import_react19.useEffect)(() => {
      if (!portalNode) return;
      if (!preserveTabOrder) return;
      let raf = 0;
      const onFocus = (event) => {
        if (!isFocusEventOutside(event)) return;
        const focusing = event.type === "focusin";
        cancelAnimationFrame(raf);
        if (focusing) return restoreFocusIn(portalNode);
        raf = requestAnimationFrame(() => {
          disableFocusIn(portalNode, true);
        });
      };
      portalNode.addEventListener("focusin", onFocus, true);
      portalNode.addEventListener("focusout", onFocus, true);
      return () => {
        cancelAnimationFrame(raf);
        portalNode.removeEventListener("focusin", onFocus, true);
        portalNode.removeEventListener("focusout", onFocus, true);
      };
    }, [portalNode, preserveTabOrder]);
    props = useWrapElement(props, (element) => {
      element = /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(PortalContext.Provider, {
        value: portalNode || context,
        children: element
      });
      if (!portal) return element;
      if (!portalNode) return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", {
        ref: refProp,
        id: props.id,
        style: { position: "fixed" },
        hidden: true
      });
      element = /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
        preserveTabOrder && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(FocusTrap, {
          ref: innerBeforeRef,
          "data-focus-trap": props.id,
          className: "__focus-trap-inner-before",
          onFocus: (event) => {
            if (isFocusEventOutside(event, portalNode)) queueFocus(getNextTabbable());
            else queueFocus(outerBeforeRef.current);
          }
        }),
        element,
        preserveTabOrder && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(FocusTrap, {
          ref: innerAfterRef,
          "data-focus-trap": props.id,
          className: "__focus-trap-inner-after",
          onFocus: (event) => {
            if (isFocusEventOutside(event, portalNode)) queueFocus(getPreviousTabbable());
            else queueFocus(outerAfterRef.current);
          }
        })
      ] });
      element = (0, import_react_dom2.createPortal)(element, portalNode);
      let preserveTabOrderElement = /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
        preserveTabOrder && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(FocusTrap, {
          ref: outerBeforeRef,
          "data-focus-trap": props.id,
          className: "__focus-trap-outer-before",
          onFocus: (event) => {
            if (!(event.relatedTarget === outerAfterRef.current) && isFocusEventOutside(event, portalNode)) queueFocus(innerBeforeRef.current);
            else queueFocus(getPreviousTabbable());
          }
        }),
        preserveTabOrder && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", {
          "aria-owns": portalNode.id,
          style: { position: "fixed" }
        }),
        preserveTabOrder && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(FocusTrap, {
          ref: outerAfterRef,
          "data-focus-trap": props.id,
          className: "__focus-trap-outer-after",
          onFocus: (event) => {
            if (isFocusEventOutside(event, portalNode)) queueFocus(innerAfterRef.current);
            else {
              const nextTabbable = getNextTabbable();
              if (nextTabbable === innerBeforeRef.current) {
                requestAnimationFrame(() => getNextTabbable()?.focus());
                return;
              }
              queueFocus(nextTabbable);
            }
          }
        })
      ] });
      if (anchorPortalNode && preserveTabOrder) preserveTabOrderElement = (0, import_react_dom2.createPortal)(preserveTabOrderElement, anchorPortalNode);
      return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [preserveTabOrderElement, element] });
    }, [
      portalNode,
      context,
      portal,
      props.id,
      preserveTabOrder,
      anchorPortalNode
    ]);
    props = {
      ...props,
      ref: refProp
    };
    return props;
  });
  var Portal = forwardRef2(function Portal2(props) {
    return createElement(TagName17, usePortal(props));
  });

  // node_modules/@ariakit/react-components/dist/dialog/utils/is-backdrop.js
  function isBackdrop(element, ...ids) {
    if (!element) return false;
    const backdrop = element.getAttribute("data-backdrop");
    if (backdrop == null) return false;
    if (backdrop === "") return true;
    if (backdrop === "true") return true;
    if (!ids.length) return true;
    return ids.some((id3) => backdrop === id3);
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/orchestrate.js
  var cleanups = /* @__PURE__ */ new WeakMap();
  function flushCleanupStack(elementCleanups, key, stack) {
    while (stack.length) {
      const entry = stack[stack.length - 1];
      if (!entry) {
        elementCleanups.delete(key);
        return;
      }
      if (!entry.disposed) return;
      stack.pop();
      entry.cleanup();
    }
    elementCleanups.delete(key);
  }
  function orchestrate(element, key, setup2) {
    let elementCleanups = cleanups.get(element);
    if (!elementCleanups) {
      elementCleanups = /* @__PURE__ */ new Map();
      cleanups.set(element, elementCleanups);
    }
    const stack = elementCleanups.get(key) ?? [];
    const entry = {
      cleanup: setup2(),
      disposed: false
    };
    if (!stack.length) elementCleanups.set(key, stack);
    stack.push(entry);
    return () => {
      if (!stack.includes(entry)) return;
      entry.disposed = true;
      flushCleanupStack(elementCleanups, key, stack);
    };
  }
  function setAttribute(element, attr, value) {
    const setup2 = () => {
      const previousValue = element.getAttribute(attr);
      element.setAttribute(attr, value);
      return () => {
        if (previousValue == null) element.removeAttribute(attr);
        else element.setAttribute(attr, previousValue);
      };
    };
    return orchestrate(element, attr, setup2);
  }
  function setProperty(element, property, value) {
    const setup2 = () => {
      const exists = property in element;
      const previousValue = element[property];
      element[property] = value;
      return () => {
        if (!exists) delete element[property];
        else element[property] = previousValue;
      };
    };
    return orchestrate(element, property, setup2);
  }
  function assignStyle(element, style2) {
    if (!element) return () => {
    };
    const setup2 = () => {
      const prevStyle = element.style.cssText;
      Object.assign(element.style, style2);
      return () => {
        element.style.cssText = prevStyle;
      };
    };
    return orchestrate(element, "style", setup2);
  }
  function setCSSProperty(element, property, value) {
    if (!element) return () => {
    };
    const setup2 = () => {
      const previousValue = element.style.getPropertyValue(property);
      element.style.setProperty(property, value);
      return () => {
        if (previousValue) element.style.setProperty(property, previousValue);
        else element.style.removeProperty(property);
      };
    };
    return orchestrate(element, property, setup2);
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/tree-cleanup.js
  function getPropertyName(id3 = "", kind = "outside") {
    return `__ariakit-dialog-${kind}${id3 ? `-${id3}` : ""}`;
  }
  function markElement(element, id3 = "") {
    return chain(setProperty(element, getPropertyName(), true), setProperty(element, getPropertyName(id3), true));
  }
  function markAncestor(element, id3 = "") {
    return chain(setProperty(element, getPropertyName("", "ancestor"), true), setProperty(element, getPropertyName(id3, "ancestor"), true));
  }
  function markTreeInside(id3, elements2) {
    return chain(...elements2.map((element) => {
      if (!element) return void 0;
      return setProperty(element, getPropertyName(id3, "inside"), true);
    }));
  }
  function isElementInside(element, id3) {
    const propertyName = getPropertyName(id3, "inside");
    do {
      if (element[propertyName]) return true;
      if (!element.parentElement) return false;
      element = element.parentElement;
    } while (true);
  }
  function isElementMarked(element, id3) {
    const ancestorProperty = getPropertyName(id3, "ancestor");
    if (element[ancestorProperty]) return true;
    const elementProperty = getPropertyName(id3);
    do {
      if (element[elementProperty]) return true;
      if (!element.parentElement) return false;
      element = element.parentElement;
    } while (true);
  }
  function addElementMarkCleanup({ cleanups: cleanups2, element, id: id3, ids }) {
    if (isBackdrop(element, ...ids)) return;
    cleanups2.push(markElement(element, id3));
  }
  function addAncestorMarkCleanup({ cleanups: cleanups2, ancestor, element, id: id3 }) {
    if (element.hasAttribute("data-dialog") && element.id !== id3) return;
    cleanups2.push(markAncestor(ancestor, id3));
  }
  function restoreCleanups(cleanups2) {
    for (let index2 = cleanups2.length - 1; index2 >= 0; index2 -= 1) cleanups2[index2]?.();
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/walk-tree-outside.js
  var ignoreTags = ["SCRIPT", "STYLE"];
  function getSnapshotPropertyName(id3) {
    return `__ariakit-dialog-snapshot-${id3}`;
  }
  function inSnapshot(id3, element) {
    const doc = getDocument(element);
    const propertyName = getSnapshotPropertyName(id3);
    if (!doc.body[propertyName]) return true;
    do {
      if (element === doc.body) return false;
      if (element[propertyName]) return true;
      if (!element.parentElement) return false;
      element = element.parentElement;
    } while (true);
  }
  function shouldWalkElement(id3, element, ignoredElements) {
    if (ignoreTags.includes(element.tagName)) return false;
    if (!inSnapshot(id3, element)) return false;
    return !ignoredElements.some((enabledElement) => enabledElement && contains(element, enabledElement));
  }
  function walkTreeOutside(id3, elements2, callback, ancestorCallback) {
    for (let element of elements2) {
      if (!element?.isConnected) continue;
      const hasAncestorAlready = elements2.some((maybeAncestor) => {
        if (!maybeAncestor) return false;
        if (maybeAncestor === element) return false;
        return maybeAncestor.contains(element);
      });
      const doc = getDocument(element);
      const originalElement = element;
      while (element.parentElement && element !== doc.body) {
        ancestorCallback?.(element.parentElement, originalElement);
        if (!hasAncestorAlready) {
          for (const child of element.parentElement.children) if (shouldWalkElement(id3, child, elements2)) callback(child, originalElement);
        }
        element = element.parentElement;
      }
    }
  }
  function createWalkTreeSnapshot(id3, elements2) {
    const { body } = getDocument(elements2[0]);
    const cleanups2 = [];
    const markElement2 = (element) => {
      cleanups2.push(setProperty(element, getSnapshotPropertyName(id3), true));
    };
    walkTreeOutside(id3, elements2, markElement2);
    return chain(setProperty(body, getSnapshotPropertyName(id3), true), () => {
      for (const cleanup of cleanups2) cleanup();
    });
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/mark-tree-outside.js
  function markTreeOutside(id3, elements2) {
    const cleanups2 = [];
    const ids = elements2.map((el) => el?.id);
    walkTreeOutside(id3, elements2, (element) => {
      addElementMarkCleanup({
        cleanups: cleanups2,
        element,
        id: id3,
        ids
      });
    }, (ancestor, element) => {
      addAncestorMarkCleanup({
        cleanups: cleanups2,
        ancestor,
        element,
        id: id3
      });
    });
    const restoreAccessibilityTree = () => {
      restoreCleanups(cleanups2);
    };
    return restoreAccessibilityTree;
  }

  // node_modules/@ariakit/react-components/dist/role/role.js
  var TagName18 = "div";
  var elements = [
    "a",
    "button",
    "details",
    "dialog",
    "div",
    "form",
    "h1",
    "h2",
    "h3",
    "h4",
    "h5",
    "h6",
    "header",
    "img",
    "input",
    "label",
    "li",
    "nav",
    "ol",
    "p",
    "section",
    "select",
    "span",
    "summary",
    "textarea",
    "ul",
    "svg"
  ];
  var useRole = createHook(function useRole2(props) {
    return props;
  });
  var Role = forwardRef2(function Role2(props) {
    return createElement(TagName18, props);
  });
  Object.assign(Role, elements.reduce((acc, element) => {
    acc[element] = forwardRef2(function Role3(props) {
      return createElement(element, props);
    });
    return acc;
  }, {}));

  // node_modules/@ariakit/react-components/dist/dialog/dialog-backdrop.js
  var import_react20 = __toESM(require_react(), 1);
  var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
  function DialogBackdrop({ store, backdrop, backdropRef, alwaysVisible, hidden }) {
    const ref = (0, import_react20.useRef)(null);
    const disclosure = useDisclosureStore({ disclosure: store });
    const contentElement = useStoreState(store, "contentElement");
    useSafeLayoutEffect(() => {
      const backdrop2 = ref.current;
      const dialog = contentElement;
      if (!backdrop2) return;
      if (!dialog) return;
      backdrop2.style.zIndex = getComputedStyle(dialog).zIndex;
    }, [contentElement]);
    useSafeLayoutEffect(() => {
      const id3 = contentElement?.id;
      if (!id3) return;
      const backdrop2 = ref.current;
      if (!backdrop2) return;
      return markAncestor(backdrop2, id3);
    }, [contentElement]);
    const props = useDisclosureContent({
      ref: useMergeRefs(ref, backdropRef),
      store: disclosure,
      role: "presentation",
      "data-backdrop": contentElement?.id || "",
      alwaysVisible,
      hidden: hidden != null ? hidden : void 0,
      style: {
        position: "fixed",
        top: 0,
        right: 0,
        bottom: 0,
        left: 0
      }
    });
    if (!backdrop) return null;
    if ((0, import_react20.isValidElement)(backdrop)) return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Role, {
      ...props,
      render: backdrop
    });
    const Component7 = typeof backdrop !== "boolean" ? backdrop : "div";
    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Role, {
      ...props,
      render: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Component7, {})
    });
  }

  // node_modules/@ariakit/components/dist/dialog/dialog-store.js
  function createDialogStore(props = {}) {
    return createDisclosureStore(props);
  }

  // node_modules/@ariakit/react-components/dist/dialog/dialog-store.js
  function useDialogStoreProps(store, update, props) {
    return useDisclosureStoreProps(store, update, props);
  }
  function useDialogStore(props = {}) {
    const [store, update] = useStore(createDialogStore, props);
    return useDialogStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/supports-inert.js
  function supportsInert() {
    return "inert" in HTMLElement.prototype;
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/disable-accessibility-tree-outside.js
  function hideElementFromAccessibilityTree(element) {
    return setAttribute(element, "aria-hidden", "true");
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/is-focus-trap.js
  function isFocusTrap(element, ...ids) {
    if (!element) return false;
    const attr = element.getAttribute("data-focus-trap");
    if (attr == null) return false;
    if (!ids.length) return true;
    if (attr === "") return false;
    return ids.some((id3) => attr === id3);
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/disable-tree.js
  function disableTree(element, ignoredElements) {
    if (!("style" in element)) return noop;
    if (supportsInert()) return setProperty(element, "inert", true);
    return chain(...getAllTabbableIn(element, true).map((element2) => {
      if (ignoredElements?.some((el) => el && contains(el, element2))) return noop;
      const restoreFocusMethod = orchestrate(element2, "focus", () => {
        element2.focus = noop;
        return () => {
          delete element2.focus;
        };
      });
      return chain(setAttribute(element2, "tabindex", "-1"), restoreFocusMethod);
    }), hideElementFromAccessibilityTree(element), assignStyle(element, {
      pointerEvents: "none",
      userSelect: "none",
      cursor: "default"
    }));
  }
  function addDisabledElementCleanup({ cleanups: cleanups2, element, elements: elements2, ids }) {
    if (isBackdrop(element, ...ids)) return;
    if (isFocusTrap(element, ...ids)) return;
    cleanups2.push(disableTree(element, elements2));
  }
  function addRoleNoneCleanup(cleanups2, ancestor, elements2) {
    if (!ancestor.hasAttribute("role")) return;
    if (elements2.some((el) => el && contains(el, ancestor))) return;
    cleanups2.push(setAttribute(ancestor, "role", "none"));
  }
  function markAndDisableTreeOutside(id3, elements2) {
    const cleanups2 = [];
    const ids = elements2.map((el) => el?.id);
    walkTreeOutside(id3, elements2, (element) => {
      addElementMarkCleanup({
        cleanups: cleanups2,
        element,
        id: id3,
        ids
      });
      addDisabledElementCleanup({
        cleanups: cleanups2,
        element,
        elements: elements2,
        ids
      });
    }, (ancestor, element) => {
      addAncestorMarkCleanup({
        cleanups: cleanups2,
        ancestor,
        element,
        id: id3
      });
      addRoleNoneCleanup(cleanups2, ancestor, elements2);
    });
    const restoreTreeOutside = () => {
      restoreCleanups(cleanups2);
    };
    return restoreTreeOutside;
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/prepend-hidden-dismiss.js
  function prependHiddenDismiss(container, onClick) {
    const button = getDocument(container).createElement("button");
    button.type = "button";
    button.tabIndex = -1;
    button.textContent = "Dismiss popup";
    Object.assign(button.style, getVisuallyHiddenStyle());
    button.addEventListener("click", onClick);
    container.prepend(button);
    const removeHiddenDismiss = () => {
      button.removeEventListener("click", onClick);
      button.remove();
    };
    return removeHiddenDismiss;
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/use-previous-mouse-down-ref.js
  var import_react21 = __toESM(require_react(), 1);
  function usePreviousMouseDownRef(enabled, scope) {
    const previousMouseDownRef = (0, import_react21.useRef)(null);
    (0, import_react21.useEffect)(() => {
      if (!enabled) {
        previousMouseDownRef.current = null;
        return;
      }
      const onMouseDown = (event) => {
        previousMouseDownRef.current = event.target;
      };
      return addGlobalEventListener("mousedown", onMouseDown, true, scope);
    }, [enabled, scope]);
    return previousMouseDownRef;
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/use-hide-on-interact-outside.js
  var import_react22 = __toESM(require_react(), 1);
  function isInDocument(target) {
    if (target.tagName === "HTML") return true;
    return contains(getDocument(target).body, target);
  }
  function isDisclosure(disclosure, target) {
    if (!disclosure) return false;
    if (contains(disclosure, target)) return true;
    const activeId = target.getAttribute("aria-activedescendant");
    if (activeId) {
      const activeElement = getDocument(disclosure).getElementById(activeId);
      if (activeElement) return contains(disclosure, activeElement);
    }
    return false;
  }
  function isMouseEventOnDialog(event, dialog) {
    if (!("clientY" in event)) return false;
    const rect = dialog.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 useEventOutside({ store, type, listener, capture, open, contentElement, focusedRef }) {
    const callListener = useEvent(listener);
    (0, import_react22.useEffect)(() => {
      if (!open) return;
      const onEvent = (event) => {
        const { contentElement: contentElement2, disclosureElement } = store.getState();
        const target = event.target;
        if (!contentElement2) return;
        if (!isElement(target)) return;
        if (!isInDocument(target)) return;
        if (contains(contentElement2, target)) return;
        if (isDisclosure(disclosureElement, target)) return;
        if (target.hasAttribute("data-focus-trap")) return;
        if (isMouseEventOnDialog(event, contentElement2)) return;
        if (isElementInside(target, contentElement2.id)) return;
        if (focusedRef.current && !isElementMarked(target, contentElement2.id)) return;
        callListener(event);
      };
      return addGlobalEventListener(type, onEvent, capture, contentElement ? getWindow(contentElement) : void 0);
    }, [
      open,
      capture,
      store,
      type,
      callListener,
      contentElement,
      focusedRef
    ]);
  }
  function shouldHideOnInteractOutside(hideOnInteractOutside, event) {
    if (typeof hideOnInteractOutside === "function") return hideOnInteractOutside(event);
    return !!hideOnInteractOutside;
  }
  function useHideOnInteractOutside(store, hideOnInteractOutside, domReady, interactedOutsideRef) {
    const open = useStoreState(store, "open");
    const contentElement = useStoreState(store, "contentElement");
    const previousMouseDownRef = usePreviousMouseDownRef(open, contentElement ? getWindow(contentElement) : void 0);
    const focusedRef = (0, import_react22.useRef)(false);
    useSafeLayoutEffect(() => {
      if (!open) return;
      if (!domReady) return;
      if (!contentElement) return;
      focusedRef.current = false;
      const onFocus = () => {
        focusedRef.current = true;
      };
      contentElement.addEventListener("focusin", onFocus, true);
      return () => contentElement.removeEventListener("focusin", onFocus, true);
    }, [
      open,
      domReady,
      contentElement
    ]);
    const props = {
      store,
      capture: true,
      open,
      contentElement,
      focusedRef
    };
    useEventOutside({
      ...props,
      type: "click",
      listener: (event) => {
        const { contentElement: contentElement2 } = store.getState();
        const previousMouseDown = previousMouseDownRef.current;
        if (!previousMouseDown) return;
        if (!isElementMarked(previousMouseDown, contentElement2?.id)) return;
        if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
        if (interactedOutsideRef) interactedOutsideRef.current = true;
        store.hide();
      }
    });
    useEventOutside({
      ...props,
      type: "focusin",
      listener: (event) => {
        const { contentElement: contentElement2 } = store.getState();
        if (!contentElement2) return;
        if (event.target === getDocument(contentElement2)) return;
        if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
        store.hide();
      }
    });
    useEventOutside({
      ...props,
      type: "contextmenu",
      listener: (event) => {
        if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
        if (interactedOutsideRef) interactedOutsideRef.current = true;
        store.hide();
      }
    });
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/use-nested-dialogs.js
  var import_react23 = __toESM(require_react(), 1);
  var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
  var NestedDialogsContext = (0, import_react23.createContext)({});
  function useNestedDialogs(store) {
    const context = (0, import_react23.useContext)(NestedDialogsContext);
    const [dialogs, setDialogs] = (0, import_react23.useState)([]);
    const add2 = (0, import_react23.useCallback)((dialog) => {
      setDialogs((dialogs2) => [...dialogs2, dialog]);
      return chain(context.add?.(dialog), () => {
        setDialogs((dialogs2) => dialogs2.filter((d3) => d3 !== dialog));
      });
    }, [context]);
    useSafeLayoutEffect(() => {
      return sync(store, ["open", "contentElement"], (state) => {
        if (!state.open) return;
        if (!state.contentElement) return;
        return context.add?.(store);
      });
    }, [store, context]);
    const providerValue = (0, import_react23.useMemo)(() => ({
      store,
      add: add2
    }), [store, add2]);
    return {
      wrapElement: (0, import_react23.useCallback)((element) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(NestedDialogsContext.Provider, {
        value: providerValue,
        children: element
      }), [providerValue]),
      nestedDialogs: dialogs
    };
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/use-root-dialog.js
  var import_react24 = __toESM(require_react(), 1);
  var import_react_dom3 = __toESM(require_react_dom(), 1);
  function useRootDialog({ attribute, contentId, contentElement, enabled }) {
    const [updated, retry] = useForceUpdate();
    const isRootDialog = (0, import_react24.useCallback)(() => {
      if (!enabled) return false;
      if (!contentElement) return false;
      const { body } = getDocument(contentElement);
      const id3 = body.getAttribute(attribute);
      return !id3 || id3 === contentId;
    }, [
      updated,
      enabled,
      contentElement,
      attribute,
      contentId
    ]);
    useSafeLayoutEffect(() => {
      if (!enabled) return;
      if (!contentId) return;
      if (!contentElement) return;
      const { body } = getDocument(contentElement);
      if (isRootDialog()) {
        body.setAttribute(attribute, contentId);
        return () => body.removeAttribute(attribute);
      }
      const observer = new MutationObserver(() => (0, import_react_dom3.flushSync)(retry));
      observer.observe(body, { attributeFilter: [attribute] });
      return () => observer.disconnect();
    }, [
      updated,
      enabled,
      contentId,
      contentElement,
      isRootDialog,
      attribute
    ]);
    return isRootDialog;
  }

  // node_modules/@ariakit/react-components/dist/dialog/utils/use-prevent-body-scroll.js
  var import_react25 = __toESM(require_react(), 1);
  var isIOS = isApple() && !isMac();
  function getPaddingProperty(documentElement) {
    const documentLeft = documentElement.getBoundingClientRect().left;
    return Math.round(documentLeft) + documentElement.scrollLeft ? "paddingLeft" : "paddingRight";
  }
  function usePreventBodyScroll(contentElement, contentId, enabled) {
    const isRootDialog = useRootDialog({
      attribute: "data-dialog-prevent-body-scroll",
      contentElement,
      contentId,
      enabled
    });
    (isIOS ? import_react25.useEffect : useSafeLayoutEffect)(() => {
      if (!isRootDialog()) return;
      if (!contentElement) return;
      const doc = getDocument(contentElement);
      const win = getWindow(contentElement);
      const { documentElement, body } = doc;
      const cssScrollbarWidth = documentElement.style.getPropertyValue("--scrollbar-width");
      const scrollbarWidth = cssScrollbarWidth ? Number.parseInt(cssScrollbarWidth, 10) : win.innerWidth - documentElement.clientWidth;
      const setScrollbarWidthProperty = () => setCSSProperty(documentElement, "--scrollbar-width", `${scrollbarWidth}px`);
      const paddingProperty = getPaddingProperty(documentElement);
      const setStyle = () => assignStyle(body, {
        overflow: "hidden",
        [paddingProperty]: `${scrollbarWidth}px`
      });
      const setIOSStyle = () => {
        const { scrollX: scrollX2, scrollY: scrollY2, visualViewport } = win;
        const offsetLeft = visualViewport?.offsetLeft ?? 0;
        const offsetTop = visualViewport?.offsetTop ?? 0;
        const restoreStyle = assignStyle(body, {
          position: "fixed",
          overflow: "hidden",
          top: `${-(scrollY2 - Math.floor(offsetTop))}px`,
          left: `${-(scrollX2 - Math.floor(offsetLeft))}px`,
          right: "0",
          [paddingProperty]: `${scrollbarWidth}px`
        });
        return () => {
          restoreStyle();
          if (true) win.scrollTo({
            left: scrollX2,
            top: scrollY2,
            behavior: "instant"
          });
        };
      };
      const restore = chain(setScrollbarWidthProperty(), isIOS ? setIOSStyle() : setStyle());
      if (isIOS) return restore;
      return () => {
        queueMicrotask(restore);
      };
    }, [isRootDialog, contentElement]);
  }

  // node_modules/@ariakit/react-components/dist/dialog/dialog.js
  var import_react26 = __toESM(require_react(), 1);
  var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
  var TagName19 = "div";
  var isSafariBrowser2 = isSafari();
  function isAlreadyFocusingAnotherElement(dialog) {
    const activeElement = getActiveElement(dialog);
    if (!activeElement) return false;
    if (dialog && contains(dialog, activeElement)) return false;
    if (isFocusable(activeElement)) return true;
    return false;
  }
  function getElementFromProp(prop, focusable = false) {
    if (!prop) return null;
    const element = "current" in prop ? prop.current : prop;
    if (!element) return null;
    if (focusable) return isFocusable(element) ? element : null;
    return element;
  }
  var useDialog = createHook(function useDialog2({ store: storeProp, open: openProp, onClose, focusable = true, modal = true, portal = modal, backdrop = modal, hideOnEscape = true, hideOnInteractOutside = true, getPersistentElements, preventBodyScroll = modal, autoFocusOnShow = true, autoFocusOnHide = true, initialFocus, finalFocus, unmountOnHide, unstable_treeSnapshotKey, ...props }) {
    const context = useDialogProviderContext();
    const ref = (0, import_react26.useRef)(null);
    const backdropRef = (0, import_react26.useRef)(null);
    const store = useDialogStore({
      store: storeProp || context,
      open: openProp,
      setOpen(open2) {
        if (open2) return;
        const dialog = ref.current;
        if (!dialog) return;
        const event = new Event("close", {
          bubbles: false,
          cancelable: true
        });
        if (onClose) dialog.addEventListener("close", onClose, { once: true });
        dialog.dispatchEvent(event);
        if (!event.defaultPrevented) return;
        store.setOpen(true);
      }
    });
    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);
    const preserveTabOrderProp = props.preserveTabOrder;
    const preserveTabOrder = useStoreState(store, (state) => preserveTabOrderProp && !modal && state.mounted);
    const id3 = useId(props.id);
    const open = useStoreState(store, "open");
    const mounted = useStoreState(store, "mounted");
    const contentElement = useStoreState(store, "contentElement");
    const hidden = isHidden(mounted, props.hidden, props.alwaysVisible);
    usePreventBodyScroll(contentElement, id3, preventBodyScroll && !hidden);
    const interactedOutsideRef = (0, import_react26.useRef)(false);
    useSafeLayoutEffect(() => {
      return sync(store, ["open"], (state) => {
        if (!state.open) return;
        interactedOutsideRef.current = false;
      });
    }, [store]);
    useHideOnInteractOutside(store, hideOnInteractOutside, domReady, interactedOutsideRef);
    const { wrapElement, nestedDialogs } = useNestedDialogs(store);
    props = useWrapElement(props, wrapElement, [wrapElement]);
    const lastMousedownRef = (0, import_react26.useRef)(null);
    if (isSafariBrowser2) (0, import_react26.useEffect)(() => {
      if (!domReady) return;
      const dialog = ref.current;
      if (!dialog) return;
      const doc = getDocument(dialog);
      const onMousedown = (event) => {
        lastMousedownRef.current = event.target;
      };
      doc.addEventListener("mousedown", onMousedown, true);
      return () => {
        doc.removeEventListener("mousedown", onMousedown, true);
      };
    }, [domReady]);
    useSafeLayoutEffect(() => {
      if (!open) return;
      const dialog = ref.current;
      const activeElement = getActiveElement(dialog, true);
      if (!activeElement) return;
      if (activeElement.tagName === "BODY") {
        const fallback = lastMousedownRef.current;
        lastMousedownRef.current = null;
        if (!fallback?.isConnected) return;
        if (!isFocusable(fallback)) return;
        if (dialog && contains(dialog, fallback)) return;
        store.setDisclosureElement(fallback);
        return;
      }
      if (dialog && contains(dialog, activeElement)) return;
      store.setDisclosureElement(activeElement);
    }, [store, open]);
    (0, import_react26.useEffect)(() => {
      if (!mounted) return;
      if (!domReady) return;
      const dialog = ref.current;
      if (!dialog) return;
      const win = getWindow(dialog);
      const viewport = win.visualViewport || win;
      const setViewportHeight = () => {
        const height = win.visualViewport?.height ?? win.innerHeight;
        dialog.style.setProperty("--dialog-viewport-height", `${height}px`);
      };
      setViewportHeight();
      viewport.addEventListener("resize", setViewportHeight);
      return () => {
        viewport.removeEventListener("resize", setViewportHeight);
      };
    }, [mounted, domReady]);
    (0, import_react26.useEffect)(() => {
      if (!modal) return;
      if (!mounted) return;
      if (!domReady) return;
      const dialog = ref.current;
      if (!dialog) return;
      if (dialog.querySelector("[data-dialog-dismiss]")) return;
      return prependHiddenDismiss(dialog, store.hide);
    }, [
      store,
      modal,
      mounted,
      domReady
    ]);
    useSafeLayoutEffect(() => {
      if (!supportsInert()) return;
      if (open) return;
      if (!mounted) return;
      if (!domReady) return;
      const dialog = ref.current;
      if (!dialog) return;
      return disableTree(dialog);
    }, [
      open,
      mounted,
      domReady
    ]);
    const canTakeTreeSnapshot = open && domReady;
    useSafeLayoutEffect(() => {
      if (!id3) return;
      if (!canTakeTreeSnapshot) return;
      const dialog = ref.current;
      return createWalkTreeSnapshot(id3, [dialog]);
    }, [
      id3,
      canTakeTreeSnapshot,
      unstable_treeSnapshotKey
    ]);
    const getPersistentElementsProp = useEvent(getPersistentElements);
    useSafeLayoutEffect(() => {
      if (!id3) return;
      if (!canTakeTreeSnapshot) return;
      const { disclosureElement } = store.getState();
      const allElements = [
        ref.current,
        ...getPersistentElementsProp() || [],
        ...nestedDialogs.map((dialog) => dialog.getState().contentElement)
      ];
      const restoreInsideMarks = markTreeInside(id3, allElements);
      if (modal) return chain(restoreInsideMarks, markAndDisableTreeOutside(id3, allElements));
      return chain(restoreInsideMarks, markTreeOutside(id3, [disclosureElement, ...allElements]));
    }, [
      id3,
      store,
      canTakeTreeSnapshot,
      getPersistentElementsProp,
      nestedDialogs,
      modal,
      unstable_treeSnapshotKey
    ]);
    const mayAutoFocusOnShow = !!autoFocusOnShow;
    const autoFocusOnShowProp = useBooleanEvent(autoFocusOnShow);
    const [autoFocusEnabled, setAutoFocusEnabled] = (0, import_react26.useState)(false);
    (0, import_react26.useEffect)(() => {
      if (!open) return;
      if (!mayAutoFocusOnShow) return;
      if (!domReady) return;
      if (!contentElement?.isConnected) return;
      const element = getElementFromProp(initialFocus, true) || contentElement.querySelector("[data-autofocus=true],[autofocus]") || getFirstTabbableIn(contentElement, true, portal && preserveTabOrder) || contentElement;
      const isElementFocusable = isFocusable(element);
      if (!autoFocusOnShowProp(isElementFocusable ? element : null)) return;
      setAutoFocusEnabled(true);
      queueMicrotask(() => {
        if (!store.getState().open) return;
        element.focus();
        if (!isSafariBrowser2) return;
        if (!isElementFocusable) return;
        element.scrollIntoView({
          block: "nearest",
          inline: "nearest"
        });
      });
    }, [
      open,
      mayAutoFocusOnShow,
      domReady,
      contentElement,
      initialFocus,
      portal,
      preserveTabOrder,
      store,
      autoFocusOnShowProp
    ]);
    const mayAutoFocusOnHide = !!autoFocusOnHide;
    const autoFocusOnHideProp = useBooleanEvent(autoFocusOnHide);
    const [hasOpened, setHasOpened] = (0, import_react26.useState)(false);
    useSafeLayoutEffect(() => {
      if (!open) return;
      setHasOpened(true);
      return () => setHasOpened(false);
    }, [open]);
    const focusOnHide = (0, import_react26.useCallback)((dialog, retry = true) => {
      if (interactedOutsideRef.current) return;
      const { disclosureElement } = store.getState();
      if (isAlreadyFocusingAnotherElement(dialog)) return;
      let element = getElementFromProp(finalFocus) || disclosureElement;
      if (element?.id) {
        const doc = getDocument(element);
        const selector2 = `[aria-activedescendant="${element.id}"]`;
        const composite = doc.querySelector(selector2);
        if (composite) element = composite;
      }
      if (element && !isFocusable(element)) {
        const maybeParentDialog = element.closest("[data-dialog]");
        if (maybeParentDialog?.id) {
          const doc = getDocument(maybeParentDialog);
          const selector2 = `[aria-controls~="${maybeParentDialog.id}"]`;
          const control = doc.querySelector(selector2);
          if (control) element = control;
        }
      }
      const isElementFocusable = element && isFocusable(element);
      if (!isElementFocusable && retry) {
        requestAnimationFrame(() => focusOnHide(dialog, false));
        return;
      }
      if (!autoFocusOnHideProp(isElementFocusable ? element : null)) return;
      if (!isElementFocusable) return;
      element?.focus();
    }, [
      store,
      finalFocus,
      autoFocusOnHideProp
    ]);
    const focusedOnHideRef = (0, import_react26.useRef)(false);
    useSafeLayoutEffect(() => {
      if (open) return;
      if (!hasOpened) return;
      if (!mayAutoFocusOnHide) return;
      const dialog = ref.current;
      focusedOnHideRef.current = true;
      focusOnHide(dialog);
    }, [
      open,
      hasOpened,
      domReady,
      mayAutoFocusOnHide,
      focusOnHide
    ]);
    (0, import_react26.useEffect)(() => {
      if (!hasOpened) return;
      if (!mayAutoFocusOnHide) return;
      const dialog = ref.current;
      return () => {
        if (focusedOnHideRef.current) {
          focusedOnHideRef.current = false;
          return;
        }
        focusOnHide(dialog);
      };
    }, [
      hasOpened,
      mayAutoFocusOnHide,
      focusOnHide
    ]);
    const hideOnEscapeProp = useBooleanEvent(hideOnEscape);
    (0, import_react26.useEffect)(() => {
      if (!domReady) return;
      if (!mounted) return;
      const onKeyDown = (event) => {
        if (event.key !== "Escape") return;
        if (event.defaultPrevented) return;
        const dialog = ref.current;
        if (!dialog) return;
        if (isElementMarked(dialog)) return;
        const target = event.target;
        if (!isNode(target)) return;
        const { disclosureElement } = store.getState();
        const isValidTarget = () => {
          if (isElement(target) && target.tagName === "BODY") return true;
          if (contains(dialog, target)) return true;
          if (!disclosureElement) return true;
          if (contains(disclosureElement, target)) return true;
          if (isElement(target) && isElementMarked(target, dialog.id)) return true;
          return false;
        };
        if (!isValidTarget()) return;
        if (!hideOnEscapeProp(event)) return;
        store.hide();
      };
      return addGlobalEventListener("keydown", onKeyDown, true, contentElement ? getWindow(contentElement) : void 0);
    }, [
      store,
      domReady,
      mounted,
      contentElement,
      hideOnEscapeProp
    ]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(HeadingLevel, {
      level: modal ? 1 : void 0,
      children: element
    }), [modal]);
    const hiddenProp = props.hidden;
    const alwaysVisible = props.alwaysVisible;
    props = useWrapElement(props, (element) => {
      if (!backdrop) return element;
      return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogBackdrop, {
        store,
        backdrop,
        backdropRef,
        hidden: hiddenProp,
        alwaysVisible
      }), element] });
    }, [
      store,
      backdrop,
      hiddenProp,
      alwaysVisible
    ]);
    const [headingId, setHeadingId] = (0, import_react26.useState)();
    const [descriptionId, setDescriptionId] = (0, import_react26.useState)();
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogScopedContextProvider, {
      value: store,
      children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogHeadingContext.Provider, {
        value: setHeadingId,
        children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogDescriptionContext.Provider, {
          value: setDescriptionId,
          children: element
        })
      })
    }), [store]);
    props = {
      "data-dialog": "",
      role: "dialog",
      tabIndex: focusable ? -1 : void 0,
      "aria-labelledby": props["aria-label"] != null ? void 0 : headingId,
      "aria-describedby": descriptionId,
      ...props,
      id: id3,
      ref: useMergeRefs(ref, props.ref)
    };
    props = useFocusableContainer({
      ...props,
      autoFocusOnShow: autoFocusEnabled
    });
    props = useDisclosureContent({
      store,
      ...props,
      unstable_otherElementRef: backdropRef
    });
    props = useFocusable({
      ...props,
      focusable
    });
    props = usePortal({
      portal,
      ...props,
      portalRef,
      preserveTabOrder
    });
    return props;
  });
  function createDialogComponent(Component7, useProviderContext = useDialogProviderContext) {
    return forwardRef2(function DialogComponent(props) {
      const context = useProviderContext();
      if (!useStoreState(props.store || context, (state) => !props.unmountOnHide || state?.mounted || !!props.open)) return null;
      return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Component7, { ...props });
    });
  }
  var DialogWithStore = createDialogComponent(forwardRef2(function DialogImpl(props) {
    return createElement(TagName19, useDialog(props));
  }), useDialogProviderContext);
  var DialogWithInternalStore = forwardRef2(function DialogWithInternalStore2(props) {
    const store = useDialogStore({ open: props.open });
    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogWithStore, {
      ...props,
      store
    });
  });
  var Dialog = forwardRef2(function Dialog2(props) {
    const context = useDialogProviderContext();
    if (props.store || context || !props.unmountOnHide) return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogWithStore, { ...props });
    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogWithInternalStore, { ...props });
  });

  // node_modules/@ariakit/react-components/dist/__chunks/B3k5_R1L.js
  function getBasePlacement(placement) {
    return placement.split("-")[0];
  }

  // node_modules/@ariakit/react-components/dist/popover/popover.js
  var import_react27 = __toESM(require_react(), 1);
  var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);

  // node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
  var min = Math.min;
  var max = Math.max;
  var round = Math.round;
  var floor = Math.floor;
  var createCoords = (v3) => ({
    x: v3,
    y: v3
  });
  var oppositeSideMap = {
    left: "right",
    right: "left",
    bottom: "top",
    top: "bottom"
  };
  function clamp(start, value, end) {
    return max(start, min(value, end));
  }
  function evaluate(value, param) {
    return typeof value === "function" ? value(param) : value;
  }
  function getSide(placement) {
    return placement.split("-")[0];
  }
  function getAlignment(placement) {
    return placement.split("-")[1];
  }
  function getOppositeAxis(axis) {
    return axis === "x" ? "y" : "x";
  }
  function getAxisLength(axis) {
    return axis === "y" ? "height" : "width";
  }
  function getSideAxis(placement) {
    const firstChar = placement[0];
    return firstChar === "t" || firstChar === "b" ? "y" : "x";
  }
  function getAlignmentAxis(placement) {
    return getOppositeAxis(getSideAxis(placement));
  }
  function getAlignmentSides(placement, rects, rtl2) {
    if (rtl2 === void 0) {
      rtl2 = false;
    }
    const alignment = getAlignment(placement);
    const alignmentAxis = getAlignmentAxis(placement);
    const length2 = getAxisLength(alignmentAxis);
    let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl2 ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
    if (rects.reference[length2] > rects.floating[length2]) {
      mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
    }
    return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
  }
  function getExpandedPlacements(placement) {
    const oppositePlacement = getOppositePlacement(placement);
    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
  }
  function getOppositeAlignmentPlacement(placement) {
    return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
  }
  var lrPlacement = ["left", "right"];
  var rlPlacement = ["right", "left"];
  var tbPlacement = ["top", "bottom"];
  var btPlacement = ["bottom", "top"];
  function getSideList(side, isStart, rtl2) {
    switch (side) {
      case "top":
      case "bottom":
        if (rtl2) return isStart ? rlPlacement : lrPlacement;
        return isStart ? lrPlacement : rlPlacement;
      case "left":
      case "right":
        return isStart ? tbPlacement : btPlacement;
      default:
        return [];
    }
  }
  function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl2) {
    const alignment = getAlignment(placement);
    let list = getSideList(getSide(placement), direction === "start", rtl2);
    if (alignment) {
      list = list.map((side) => side + "-" + alignment);
      if (flipAlignment) {
        list = list.concat(list.map(getOppositeAlignmentPlacement));
      }
    }
    return list;
  }
  function getOppositePlacement(placement) {
    const side = getSide(placement);
    return oppositeSideMap[side] + placement.slice(side.length);
  }
  function expandPaddingObject(padding2) {
    return {
      top: 0,
      right: 0,
      bottom: 0,
      left: 0,
      ...padding2
    };
  }
  function getPaddingObject(padding2) {
    return typeof padding2 !== "number" ? expandPaddingObject(padding2) : {
      top: padding2,
      right: padding2,
      bottom: padding2,
      left: padding2
    };
  }
  function rectToClientRect(rect) {
    const {
      x: x2,
      y: y3,
      width,
      height
    } = rect;
    return {
      width,
      height,
      top: y3,
      left: x2,
      right: x2 + width,
      bottom: y3 + height,
      x: x2,
      y: y3
    };
  }

  // node_modules/@floating-ui/core/dist/floating-ui.core.mjs
  function computeCoordsFromPlacement(_ref9, placement, rtl2) {
    let {
      reference,
      floating
    } = _ref9;
    const sideAxis = getSideAxis(placement);
    const alignmentAxis = getAlignmentAxis(placement);
    const alignLength = getAxisLength(alignmentAxis);
    const side = getSide(placement);
    const isVertical = sideAxis === "y";
    const commonX = reference.x + reference.width / 2 - floating.width / 2;
    const commonY = reference.y + reference.height / 2 - floating.height / 2;
    const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
    let coords;
    switch (side) {
      case "top":
        coords = {
          x: commonX,
          y: reference.y - floating.height
        };
        break;
      case "bottom":
        coords = {
          x: commonX,
          y: reference.y + reference.height
        };
        break;
      case "right":
        coords = {
          x: reference.x + reference.width,
          y: commonY
        };
        break;
      case "left":
        coords = {
          x: reference.x - floating.width,
          y: commonY
        };
        break;
      default:
        coords = {
          x: reference.x,
          y: reference.y
        };
    }
    switch (getAlignment(placement)) {
      case "start":
        coords[alignmentAxis] -= commonAlign * (rtl2 && isVertical ? -1 : 1);
        break;
      case "end":
        coords[alignmentAxis] += commonAlign * (rtl2 && isVertical ? -1 : 1);
        break;
    }
    return coords;
  }
  async function detectOverflow(state, options2) {
    var _await$platform$isEle;
    if (options2 === void 0) {
      options2 = {};
    }
    const {
      x: x2,
      y: y3,
      platform: platform2,
      rects,
      elements: elements2,
      strategy
    } = state;
    const {
      boundary = "clippingAncestors",
      rootBoundary = "viewport",
      elementContext = "floating",
      altBoundary = false,
      padding: padding2 = 0
    } = evaluate(options2, state);
    const paddingObject = getPaddingObject(padding2);
    const altContext = elementContext === "floating" ? "reference" : "floating";
    const element = elements2[altBoundary ? altContext : elementContext];
    const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
      element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements2.floating)),
      boundary,
      rootBoundary,
      strategy
    }));
    const rect = elementContext === "floating" ? {
      x: x2,
      y: y3,
      width: rects.floating.width,
      height: rects.floating.height
    } : rects.reference;
    const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements2.floating));
    const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
      x: 1,
      y: 1
    } : {
      x: 1,
      y: 1
    };
    const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
      elements: elements2,
      rect,
      offsetParent,
      strategy
    }) : rect);
    return {
      top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
      bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
      left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
      right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
    };
  }
  var MAX_RESET_COUNT = 50;
  var computePosition = async (reference, floating, config) => {
    const {
      placement = "bottom",
      strategy = "absolute",
      middleware: middleware2 = [],
      platform: platform2
    } = config;
    const platformWithDetectOverflow = platform2.detectOverflow ? platform2 : {
      ...platform2,
      detectOverflow
    };
    const rtl2 = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
    let rects = await platform2.getElementRects({
      reference,
      floating,
      strategy
    });
    let {
      x: x2,
      y: y3
    } = computeCoordsFromPlacement(rects, placement, rtl2);
    let statefulPlacement = placement;
    let resetCount = 0;
    const middlewareData = {};
    for (let i3 = 0; i3 < middleware2.length; i3++) {
      const currentMiddleware = middleware2[i3];
      if (!currentMiddleware) {
        continue;
      }
      const {
        name,
        fn
      } = currentMiddleware;
      const {
        x: nextX,
        y: nextY,
        data,
        reset
      } = await fn({
        x: x2,
        y: y3,
        initialPlacement: placement,
        placement: statefulPlacement,
        strategy,
        middlewareData,
        rects,
        platform: platformWithDetectOverflow,
        elements: {
          reference,
          floating
        }
      });
      x2 = nextX != null ? nextX : x2;
      y3 = nextY != null ? nextY : y3;
      middlewareData[name] = {
        ...middlewareData[name],
        ...data
      };
      if (reset && resetCount < MAX_RESET_COUNT) {
        resetCount++;
        if (typeof reset === "object") {
          if (reset.placement) {
            statefulPlacement = reset.placement;
          }
          if (reset.rects) {
            rects = reset.rects === true ? await platform2.getElementRects({
              reference,
              floating,
              strategy
            }) : reset.rects;
          }
          ({
            x: x2,
            y: y3
          } = computeCoordsFromPlacement(rects, statefulPlacement, rtl2));
        }
        i3 = -1;
      }
    }
    return {
      x: x2,
      y: y3,
      placement: statefulPlacement,
      strategy,
      middlewareData
    };
  };
  var arrow = (options2) => ({
    name: "arrow",
    options: options2,
    async fn(state) {
      const {
        x: x2,
        y: y3,
        placement,
        rects,
        platform: platform2,
        elements: elements2,
        middlewareData
      } = state;
      const {
        element,
        padding: padding2 = 0
      } = evaluate(options2, state) || {};
      if (element == null) {
        return {};
      }
      const paddingObject = getPaddingObject(padding2);
      const coords = {
        x: x2,
        y: y3
      };
      const axis = getAlignmentAxis(placement);
      const length2 = getAxisLength(axis);
      const arrowDimensions = await platform2.getDimensions(element);
      const isYAxis = axis === "y";
      const minProp = isYAxis ? "top" : "left";
      const maxProp = isYAxis ? "bottom" : "right";
      const clientProp = isYAxis ? "clientHeight" : "clientWidth";
      const endDiff = rects.reference[length2] + rects.reference[axis] - coords[axis] - rects.floating[length2];
      const startDiff = coords[axis] - rects.reference[axis];
      const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
      let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
      if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
        clientSize = elements2.floating[clientProp] || rects.floating[length2];
      }
      const centerToReference = endDiff / 2 - startDiff / 2;
      const largestPossiblePadding = clientSize / 2 - arrowDimensions[length2] / 2 - 1;
      const minPadding = min(paddingObject[minProp], largestPossiblePadding);
      const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
      const min$1 = minPadding;
      const max3 = clientSize - arrowDimensions[length2] - maxPadding;
      const center = clientSize / 2 - arrowDimensions[length2] / 2 + centerToReference;
      const offset4 = clamp(min$1, center, max3);
      const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length2] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length2] / 2 < 0;
      const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max3 : 0;
      return {
        [axis]: coords[axis] + alignmentOffset,
        data: {
          [axis]: offset4,
          centerOffset: center - offset4 - alignmentOffset,
          ...shouldAddOffset && {
            alignmentOffset
          }
        },
        reset: shouldAddOffset
      };
    }
  });
  var flip = function(options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    return {
      name: "flip",
      options: options2,
      async fn(state) {
        var _middlewareData$arrow, _middlewareData$flip;
        const {
          placement,
          middlewareData,
          rects,
          initialPlacement,
          platform: platform2,
          elements: elements2
        } = state;
        const {
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = true,
          fallbackPlacements: specifiedFallbackPlacements,
          fallbackStrategy = "bestFit",
          fallbackAxisSideDirection = "none",
          flipAlignment = true,
          ...detectOverflowOptions
        } = evaluate(options2, state);
        if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
          return {};
        }
        const side = getSide(placement);
        const initialSideAxis = getSideAxis(initialPlacement);
        const isBasePlacement = getSide(initialPlacement) === initialPlacement;
        const rtl2 = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements2.floating));
        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
        const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
        if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
          fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl2));
        }
        const placements2 = [initialPlacement, ...fallbackPlacements];
        const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
        const overflows = [];
        let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
        if (checkMainAxis) {
          overflows.push(overflow[side]);
        }
        if (checkCrossAxis) {
          const sides3 = getAlignmentSides(placement, rects, rtl2);
          overflows.push(overflow[sides3[0]], overflow[sides3[1]]);
        }
        overflowsData = [...overflowsData, {
          placement,
          overflows
        }];
        if (!overflows.every((side2) => side2 <= 0)) {
          var _middlewareData$flip2, _overflowsData$filter;
          const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
          const nextPlacement = placements2[nextIndex];
          if (nextPlacement) {
            const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
            if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
            // overflows the main axis.
            overflowsData.every((d3) => getSideAxis(d3.placement) === initialSideAxis ? d3.overflows[0] > 0 : true)) {
              return {
                data: {
                  index: nextIndex,
                  overflows: overflowsData
                },
                reset: {
                  placement: nextPlacement
                }
              };
            }
          }
          let resetPlacement = (_overflowsData$filter = overflowsData.filter((d3) => d3.overflows[0] <= 0).sort((a3, b3) => a3.overflows[1] - b3.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
          if (!resetPlacement) {
            switch (fallbackStrategy) {
              case "bestFit": {
                var _overflowsData$filter2;
                const placement2 = (_overflowsData$filter2 = overflowsData.filter((d3) => {
                  if (hasFallbackAxisSideDirection) {
                    const currentSideAxis = getSideAxis(d3.placement);
                    return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
                    // reading directions favoring greater width.
                    currentSideAxis === "y";
                  }
                  return true;
                }).map((d3) => [d3.placement, d3.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a3, b3) => a3[1] - b3[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
                if (placement2) {
                  resetPlacement = placement2;
                }
                break;
              }
              case "initialPlacement":
                resetPlacement = initialPlacement;
                break;
            }
          }
          if (placement !== resetPlacement) {
            return {
              reset: {
                placement: resetPlacement
              }
            };
          }
        }
        return {};
      }
    };
  };
  var originSides = /* @__PURE__ */ new Set(["left", "top"]);
  async function convertValueToCoords(state, options2) {
    const {
      placement,
      platform: platform2,
      elements: elements2
    } = state;
    const rtl2 = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements2.floating));
    const side = getSide(placement);
    const alignment = getAlignment(placement);
    const isVertical = getSideAxis(placement) === "y";
    const mainAxisMulti = originSides.has(side) ? -1 : 1;
    const crossAxisMulti = rtl2 && isVertical ? -1 : 1;
    const rawValue = evaluate(options2, state);
    let {
      mainAxis,
      crossAxis,
      alignmentAxis
    } = typeof rawValue === "number" ? {
      mainAxis: rawValue,
      crossAxis: 0,
      alignmentAxis: null
    } : {
      mainAxis: rawValue.mainAxis || 0,
      crossAxis: rawValue.crossAxis || 0,
      alignmentAxis: rawValue.alignmentAxis
    };
    if (alignment && typeof alignmentAxis === "number") {
      crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
    }
    return isVertical ? {
      x: crossAxis * crossAxisMulti,
      y: mainAxis * mainAxisMulti
    } : {
      x: mainAxis * mainAxisMulti,
      y: crossAxis * crossAxisMulti
    };
  }
  var offset = function(options2) {
    if (options2 === void 0) {
      options2 = 0;
    }
    return {
      name: "offset",
      options: options2,
      async fn(state) {
        var _middlewareData$offse, _middlewareData$arrow;
        const {
          x: x2,
          y: y3,
          placement,
          middlewareData
        } = state;
        const diffCoords = await convertValueToCoords(state, options2);
        if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
          return {};
        }
        return {
          x: x2 + diffCoords.x,
          y: y3 + diffCoords.y,
          data: {
            ...diffCoords,
            placement
          }
        };
      }
    };
  };
  var shift = function(options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    return {
      name: "shift",
      options: options2,
      async fn(state) {
        const {
          x: x2,
          y: y3,
          placement,
          platform: platform2
        } = state;
        const {
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = false,
          limiter = {
            fn: (_ref9) => {
              let {
                x: x3,
                y: y4
              } = _ref9;
              return {
                x: x3,
                y: y4
              };
            }
          },
          ...detectOverflowOptions
        } = evaluate(options2, state);
        const coords = {
          x: x2,
          y: y3
        };
        const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
        const crossAxis = getSideAxis(getSide(placement));
        const mainAxis = getOppositeAxis(crossAxis);
        let mainAxisCoord = coords[mainAxis];
        let crossAxisCoord = coords[crossAxis];
        if (checkMainAxis) {
          const minSide = mainAxis === "y" ? "top" : "left";
          const maxSide = mainAxis === "y" ? "bottom" : "right";
          const min3 = mainAxisCoord + overflow[minSide];
          const max3 = mainAxisCoord - overflow[maxSide];
          mainAxisCoord = clamp(min3, mainAxisCoord, max3);
        }
        if (checkCrossAxis) {
          const minSide = crossAxis === "y" ? "top" : "left";
          const maxSide = crossAxis === "y" ? "bottom" : "right";
          const min3 = crossAxisCoord + overflow[minSide];
          const max3 = crossAxisCoord - overflow[maxSide];
          crossAxisCoord = clamp(min3, crossAxisCoord, max3);
        }
        const limitedCoords = limiter.fn({
          ...state,
          [mainAxis]: mainAxisCoord,
          [crossAxis]: crossAxisCoord
        });
        return {
          ...limitedCoords,
          data: {
            x: limitedCoords.x - x2,
            y: limitedCoords.y - y3,
            enabled: {
              [mainAxis]: checkMainAxis,
              [crossAxis]: checkCrossAxis
            }
          }
        };
      }
    };
  };
  var limitShift = function(options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    return {
      options: options2,
      fn(state) {
        const {
          x: x2,
          y: y3,
          placement,
          rects,
          middlewareData
        } = state;
        const {
          offset: offset4 = 0,
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = true
        } = evaluate(options2, state);
        const coords = {
          x: x2,
          y: y3
        };
        const crossAxis = getSideAxis(placement);
        const mainAxis = getOppositeAxis(crossAxis);
        let mainAxisCoord = coords[mainAxis];
        let crossAxisCoord = coords[crossAxis];
        const rawOffset = evaluate(offset4, state);
        const computedOffset = typeof rawOffset === "number" ? {
          mainAxis: rawOffset,
          crossAxis: 0
        } : {
          mainAxis: 0,
          crossAxis: 0,
          ...rawOffset
        };
        if (checkMainAxis) {
          const len = mainAxis === "y" ? "height" : "width";
          const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
          const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
          if (mainAxisCoord < limitMin) {
            mainAxisCoord = limitMin;
          } else if (mainAxisCoord > limitMax) {
            mainAxisCoord = limitMax;
          }
        }
        if (checkCrossAxis) {
          var _middlewareData$offse, _middlewareData$offse2;
          const len = mainAxis === "y" ? "width" : "height";
          const isOriginSide = originSides.has(getSide(placement));
          const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
          const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
          if (crossAxisCoord < limitMin) {
            crossAxisCoord = limitMin;
          } else if (crossAxisCoord > limitMax) {
            crossAxisCoord = limitMax;
          }
        }
        return {
          [mainAxis]: mainAxisCoord,
          [crossAxis]: crossAxisCoord
        };
      }
    };
  };
  var size = function(options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    return {
      name: "size",
      options: options2,
      async fn(state) {
        var _state$middlewareData, _state$middlewareData2;
        const {
          placement,
          rects,
          platform: platform2,
          elements: elements2
        } = state;
        const {
          apply = () => {
          },
          ...detectOverflowOptions
        } = evaluate(options2, state);
        const overflow = await platform2.detectOverflow(state, detectOverflowOptions);
        const side = getSide(placement);
        const alignment = getAlignment(placement);
        const isYAxis = getSideAxis(placement) === "y";
        const {
          width,
          height
        } = rects.floating;
        let heightSide;
        let widthSide;
        if (side === "top" || side === "bottom") {
          heightSide = side;
          widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements2.floating)) ? "start" : "end") ? "left" : "right";
        } else {
          widthSide = side;
          heightSide = alignment === "end" ? "top" : "bottom";
        }
        const maximumClippingHeight = height - overflow.top - overflow.bottom;
        const maximumClippingWidth = width - overflow.left - overflow.right;
        const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
        const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
        const noShift = !state.middlewareData.shift;
        let availableHeight = overflowAvailableHeight;
        let availableWidth = overflowAvailableWidth;
        if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
          availableWidth = maximumClippingWidth;
        }
        if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
          availableHeight = maximumClippingHeight;
        }
        if (noShift && !alignment) {
          const xMin = max(overflow.left, 0);
          const xMax = max(overflow.right, 0);
          const yMin = max(overflow.top, 0);
          const yMax = max(overflow.bottom, 0);
          if (isYAxis) {
            availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
          } else {
            availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
          }
        }
        await apply({
          ...state,
          availableWidth,
          availableHeight
        });
        const nextDimensions = await platform2.getDimensions(elements2.floating);
        if (width !== nextDimensions.width || height !== nextDimensions.height) {
          return {
            reset: {
              rects: true
            }
          };
        }
        return {};
      }
    };
  };

  // node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
  function hasWindow() {
    return typeof window !== "undefined";
  }
  function getNodeName(node2) {
    if (isNode2(node2)) {
      return (node2.nodeName || "").toLowerCase();
    }
    return "#document";
  }
  function getWindow2(node2) {
    var _node$ownerDocument;
    return (node2 == null || (_node$ownerDocument = node2.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
  }
  function getDocumentElement(node2) {
    var _ref9;
    return (_ref9 = (isNode2(node2) ? node2.ownerDocument : node2.document) || window.document) == null ? void 0 : _ref9.documentElement;
  }
  function isNode2(value) {
    if (!hasWindow()) {
      return false;
    }
    return value instanceof Node || value instanceof getWindow2(value).Node;
  }
  function isElement2(value) {
    if (!hasWindow()) {
      return false;
    }
    return value instanceof Element || value instanceof getWindow2(value).Element;
  }
  function isHTMLElement(value) {
    if (!hasWindow()) {
      return false;
    }
    return value instanceof HTMLElement || value instanceof getWindow2(value).HTMLElement;
  }
  function isShadowRoot(value) {
    if (!hasWindow() || typeof ShadowRoot === "undefined") {
      return false;
    }
    return value instanceof ShadowRoot || value instanceof getWindow2(value).ShadowRoot;
  }
  function isOverflowElement(element) {
    const {
      overflow,
      overflowX,
      overflowY,
      display
    } = getComputedStyle2(element);
    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
  }
  function isTableElement(element) {
    return /^(table|td|th)$/.test(getNodeName(element));
  }
  function isTopLayer(element) {
    try {
      if (element.matches(":popover-open")) {
        return true;
      }
    } catch (_e) {
    }
    try {
      return element.matches(":modal");
    } catch (_e) {
      return false;
    }
  }
  var willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
  var containRe = /paint|layout|strict|content/;
  var isNotNone = (value) => !!value && value !== "none";
  var isWebKitValue;
  function isContainingBlock(elementOrCss) {
    const css3 = isElement2(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
    return isNotNone(css3.transform) || isNotNone(css3.translate) || isNotNone(css3.scale) || isNotNone(css3.rotate) || isNotNone(css3.perspective) || !isWebKit() && (isNotNone(css3.backdropFilter) || isNotNone(css3.filter)) || willChangeRe.test(css3.willChange || "") || containRe.test(css3.contain || "");
  }
  function getContainingBlock(element) {
    let currentNode = getParentNode(element);
    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
      if (isContainingBlock(currentNode)) {
        return currentNode;
      } else if (isTopLayer(currentNode)) {
        return null;
      }
      currentNode = getParentNode(currentNode);
    }
    return null;
  }
  function isWebKit() {
    if (isWebKitValue == null) {
      isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
    }
    return isWebKitValue;
  }
  function isLastTraversableNode(node2) {
    return /^(html|body|#document)$/.test(getNodeName(node2));
  }
  function getComputedStyle2(element) {
    return getWindow2(element).getComputedStyle(element);
  }
  function getNodeScroll(element) {
    if (isElement2(element)) {
      return {
        scrollLeft: element.scrollLeft,
        scrollTop: element.scrollTop
      };
    }
    return {
      scrollLeft: element.scrollX,
      scrollTop: element.scrollY
    };
  }
  function getParentNode(node2) {
    if (getNodeName(node2) === "html") {
      return node2;
    }
    const result = (
      // Step into the shadow DOM of the parent of a slotted node.
      node2.assignedSlot || // DOM Element detected.
      node2.parentNode || // ShadowRoot detected.
      isShadowRoot(node2) && node2.host || // Fallback.
      getDocumentElement(node2)
    );
    return isShadowRoot(result) ? result.host : result;
  }
  function getNearestOverflowAncestor(node2) {
    const parentNode = getParentNode(node2);
    if (isLastTraversableNode(parentNode)) {
      return node2.ownerDocument ? node2.ownerDocument.body : node2.body;
    }
    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
      return parentNode;
    }
    return getNearestOverflowAncestor(parentNode);
  }
  function getOverflowAncestors(node2, list, traverseIframes) {
    var _node$ownerDocument2;
    if (list === void 0) {
      list = [];
    }
    if (traverseIframes === void 0) {
      traverseIframes = true;
    }
    const scrollableAncestor = getNearestOverflowAncestor(node2);
    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node2.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
    const win = getWindow2(scrollableAncestor);
    if (isBody) {
      const frameElement = getFrameElement(win);
      return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
    } else {
      return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
    }
  }
  function getFrameElement(win) {
    return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
  }

  // node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
  function getCssDimensions(element) {
    const css3 = getComputedStyle2(element);
    let width = parseFloat(css3.width) || 0;
    let height = parseFloat(css3.height) || 0;
    const hasOffset = isHTMLElement(element);
    const offsetWidth = hasOffset ? element.offsetWidth : width;
    const offsetHeight = hasOffset ? element.offsetHeight : height;
    const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
    if (shouldFallback) {
      width = offsetWidth;
      height = offsetHeight;
    }
    return {
      width,
      height,
      $: shouldFallback
    };
  }
  function unwrapElement(element) {
    return !isElement2(element) ? element.contextElement : element;
  }
  function getScale(element) {
    const domElement = unwrapElement(element);
    if (!isHTMLElement(domElement)) {
      return createCoords(1);
    }
    const rect = domElement.getBoundingClientRect();
    const {
      width,
      height,
      $: $3
    } = getCssDimensions(domElement);
    let x2 = ($3 ? round(rect.width) : rect.width) / width;
    let y3 = ($3 ? round(rect.height) : rect.height) / height;
    if (!x2 || !Number.isFinite(x2)) {
      x2 = 1;
    }
    if (!y3 || !Number.isFinite(y3)) {
      y3 = 1;
    }
    return {
      x: x2,
      y: y3
    };
  }
  var noOffsets = /* @__PURE__ */ createCoords(0);
  function getVisualOffsets(element) {
    const win = getWindow2(element);
    if (!isWebKit() || !win.visualViewport) {
      return noOffsets;
    }
    return {
      x: win.visualViewport.offsetLeft,
      y: win.visualViewport.offsetTop
    };
  }
  function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
    if (isFixed === void 0) {
      isFixed = false;
    }
    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow2(element)) {
      return false;
    }
    return isFixed;
  }
  function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
    if (includeScale === void 0) {
      includeScale = false;
    }
    if (isFixedStrategy === void 0) {
      isFixedStrategy = false;
    }
    const clientRect = element.getBoundingClientRect();
    const domElement = unwrapElement(element);
    let scale2 = createCoords(1);
    if (includeScale) {
      if (offsetParent) {
        if (isElement2(offsetParent)) {
          scale2 = getScale(offsetParent);
        }
      } else {
        scale2 = getScale(element);
      }
    }
    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
    let x2 = (clientRect.left + visualOffsets.x) / scale2.x;
    let y3 = (clientRect.top + visualOffsets.y) / scale2.y;
    let width = clientRect.width / scale2.x;
    let height = clientRect.height / scale2.y;
    if (domElement) {
      const win = getWindow2(domElement);
      const offsetWin = offsetParent && isElement2(offsetParent) ? getWindow2(offsetParent) : offsetParent;
      let currentWin = win;
      let currentIFrame = getFrameElement(currentWin);
      while (currentIFrame && offsetParent && offsetWin !== currentWin) {
        const iframeScale = getScale(currentIFrame);
        const iframeRect = currentIFrame.getBoundingClientRect();
        const css3 = getComputedStyle2(currentIFrame);
        const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css3.paddingLeft)) * iframeScale.x;
        const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css3.paddingTop)) * iframeScale.y;
        x2 *= iframeScale.x;
        y3 *= iframeScale.y;
        width *= iframeScale.x;
        height *= iframeScale.y;
        x2 += left;
        y3 += top;
        currentWin = getWindow2(currentIFrame);
        currentIFrame = getFrameElement(currentWin);
      }
    }
    return rectToClientRect({
      width,
      height,
      x: x2,
      y: y3
    });
  }
  function getWindowScrollBarX(element, rect) {
    const leftScroll = getNodeScroll(element).scrollLeft;
    if (!rect) {
      return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
    }
    return rect.left + leftScroll;
  }
  function getHTMLOffset(documentElement, scroll) {
    const htmlRect = documentElement.getBoundingClientRect();
    const x2 = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
    const y3 = htmlRect.top + scroll.scrollTop;
    return {
      x: x2,
      y: y3
    };
  }
  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref9) {
    let {
      elements: elements2,
      rect,
      offsetParent,
      strategy
    } = _ref9;
    const isFixed = strategy === "fixed";
    const documentElement = getDocumentElement(offsetParent);
    const topLayer = elements2 ? isTopLayer(elements2.floating) : false;
    if (offsetParent === documentElement || topLayer && isFixed) {
      return rect;
    }
    let scroll = {
      scrollLeft: 0,
      scrollTop: 0
    };
    let scale2 = createCoords(1);
    const offsets = createCoords(0);
    const isOffsetParentAnElement = isHTMLElement(offsetParent);
    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
      if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
        scroll = getNodeScroll(offsetParent);
      }
      if (isOffsetParentAnElement) {
        const offsetRect = getBoundingClientRect(offsetParent);
        scale2 = getScale(offsetParent);
        offsets.x = offsetRect.x + offsetParent.clientLeft;
        offsets.y = offsetRect.y + offsetParent.clientTop;
      }
    }
    const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
    return {
      width: rect.width * scale2.x,
      height: rect.height * scale2.y,
      x: rect.x * scale2.x - scroll.scrollLeft * scale2.x + offsets.x + htmlOffset.x,
      y: rect.y * scale2.y - scroll.scrollTop * scale2.y + offsets.y + htmlOffset.y
    };
  }
  function getClientRects(element) {
    return Array.from(element.getClientRects());
  }
  function getDocumentRect(element) {
    const html = getDocumentElement(element);
    const scroll = getNodeScroll(element);
    const body = element.ownerDocument.body;
    const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
    const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
    let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
    const y3 = -scroll.scrollTop;
    if (getComputedStyle2(body).direction === "rtl") {
      x2 += max(html.clientWidth, body.clientWidth) - width;
    }
    return {
      width,
      height,
      x: x2,
      y: y3
    };
  }
  var SCROLLBAR_MAX = 25;
  function getViewportRect(element, strategy) {
    const win = getWindow2(element);
    const html = getDocumentElement(element);
    const visualViewport = win.visualViewport;
    let width = html.clientWidth;
    let height = html.clientHeight;
    let x2 = 0;
    let y3 = 0;
    if (visualViewport) {
      width = visualViewport.width;
      height = visualViewport.height;
      const visualViewportBased = isWebKit();
      if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
        x2 = visualViewport.offsetLeft;
        y3 = visualViewport.offsetTop;
      }
    }
    const windowScrollbarX = getWindowScrollBarX(html);
    if (windowScrollbarX <= 0) {
      const doc = html.ownerDocument;
      const body = doc.body;
      const bodyStyles = getComputedStyle(body);
      const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
      const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
      if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
        width -= clippingStableScrollbarWidth;
      }
    } else if (windowScrollbarX <= SCROLLBAR_MAX) {
      width += windowScrollbarX;
    }
    return {
      width,
      height,
      x: x2,
      y: y3
    };
  }
  function getInnerBoundingClientRect(element, strategy) {
    const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
    const top = clientRect.top + element.clientTop;
    const left = clientRect.left + element.clientLeft;
    const scale2 = isHTMLElement(element) ? getScale(element) : createCoords(1);
    const width = element.clientWidth * scale2.x;
    const height = element.clientHeight * scale2.y;
    const x2 = left * scale2.x;
    const y3 = top * scale2.y;
    return {
      width,
      height,
      x: x2,
      y: y3
    };
  }
  function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
    let rect;
    if (clippingAncestor === "viewport") {
      rect = getViewportRect(element, strategy);
    } else if (clippingAncestor === "document") {
      rect = getDocumentRect(getDocumentElement(element));
    } else if (isElement2(clippingAncestor)) {
      rect = getInnerBoundingClientRect(clippingAncestor, strategy);
    } else {
      const visualOffsets = getVisualOffsets(element);
      rect = {
        x: clippingAncestor.x - visualOffsets.x,
        y: clippingAncestor.y - visualOffsets.y,
        width: clippingAncestor.width,
        height: clippingAncestor.height
      };
    }
    return rectToClientRect(rect);
  }
  function hasFixedPositionAncestor(element, stopNode) {
    const parentNode = getParentNode(element);
    if (parentNode === stopNode || !isElement2(parentNode) || isLastTraversableNode(parentNode)) {
      return false;
    }
    return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
  }
  function getClippingElementAncestors(element, cache2) {
    const cachedResult = cache2.get(element);
    if (cachedResult) {
      return cachedResult;
    }
    let result = getOverflowAncestors(element, [], false).filter((el) => isElement2(el) && getNodeName(el) !== "body");
    let currentContainingBlockComputedStyle = null;
    const elementIsFixed = getComputedStyle2(element).position === "fixed";
    let currentNode = elementIsFixed ? getParentNode(element) : element;
    while (isElement2(currentNode) && !isLastTraversableNode(currentNode)) {
      const computedStyle = getComputedStyle2(currentNode);
      const currentNodeIsContaining = isContainingBlock(currentNode);
      if (!currentNodeIsContaining && computedStyle.position === "fixed") {
        currentContainingBlockComputedStyle = null;
      }
      const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
      if (shouldDropCurrentNode) {
        result = result.filter((ancestor) => ancestor !== currentNode);
      } else {
        currentContainingBlockComputedStyle = computedStyle;
      }
      currentNode = getParentNode(currentNode);
    }
    cache2.set(element, result);
    return result;
  }
  function getClippingRect(_ref9) {
    let {
      element,
      boundary,
      rootBoundary,
      strategy
    } = _ref9;
    const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
    const clippingAncestors = [...elementClippingAncestors, rootBoundary];
    const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
    let top = firstRect.top;
    let right = firstRect.right;
    let bottom = firstRect.bottom;
    let left = firstRect.left;
    for (let i3 = 1; i3 < clippingAncestors.length; i3++) {
      const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i3], strategy);
      top = max(rect.top, top);
      right = min(rect.right, right);
      bottom = min(rect.bottom, bottom);
      left = max(rect.left, left);
    }
    return {
      width: right - left,
      height: bottom - top,
      x: left,
      y: top
    };
  }
  function getDimensions(element) {
    const {
      width,
      height
    } = getCssDimensions(element);
    return {
      width,
      height
    };
  }
  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
    const isOffsetParentAnElement = isHTMLElement(offsetParent);
    const documentElement = getDocumentElement(offsetParent);
    const isFixed = strategy === "fixed";
    const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
    let scroll = {
      scrollLeft: 0,
      scrollTop: 0
    };
    const offsets = createCoords(0);
    function setLeftRTLScrollbarOffset() {
      offsets.x = getWindowScrollBarX(documentElement);
    }
    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
      if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
        scroll = getNodeScroll(offsetParent);
      }
      if (isOffsetParentAnElement) {
        const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
        offsets.x = offsetRect.x + offsetParent.clientLeft;
        offsets.y = offsetRect.y + offsetParent.clientTop;
      } else if (documentElement) {
        setLeftRTLScrollbarOffset();
      }
    }
    if (isFixed && !isOffsetParentAnElement && documentElement) {
      setLeftRTLScrollbarOffset();
    }
    const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
    const x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
    const y3 = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
    return {
      x: x2,
      y: y3,
      width: rect.width,
      height: rect.height
    };
  }
  function isStaticPositioned(element) {
    return getComputedStyle2(element).position === "static";
  }
  function getTrueOffsetParent(element, polyfill) {
    if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") {
      return null;
    }
    if (polyfill) {
      return polyfill(element);
    }
    let rawOffsetParent = element.offsetParent;
    if (getDocumentElement(element) === rawOffsetParent) {
      rawOffsetParent = rawOffsetParent.ownerDocument.body;
    }
    return rawOffsetParent;
  }
  function getOffsetParent(element, polyfill) {
    const win = getWindow2(element);
    if (isTopLayer(element)) {
      return win;
    }
    if (!isHTMLElement(element)) {
      let svgOffsetParent = getParentNode(element);
      while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
        if (isElement2(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
          return svgOffsetParent;
        }
        svgOffsetParent = getParentNode(svgOffsetParent);
      }
      return win;
    }
    let offsetParent = getTrueOffsetParent(element, polyfill);
    while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
      offsetParent = getTrueOffsetParent(offsetParent, polyfill);
    }
    if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
      return win;
    }
    return offsetParent || getContainingBlock(element) || win;
  }
  var getElementRects = async function(data) {
    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
    const getDimensionsFn = this.getDimensions;
    const floatingDimensions = await getDimensionsFn(data.floating);
    return {
      reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
      floating: {
        x: 0,
        y: 0,
        width: floatingDimensions.width,
        height: floatingDimensions.height
      }
    };
  };
  function isRTL(element) {
    return getComputedStyle2(element).direction === "rtl";
  }
  var platform = {
    convertOffsetParentRelativeRectToViewportRelativeRect,
    getDocumentElement,
    getClippingRect,
    getOffsetParent,
    getElementRects,
    getClientRects,
    getDimensions,
    getScale,
    isElement: isElement2,
    isRTL
  };
  function rectsAreEqual(a3, b3) {
    return a3.x === b3.x && a3.y === b3.y && a3.width === b3.width && a3.height === b3.height;
  }
  function observeMove(element, onMove) {
    let io = null;
    let timeoutId;
    const root = getDocumentElement(element);
    function cleanup() {
      var _io;
      clearTimeout(timeoutId);
      (_io = io) == null || _io.disconnect();
      io = null;
    }
    function refresh(skip, threshold) {
      if (skip === void 0) {
        skip = false;
      }
      if (threshold === void 0) {
        threshold = 1;
      }
      cleanup();
      const elementRectForRootMargin = element.getBoundingClientRect();
      const {
        left,
        top,
        width,
        height
      } = elementRectForRootMargin;
      if (!skip) {
        onMove();
      }
      if (!width || !height) {
        return;
      }
      const insetTop = floor(top);
      const insetRight = floor(root.clientWidth - (left + width));
      const insetBottom = floor(root.clientHeight - (top + height));
      const insetLeft = floor(left);
      const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
      const options2 = {
        rootMargin,
        threshold: max(0, min(1, threshold)) || 1
      };
      let isFirstUpdate = true;
      function handleObserve(entries) {
        const ratio = entries[0].intersectionRatio;
        if (ratio !== threshold) {
          if (!isFirstUpdate) {
            return refresh();
          }
          if (!ratio) {
            timeoutId = setTimeout(() => {
              refresh(false, 1e-7);
            }, 1e3);
          } else {
            refresh(false, ratio);
          }
        }
        if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
          refresh();
        }
        isFirstUpdate = false;
      }
      try {
        io = new IntersectionObserver(handleObserve, {
          ...options2,
          // Handle <iframe>s
          root: root.ownerDocument
        });
      } catch (_e) {
        io = new IntersectionObserver(handleObserve, options2);
      }
      io.observe(element);
    }
    refresh(true);
    return cleanup;
  }
  function autoUpdate(reference, floating, update, options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    const {
      ancestorScroll = true,
      ancestorResize = true,
      elementResize = typeof ResizeObserver === "function",
      layoutShift = typeof IntersectionObserver === "function",
      animationFrame = false
    } = options2;
    const referenceEl = unwrapElement(reference);
    const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
    ancestors.forEach((ancestor) => {
      ancestorScroll && ancestor.addEventListener("scroll", update, {
        passive: true
      });
      ancestorResize && ancestor.addEventListener("resize", update);
    });
    const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
    let reobserveFrame = -1;
    let resizeObserver = null;
    if (elementResize) {
      resizeObserver = new ResizeObserver((_ref9) => {
        let [firstEntry] = _ref9;
        if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
          resizeObserver.unobserve(floating);
          cancelAnimationFrame(reobserveFrame);
          reobserveFrame = requestAnimationFrame(() => {
            var _resizeObserver;
            (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
          });
        }
        update();
      });
      if (referenceEl && !animationFrame) {
        resizeObserver.observe(referenceEl);
      }
      if (floating) {
        resizeObserver.observe(floating);
      }
    }
    let frameId;
    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
    if (animationFrame) {
      frameLoop();
    }
    function frameLoop() {
      const nextRefRect = getBoundingClientRect(reference);
      if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
        update();
      }
      prevRefRect = nextRefRect;
      frameId = requestAnimationFrame(frameLoop);
    }
    update();
    return () => {
      var _resizeObserver2;
      ancestors.forEach((ancestor) => {
        ancestorScroll && ancestor.removeEventListener("scroll", update);
        ancestorResize && ancestor.removeEventListener("resize", update);
      });
      cleanupIo == null || cleanupIo();
      (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
      resizeObserver = null;
      if (animationFrame) {
        cancelAnimationFrame(frameId);
      }
    };
  }
  var offset2 = offset;
  var shift2 = shift;
  var flip2 = flip;
  var size2 = size;
  var arrow2 = arrow;
  var limitShift2 = limitShift;
  var computePosition2 = (reference, floating, options2) => {
    const cache2 = /* @__PURE__ */ new Map();
    const mergedOptions = {
      platform,
      ...options2
    };
    const platformWithCache = {
      ...mergedOptions.platform,
      _c: cache2
    };
    return computePosition(reference, floating, {
      ...mergedOptions,
      platform: platformWithCache
    });
  };

  // node_modules/@ariakit/react-components/dist/popover/popover.js
  var TagName20 = "div";
  function createDOMRect(x2 = 0, y3 = 0, width = 0, height = 0) {
    if (typeof DOMRect === "function") return new DOMRect(x2, y3, width, height);
    const rect = {
      x: x2,
      y: y3,
      width,
      height,
      top: y3,
      right: x2 + width,
      bottom: y3 + height,
      left: x2
    };
    return {
      ...rect,
      toJSON: () => rect
    };
  }
  function getDOMRect(anchorRect) {
    if (!anchorRect) return createDOMRect();
    const { x: x2, y: y3, width, height } = anchorRect;
    return createDOMRect(x2, y3, width, height);
  }
  function getAnchorElement(anchorElement, getAnchorRect) {
    return {
      contextElement: anchorElement || void 0,
      getBoundingClientRect: () => {
        const anchor = anchorElement;
        const anchorRect = getAnchorRect?.(anchor);
        if (anchorRect || !anchor) return getDOMRect(anchorRect);
        return anchor.getBoundingClientRect();
      }
    };
  }
  function isValidPlacement(flip4) {
    return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(flip4);
  }
  function roundByDPR(value) {
    const dpr = window.devicePixelRatio || 1;
    return Math.round(value * dpr) / dpr;
  }
  function getOffsetMiddleware(arrowElement, props) {
    return offset2(({ placement }) => {
      const arrowOffset = (arrowElement?.clientHeight || 0) / 2;
      const finalGutter = typeof props.gutter === "number" ? props.gutter + arrowOffset : props.gutter ?? arrowOffset;
      return {
        crossAxis: !!!placement.split("-")[1] ? props.shift : void 0,
        mainAxis: finalGutter,
        alignmentAxis: props.shift
      };
    });
  }
  function getFlipMiddleware(props) {
    if (props.flip === false) return;
    const fallbackPlacements = typeof props.flip === "string" ? props.flip.split(" ") : void 0;
    invariant(!fallbackPlacements || fallbackPlacements.every(isValidPlacement), "`flip` expects a spaced-delimited list of placements");
    return flip2({
      padding: props.overflowPadding,
      fallbackPlacements
    });
  }
  function getShiftMiddleware(props) {
    if (!props.slide && !props.overlap) return;
    return shift2({
      mainAxis: props.slide,
      crossAxis: props.overlap,
      padding: props.overflowPadding,
      limiter: limitShift2()
    });
  }
  function getSizeMiddleware(props, shouldCancel) {
    return size2({
      padding: props.overflowPadding,
      apply({ elements: elements2, availableWidth, availableHeight, rects }) {
        if (shouldCancel?.()) return;
        const wrapper3 = elements2.floating;
        const referenceWidth = Math.round(rects.reference.width);
        availableWidth = Math.floor(availableWidth);
        availableHeight = Math.floor(availableHeight);
        wrapper3.style.setProperty("--popover-anchor-width", `${referenceWidth}px`);
        wrapper3.style.setProperty("--popover-available-width", `${availableWidth}px`);
        wrapper3.style.setProperty("--popover-available-height", `${availableHeight}px`);
        if (props.sameWidth) wrapper3.style.width = `${referenceWidth}px`;
        if (props.fitViewport) {
          wrapper3.style.maxWidth = `${availableWidth}px`;
          wrapper3.style.maxHeight = `${availableHeight}px`;
        }
      }
    });
  }
  function getArrowMiddleware(arrowElement, props) {
    if (!arrowElement) return;
    return arrow2({
      element: arrowElement,
      padding: props.arrowPadding
    });
  }
  var usePopover = createHook(function usePopover2({ store, modal = false, portal = modal, preserveTabOrder = true, autoFocusOnShow = true, wrapperProps, fixed = false, flip: flip4 = true, shift: shift4 = 0, slide = true, overlap = false, sameWidth = false, fitViewport = false, gutter, arrowPadding = 4, overflowPadding = 8, getAnchorRect, updatePosition, ...props }) {
    const context = usePopoverProviderContext();
    store = store || context;
    invariant(store, "Popover must receive a `store` prop or be wrapped in a PopoverProvider component.");
    const arrowElement = useStoreState(store, "arrowElement");
    const anchorElement = useStoreState(store, "anchorElement");
    const disclosureElement = useStoreState(store, "disclosureElement");
    const popoverElement = useStoreState(store, "popoverElement");
    const contentElement = useStoreState(store, "contentElement");
    const placement = useStoreState(store, "placement");
    const mounted = useStoreState(store, "mounted");
    const rendered = useStoreState(store, "rendered");
    const defaultArrowElementRef = (0, import_react27.useRef)(null);
    const [positioned, setPositioned] = (0, import_react27.useState)(false);
    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);
    const getAnchorRectProp = useEvent(getAnchorRect);
    const updatePositionProp = useEvent(updatePosition);
    const hasCustomUpdatePosition = !!updatePosition;
    useSafeLayoutEffect(() => {
      if (!popoverElement?.isConnected) return;
      popoverElement.style.setProperty("--popover-overflow-padding", `${overflowPadding}px`);
      const anchor = getAnchorElement(anchorElement, getAnchorRectProp);
      let canceled = false;
      const shouldCancelUpdate = () => {
        if (canceled) return true;
        if (!popoverElement.isConnected) return true;
        return false;
      };
      const updatePosition2 = async () => {
        if (shouldCancelUpdate()) return;
        if (!mounted) return;
        if (!arrowElement) defaultArrowElementRef.current = defaultArrowElementRef.current || document.createElement("div");
        const arrow4 = arrowElement || defaultArrowElementRef.current;
        const middleware2 = [
          getOffsetMiddleware(arrow4, {
            gutter,
            shift: shift4
          }),
          getFlipMiddleware({
            flip: flip4,
            overflowPadding
          }),
          getShiftMiddleware({
            slide,
            shift: shift4,
            overlap,
            overflowPadding
          }),
          getArrowMiddleware(arrow4, { arrowPadding }),
          getSizeMiddleware({
            sameWidth,
            fitViewport,
            overflowPadding
          }, shouldCancelUpdate)
        ];
        const pos = await computePosition2(anchor, popoverElement, {
          placement,
          strategy: fixed ? "fixed" : "absolute",
          middleware: middleware2
        });
        if (shouldCancelUpdate()) return;
        store?.setState("currentPlacement", pos.placement);
        setPositioned(true);
        const x2 = roundByDPR(pos.x);
        const y3 = roundByDPR(pos.y);
        Object.assign(popoverElement.style, {
          top: "0",
          left: "0",
          transform: `translate3d(${x2}px,${y3}px,0)`
        });
        if (arrow4 && pos.middlewareData.arrow) {
          const { x: arrowX, y: arrowY } = pos.middlewareData.arrow;
          const side = getBasePlacement(pos.placement);
          const centerX = arrow4.clientWidth / 2;
          const centerY = arrow4.clientHeight / 2;
          const originX = arrowX != null ? arrowX + centerX : -centerX;
          const originY = arrowY != null ? arrowY + centerY : -centerY;
          popoverElement.style.setProperty("--popover-transform-origin", {
            top: `${originX}px calc(100% + ${centerY}px)`,
            bottom: `${originX}px ${-centerY}px`,
            left: `calc(100% + ${centerX}px) ${originY}px`,
            right: `${-centerX}px ${originY}px`
          }[side]);
          Object.assign(arrow4.style, {
            left: arrowX != null ? `${arrowX}px` : "",
            top: arrowY != null ? `${arrowY}px` : "",
            right: "",
            bottom: "",
            [side]: "100%"
          });
        }
      };
      const update = async () => {
        if (shouldCancelUpdate()) return;
        if (hasCustomUpdatePosition) {
          await updatePositionProp({ updatePosition: updatePosition2 });
          if (shouldCancelUpdate()) return;
          setPositioned(true);
        } else await updatePosition2();
      };
      const cancelAutoUpdate = autoUpdate(anchor, popoverElement, update, { elementResize: typeof ResizeObserver === "function" });
      return () => {
        canceled = true;
        setPositioned(false);
        cancelAutoUpdate();
      };
    }, [
      store,
      rendered,
      popoverElement,
      arrowElement,
      anchorElement,
      placement,
      mounted,
      domReady,
      fixed,
      flip4,
      shift4,
      slide,
      overlap,
      sameWidth,
      fitViewport,
      gutter,
      arrowPadding,
      overflowPadding,
      getAnchorRectProp,
      hasCustomUpdatePosition,
      updatePositionProp
    ]);
    useSafeLayoutEffect(() => {
      if (!mounted) return;
      if (!domReady) return;
      if (!popoverElement?.isConnected) return;
      if (!contentElement?.isConnected) return;
      const applyZIndex = () => {
        popoverElement.style.zIndex = getComputedStyle(contentElement).zIndex;
      };
      applyZIndex();
      let raf = requestAnimationFrame(() => {
        raf = requestAnimationFrame(applyZIndex);
      });
      return () => cancelAnimationFrame(raf);
    }, [
      mounted,
      domReady,
      popoverElement,
      contentElement
    ]);
    const position2 = fixed ? "fixed" : "absolute";
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", {
      ...wrapperProps,
      style: {
        position: position2,
        top: 0,
        left: 0,
        width: "max-content",
        ...wrapperProps?.style
      },
      ref: store?.setPopoverElement,
      children: element
    }), [
      store,
      position2,
      wrapperProps
    ]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(PopoverScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    props = {
      "data-placing": !positioned || void 0,
      ...props,
      style: {
        position: "relative",
        ...props.style
      }
    };
    props = useDialog({
      store,
      modal,
      portal,
      preserveTabOrder,
      preserveTabOrderAnchor: disclosureElement || anchorElement,
      autoFocusOnShow: positioned && autoFocusOnShow,
      ...props,
      portalRef
    });
    return props;
  });
  var Popover = createDialogComponent(forwardRef2(function Popover2(props) {
    return createElement(TagName20, usePopover(props));
  }), usePopoverProviderContext);

  // node_modules/@ariakit/react-components/dist/hovercard/hovercard-context.js
  var ctx10 = createStoreContext([PopoverContextProvider], [PopoverScopedContextProvider]);
  var useHovercardContext = ctx10.useContext;
  var useHovercardScopedContext = ctx10.useScopedContext;
  var useHovercardProviderContext = ctx10.useProviderContext;
  var HovercardContextProvider = ctx10.ContextProvider;
  var HovercardScopedContextProvider = ctx10.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/hovercard/utils/polygon.js
  function getEventPoint(event) {
    return [event.clientX, event.clientY];
  }
  function isPointInPolygon(point, polygon) {
    const [x2, y3] = point;
    let inside = false;
    const length2 = polygon.length;
    for (let l3 = length2, i3 = 0, j2 = l3 - 1; i3 < l3; j2 = i3++) {
      const currentPoint = polygon[i3];
      const previousPoint = polygon[j2];
      const vertexPoint = polygon[j2 === 0 ? l3 - 1 : j2 - 1];
      if (currentPoint == null) return false;
      if (previousPoint == null) return false;
      if (vertexPoint == null) return false;
      const [xi, yi] = currentPoint;
      const [xj, yj] = previousPoint;
      const [, vy] = vertexPoint;
      const where = (yi - yj) * (x2 - xi) - (xi - xj) * (y3 - yi);
      if (yj < yi) {
        if (y3 >= yj && y3 < yi) {
          if (where === 0) return true;
          if (where > 0) if (y3 === yj) {
            if (y3 > vy) inside = !inside;
          } else inside = !inside;
        }
      } else if (yi < yj) {
        if (y3 > yi && y3 <= yj) {
          if (where === 0) return true;
          if (where < 0) if (y3 === yj) {
            if (y3 < vy) inside = !inside;
          } else inside = !inside;
        }
      } else if (y3 === yi && (x2 >= xj && x2 <= xi || x2 >= xi && x2 <= xj)) return true;
    }
    return inside;
  }
  function getEnterPointPlacement(enterPoint, rect) {
    const { top, right, bottom, left } = rect;
    const [x2, y3] = enterPoint;
    return [x2 < left ? "left" : x2 > right ? "right" : null, y3 < top ? "top" : y3 > bottom ? "bottom" : null];
  }
  function getElementPolygon(element, enterPoint) {
    const rect = element.getBoundingClientRect();
    const { top, right, bottom, left } = rect;
    const [x2, y3] = getEnterPointPlacement(enterPoint, rect);
    const polygon = [enterPoint];
    if (x2) {
      if (y3 !== "top") polygon.push([x2 === "left" ? left : right, top]);
      polygon.push([x2 === "left" ? right : left, top]);
      polygon.push([x2 === "left" ? right : left, bottom]);
      if (y3 !== "bottom") polygon.push([x2 === "left" ? left : right, bottom]);
    } else if (y3 === "top") {
      polygon.push([left, top]);
      polygon.push([left, bottom]);
      polygon.push([right, bottom]);
      polygon.push([right, top]);
    } else {
      polygon.push([left, bottom]);
      polygon.push([left, top]);
      polygon.push([right, top]);
      polygon.push([right, bottom]);
    }
    return polygon;
  }

  // node_modules/@ariakit/react-components/dist/hovercard/hovercard.js
  var import_react28 = __toESM(require_react(), 1);
  var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
  var TagName21 = "div";
  function isMovingOnHovercard(path, card, anchor, nested) {
    if (hasFocusWithin(card)) return true;
    if (path.includes(card)) return true;
    if (anchor && path.includes(anchor)) return true;
    if (nested?.some((card2) => hasFocusWithin(card2) || path.includes(card2))) return true;
    return false;
  }
  function disableEventOnTransit({ event, element, enterPointRef, disablePointerEvents, refreshEnterPoint = false }) {
    const enterPoint = enterPointRef.current;
    if (!enterPoint) return false;
    const currentPoint = getEventPoint(event);
    if (!isPointInPolygon(currentPoint, getElementPolygon(element, enterPoint))) return false;
    if (refreshEnterPoint) enterPointRef.current = currentPoint;
    if (disablePointerEvents(event)) {
      event.preventDefault();
      event.stopPropagation();
    }
    return true;
  }
  function useAutoFocusOnHide({ store, ...props }) {
    const [autoFocusOnHide, setAutoFocusOnHide] = (0, import_react28.useState)(false);
    const mounted = useStoreState(store, "mounted");
    (0, import_react28.useEffect)(() => {
      if (!mounted) setAutoFocusOnHide(false);
    }, [mounted]);
    const onFocusProp = props.onFocus;
    const onFocus = useEvent((event) => {
      onFocusProp?.(event);
      if (event.defaultPrevented) return;
      setAutoFocusOnHide(true);
    });
    const finalFocusRef = (0, import_react28.useRef)(null);
    (0, import_react28.useEffect)(() => {
      return sync(store, ["anchorElement"], (state) => {
        finalFocusRef.current = state.anchorElement;
      });
    }, [store]);
    props = {
      autoFocusOnHide,
      finalFocus: finalFocusRef,
      ...props,
      onFocus
    };
    return props;
  }
  var NestedHovercardContext = (0, import_react28.createContext)(null);
  var useHovercard = createHook(function useHovercard2({ store, modal = false, portal = modal, hideOnEscape = true, hideOnHoverOutside = true, disablePointerEventsOnApproach = !!hideOnHoverOutside, ...props }) {
    const context = useHovercardProviderContext();
    store = store || context;
    invariant(store, "Hovercard must receive a `store` prop or be wrapped in a HovercardProvider component.");
    const ref = (0, import_react28.useRef)(null);
    const nestedHovercardsRef = (0, import_react28.useRef)([]);
    const hideTimeoutRef = (0, import_react28.useRef)(0);
    const enterPointRef = (0, import_react28.useRef)(null);
    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);
    const isMouseMoving = useIsMouseMoving();
    const mayHideOnHoverOutside = !!hideOnHoverOutside;
    const hideOnHoverOutsideProp = useBooleanEvent(hideOnHoverOutside);
    const mayDisablePointerEvents = !!disablePointerEventsOnApproach;
    const disablePointerEventsProp = useBooleanEvent(disablePointerEventsOnApproach);
    const open = useStoreState(store, "open");
    const mounted = useStoreState(store, "mounted");
    const clearHideTimeout = (0, import_react28.useCallback)(() => {
      window.clearTimeout(hideTimeoutRef.current);
      hideTimeoutRef.current = 0;
    }, []);
    (0, import_react28.useEffect)(() => {
      if (!domReady) return;
      if (!mounted) return;
      if (!mayHideOnHoverOutside && !mayDisablePointerEvents) return;
      const element = ref.current;
      if (!element) return;
      const onMouseMove = (event) => {
        if (!store) return;
        if (!isMouseMoving()) return;
        const { anchorElement, hideTimeout, timeout } = store.getState();
        const path = event.composedPath();
        const anchor = anchorElement;
        if (isMovingOnHovercard(path, element, anchor, nestedHovercardsRef.current)) {
          enterPointRef.current = anchor && path.includes(anchor) ? getEventPoint(event) : null;
          clearHideTimeout();
          return;
        }
        if (hideTimeoutRef.current) return;
        if (disableEventOnTransit({
          event,
          element,
          enterPointRef,
          disablePointerEvents: disablePointerEventsProp,
          refreshEnterPoint: true
        })) return;
        if (!hideOnHoverOutsideProp(event)) return;
        hideTimeoutRef.current = window.setTimeout(() => {
          hideTimeoutRef.current = 0;
          store?.hide();
        }, hideTimeout ?? timeout);
      };
      return chain(addGlobalEventListener("mousemove", onMouseMove, true), clearHideTimeout);
    }, [
      store,
      isMouseMoving,
      domReady,
      mounted,
      mayHideOnHoverOutside,
      mayDisablePointerEvents,
      nestedHovercardsRef,
      clearHideTimeout,
      disablePointerEventsProp,
      hideOnHoverOutsideProp
    ]);
    (0, import_react28.useEffect)(() => {
      if (!domReady) return;
      if (!mounted) return;
      if (!mayDisablePointerEvents) return;
      const disableEvent = (event) => {
        const element = ref.current;
        if (!element) return;
        disableEventOnTransit({
          event,
          element,
          enterPointRef,
          disablePointerEvents: disablePointerEventsProp
        });
      };
      return chain(addGlobalEventListener("mouseenter", disableEvent, true), addGlobalEventListener("mouseover", disableEvent, true), addGlobalEventListener("mouseout", disableEvent, true), addGlobalEventListener("mouseleave", disableEvent, true));
    }, [
      domReady,
      mounted,
      mayDisablePointerEvents,
      disablePointerEventsProp
    ]);
    (0, import_react28.useEffect)(() => {
      if (!domReady) return;
      if (open) return;
      store?.setAutoFocusOnShow(false);
    }, [
      store,
      domReady,
      open
    ]);
    const openRef = useLiveRef(open);
    (0, import_react28.useEffect)(() => {
      if (!domReady) return;
      return () => {
        if (!openRef.current) store?.setAutoFocusOnShow(false);
      };
    }, [store, domReady]);
    const registerOnParent = (0, import_react28.useContext)(NestedHovercardContext);
    useSafeLayoutEffect(() => {
      if (modal) return;
      if (!portal) return;
      if (!mounted) return;
      if (!domReady) return;
      const element = ref.current;
      if (!element) return;
      return registerOnParent?.(element);
    }, [
      modal,
      portal,
      mounted,
      domReady
    ]);
    const registerNestedHovercard = (0, import_react28.useCallback)((element) => {
      clearHideTimeout();
      nestedHovercardsRef.current = [...nestedHovercardsRef.current, element];
      const parentUnregister = registerOnParent?.(element);
      return () => {
        clearHideTimeout();
        nestedHovercardsRef.current = nestedHovercardsRef.current.filter((item2) => item2 !== element);
        parentUnregister?.();
      };
    }, [clearHideTimeout, registerOnParent]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(HovercardScopedContextProvider, {
      value: store,
      children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(NestedHovercardContext.Provider, {
        value: registerNestedHovercard,
        children: element
      })
    }), [store, registerNestedHovercard]);
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref)
    };
    props = useAutoFocusOnHide({
      store,
      ...props
    });
    const autoFocusOnShow = useStoreState(store, (state) => modal || state.autoFocusOnShow);
    props = usePopover({
      store,
      modal,
      portal,
      autoFocusOnShow,
      ...props,
      portalRef,
      hideOnEscape(event) {
        if (isFalsyBooleanCallback(hideOnEscape, event)) return false;
        requestAnimationFrame(() => {
          requestAnimationFrame(() => {
            store?.hide();
          });
        });
        return true;
      }
    });
    return props;
  });
  var Hovercard = createDialogComponent(forwardRef2(function Hovercard2(props) {
    return createElement(TagName21, useHovercard(props));
  }), useHovercardProviderContext);

  // node_modules/@ariakit/react-components/dist/tooltip/tooltip-context.js
  var ctx11 = createStoreContext([HovercardContextProvider], [HovercardScopedContextProvider]);
  var useTooltipContext = ctx11.useContext;
  var useTooltipScopedContext = ctx11.useScopedContext;
  var useTooltipProviderContext = ctx11.useProviderContext;
  var TooltipContextProvider = ctx11.ContextProvider;
  var TooltipScopedContextProvider = ctx11.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/tooltip/tooltip.js
  var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
  var TagName22 = "div";
  var useTooltip = createHook(function useTooltip2({ store, portal = true, gutter = 8, preserveTabOrder = false, hideOnHoverOutside = true, hideOnInteractOutside = true, ...props }) {
    const context = useTooltipProviderContext();
    store = store || context;
    invariant(store, "Tooltip must receive a `store` prop or be wrapped in a TooltipProvider component.");
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(TooltipScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    props = {
      role: useStoreState(store, (state) => state.type === "description" ? "tooltip" : "none"),
      ...props
    };
    props = useHovercard({
      ...props,
      store,
      portal,
      gutter,
      preserveTabOrder,
      hideOnHoverOutside(event) {
        if (isFalsyBooleanCallback(hideOnHoverOutside, event)) return false;
        const anchorElement = store?.getState().anchorElement;
        if (!anchorElement) return true;
        if ("focusVisible" in anchorElement.dataset) return false;
        return true;
      },
      hideOnInteractOutside: (event) => {
        if (isFalsyBooleanCallback(hideOnInteractOutside, event)) return false;
        const anchorElement = store?.getState().anchorElement;
        if (!anchorElement) return true;
        if (contains(anchorElement, event.target)) return false;
        return true;
      }
    });
    return props;
  });
  var Tooltip = createDialogComponent(forwardRef2(function Tooltip2(props) {
    return createElement(TagName22, useTooltip(props));
  }), useTooltipProviderContext);

  // node_modules/@ariakit/react-components/dist/hovercard/hovercard-anchor.js
  var import_react29 = __toESM(require_react(), 1);
  var TagName23 = "a";
  var useHovercardAnchor = createHook(function useHovercardAnchor2({ store, showOnHover = true, ...props }) {
    const context = useHovercardProviderContext();
    store = store || context;
    invariant(store, "HovercardAnchor must receive a `store` prop or be wrapped in a HovercardProvider component.");
    const disabled = disabledFromProps(props);
    const showTimeoutRef = (0, import_react29.useRef)(0);
    (0, import_react29.useEffect)(() => () => window.clearTimeout(showTimeoutRef.current), []);
    (0, import_react29.useEffect)(() => {
      const onMouseLeave = (event) => {
        if (!store) return;
        const { anchorElement } = store.getState();
        if (!anchorElement) return;
        if (event.target !== anchorElement) return;
        window.clearTimeout(showTimeoutRef.current);
        showTimeoutRef.current = 0;
      };
      return addGlobalEventListener("mouseleave", onMouseLeave, true);
    }, [store]);
    const onMouseMoveProp = props.onMouseMove;
    const showOnHoverProp = useBooleanEvent(showOnHover);
    const isMouseMoving = useIsMouseMoving();
    const onMouseMove = useEvent((event) => {
      onMouseMoveProp?.(event);
      if (disabled) return;
      if (!store) return;
      if (event.defaultPrevented) return;
      if (showTimeoutRef.current) return;
      if (!isMouseMoving()) return;
      if (!showOnHoverProp(event)) return;
      const element = event.currentTarget;
      store.setAnchorElement(element);
      store.setDisclosureElement(element);
      const { showTimeout, timeout } = store.getState();
      const showHovercard = () => {
        showTimeoutRef.current = 0;
        if (!isMouseMoving()) return;
        store?.setAnchorElement(element);
        store?.show();
        queueMicrotask(() => {
          store?.setDisclosureElement(element);
        });
      };
      const timeoutMs = showTimeout ?? timeout;
      if (timeoutMs === 0) showHovercard();
      else showTimeoutRef.current = window.setTimeout(showHovercard, timeoutMs);
    });
    const onClickProp = props.onClick;
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (!store) return;
      window.clearTimeout(showTimeoutRef.current);
      showTimeoutRef.current = 0;
    });
    const ref = (0, import_react29.useCallback)((element) => {
      if (!store) return;
      const { anchorElement } = store.getState();
      if (anchorElement?.isConnected) return;
      store.setAnchorElement(element);
    }, [store]);
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref),
      onMouseMove,
      onClick
    };
    props = useFocusable(props);
    return props;
  });
  var HovercardAnchor = forwardRef2(function HovercardAnchor2(props) {
    return createElement(TagName23, useHovercardAnchor(props));
  });

  // node_modules/@ariakit/react-components/dist/tooltip/tooltip-anchor.js
  var import_react30 = __toESM(require_react(), 1);
  var TagName24 = "div";
  var globalStore = createStore({ activeStore: null });
  var hidingStores = /* @__PURE__ */ new WeakSet();
  function createRemoveStoreCallback(store) {
    return () => {
      const { activeStore } = globalStore.getState();
      if (activeStore !== store) return;
      globalStore.setState("activeStore", null);
    };
  }
  function hideStore(store) {
    if (!store) return;
    hidingStores.add(store);
    store.hide();
    queueMicrotask(() => hidingStores.delete(store));
  }
  var useTooltipAnchor = createHook(function useTooltipAnchor2({ store, showOnHover = true, ...props }) {
    const context = useTooltipProviderContext();
    store = store || context;
    invariant(store, "TooltipAnchor must receive a `store` prop or be wrapped in a TooltipProvider component.");
    const canShowOnHoverRef = (0, import_react30.useRef)(false);
    (0, import_react30.useEffect)(() => {
      return sync(store, ["mounted"], (state) => {
        if (state.mounted) return;
        canShowOnHoverRef.current = false;
      });
    }, [store]);
    (0, import_react30.useEffect)(() => {
      if (!store) return;
      const removeStore = createRemoveStoreCallback(store);
      return chain(removeStore, sync(store, ["mounted"], (state) => {
        if (!store) return;
        if (state.mounted) {
          const { activeStore } = globalStore.getState();
          if (activeStore !== store) {
            if (hidingStores.has(store)) return;
            hideStore(activeStore);
          }
          return globalStore.setState("activeStore", store);
        }
        const id3 = setTimeout(removeStore, store.getState().skipTimeout);
        return () => clearTimeout(id3);
      }));
    }, [store]);
    const onMouseEnterProp = props.onMouseEnter;
    const onMouseEnter = useEvent((event) => {
      onMouseEnterProp?.(event);
      canShowOnHoverRef.current = true;
    });
    const onFocusVisibleProp = props.onFocusVisible;
    const onFocusVisible = useEvent((event) => {
      onFocusVisibleProp?.(event);
      if (event.defaultPrevented) return;
      store?.setAnchorElement(event.currentTarget);
      store?.show();
    });
    const onBlurProp = props.onBlur;
    const onBlur = useEvent((event) => {
      onBlurProp?.(event);
      if (event.defaultPrevented) return;
      const { activeStore } = globalStore.getState();
      canShowOnHoverRef.current = false;
      if (activeStore === store) globalStore.setState("activeStore", null);
    });
    const labelledBy = useStoreState(store, (state) => state.type === "label" ? state.contentElement?.id : void 0);
    props = {
      "aria-labelledby": props["aria-label"] == null ? labelledBy : void 0,
      ...props,
      onMouseEnter,
      onFocusVisible,
      onBlur
    };
    props = useHovercardAnchor({
      store,
      showOnHover(event) {
        if (!canShowOnHoverRef.current) return false;
        if (isFalsyBooleanCallback(showOnHover, event)) return false;
        const { activeStore } = globalStore.getState();
        if (!activeStore) return true;
        store?.show();
        return false;
      },
      ...props
    });
    return props;
  });
  var TooltipAnchor = forwardRef2(function TooltipAnchor2(props) {
    return createElement(TagName24, useTooltipAnchor(props));
  });

  // node_modules/@ariakit/components/dist/popover/popover-store.js
  function createPopoverStore({ popover: otherPopover, ...props } = {}) {
    const store = mergeStore(props.store, omit2(otherPopover, [
      "arrowElement",
      "anchorElement",
      "contentElement",
      "popoverElement",
      "disclosureElement"
    ]));
    throwOnConflictingProps(props, store);
    const syncState = store?.getState();
    const dialog = createDialogStore({
      ...props,
      store
    });
    const placement = defaultValue(props.placement, syncState?.placement, "bottom");
    const popover = createStore({
      ...dialog.getState(),
      placement,
      currentPlacement: placement,
      anchorElement: defaultValue(syncState?.anchorElement, null),
      popoverElement: defaultValue(syncState?.popoverElement, null),
      arrowElement: defaultValue(syncState?.arrowElement, null),
      rendered: /* @__PURE__ */ Symbol("rendered")
    }, dialog, store);
    return {
      ...dialog,
      ...popover,
      setAnchorElement: (element) => popover.setState("anchorElement", element),
      setPopoverElement: (element) => popover.setState("popoverElement", element),
      setArrowElement: (element) => popover.setState("arrowElement", element),
      render: () => popover.setState("rendered", /* @__PURE__ */ Symbol("rendered"))
    };
  }

  // node_modules/@ariakit/react-components/dist/popover/popover-store.js
  function usePopoverStoreProps(store, update, props) {
    useUpdateEffect(update, [props.popover]);
    useStoreProps(store, props, "placement");
    return useDialogStoreProps(store, update, props);
  }

  // node_modules/@ariakit/components/dist/hovercard/hovercard-store.js
  function createHovercardStore(props = {}) {
    const syncState = props.store?.getState();
    const popover = createPopoverStore({
      ...props,
      placement: defaultValue(props.placement, syncState?.placement, "bottom")
    });
    const timeout = defaultValue(props.timeout, syncState?.timeout, 500);
    const hovercard = createStore({
      ...popover.getState(),
      timeout,
      showTimeout: defaultValue(props.showTimeout, syncState?.showTimeout),
      hideTimeout: defaultValue(props.hideTimeout, syncState?.hideTimeout),
      autoFocusOnShow: defaultValue(syncState?.autoFocusOnShow, false)
    }, popover, props.store);
    return {
      ...popover,
      ...hovercard,
      setAutoFocusOnShow: (value) => hovercard.setState("autoFocusOnShow", value)
    };
  }

  // node_modules/@ariakit/react-components/dist/hovercard/hovercard-store.js
  function useHovercardStoreProps(store, update, props) {
    useStoreProps(store, props, "timeout");
    useStoreProps(store, props, "showTimeout");
    useStoreProps(store, props, "hideTimeout");
    return usePopoverStoreProps(store, update, props);
  }

  // node_modules/@ariakit/components/dist/tooltip/tooltip-store.js
  function createTooltipStore(props = {}) {
    if (true) {
      if (props.type === "label") console.warn("The `type` option on the tooltip store is deprecated.", "Render a visually hidden label or use the `aria-label` or `aria-labelledby` attributes on the anchor element instead.", "See https://ariakit.com/components/tooltip#tooltip-anchors-must-have-accessible-names");
    }
    const syncState = props.store?.getState();
    const hovercard = createHovercardStore({
      ...props,
      placement: defaultValue(props.placement, syncState?.placement, "top"),
      hideTimeout: defaultValue(props.hideTimeout, syncState?.hideTimeout, 0)
    });
    const tooltip = createStore({
      ...hovercard.getState(),
      type: defaultValue(props.type, syncState?.type, "description"),
      skipTimeout: defaultValue(props.skipTimeout, syncState?.skipTimeout, 300)
    }, hovercard, props.store);
    return {
      ...hovercard,
      ...tooltip
    };
  }

  // node_modules/@ariakit/react-components/dist/tooltip/tooltip-store.js
  function useTooltipStoreProps(store, update, props) {
    useStoreProps(store, props, "type");
    useStoreProps(store, props, "skipTimeout");
    return useHovercardStoreProps(store, update, props);
  }
  function useTooltipStore(props = {}) {
    const [store, update] = useStore(createTooltipStore, props);
    return useTooltipStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/menubar/menubar-context.js
  var menubar = createStoreContext([CompositeContextProvider], [CompositeScopedContextProvider]);
  var useMenubarContext = menubar.useContext;
  var useMenubarScopedContext = menubar.useScopedContext;
  var useMenubarProviderContext = menubar.useProviderContext;
  var MenubarContextProvider = menubar.ContextProvider;
  var MenubarScopedContextProvider = menubar.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/popover/popover-anchor.js
  var TagName25 = "div";
  var usePopoverAnchor = createHook(function usePopoverAnchor2({ store, ...props }) {
    const context = usePopoverProviderContext();
    store = store || context;
    props = {
      ...props,
      ref: useMergeRefs(store?.setAnchorElement, props.ref)
    };
    return props;
  });
  var PopoverAnchor = forwardRef2(function PopoverAnchor2(props) {
    return createElement(TagName25, usePopoverAnchor(props));
  });

  // node_modules/@ariakit/react-components/dist/button/button.js
  var import_react31 = __toESM(require_react(), 1);
  var TagName26 = "button";
  var useButton = createHook(function useButton2(props) {
    const ref = (0, import_react31.useRef)(null);
    const tagName = useTagName(ref, TagName26);
    const [isNativeButton, setIsNativeButton] = (0, import_react31.useState)(() => !!tagName && isButton({
      tagName,
      type: props.type
    }));
    (0, import_react31.useEffect)(() => {
      if (!ref.current) return;
      setIsNativeButton(isButton(ref.current));
    }, []);
    props = {
      role: !isNativeButton && tagName !== "a" ? "button" : void 0,
      ...props,
      ref: useMergeRefs(ref, props.ref)
    };
    props = useCommand(props);
    return props;
  });
  var Button = forwardRef2(function Button2(props) {
    return createElement(TagName26, useButton(props));
  });

  // node_modules/@ariakit/react-components/dist/disclosure/disclosure.js
  var import_react32 = __toESM(require_react(), 1);
  var TagName27 = "button";
  var symbol2 = /* @__PURE__ */ Symbol("disclosure");
  var useDisclosure = createHook(function useDisclosure2({ store, toggleOnClick = true, ...props }) {
    const context = useDisclosureProviderContext();
    store = store || context;
    invariant(store, "Disclosure must receive a `store` prop or be wrapped in a DisclosureProvider component.");
    const ref = (0, import_react32.useRef)(null);
    const [expanded, setExpanded] = (0, import_react32.useState)(false);
    const disclosureElement = useStoreState(store, "disclosureElement");
    const open = useStoreState(store, "open");
    (0, import_react32.useEffect)(() => {
      let isCurrentDisclosure = disclosureElement === ref.current;
      if (!disclosureElement?.isConnected) {
        store?.setDisclosureElement(ref.current);
        isCurrentDisclosure = true;
      }
      setExpanded(open && isCurrentDisclosure);
    }, [
      disclosureElement,
      store,
      open
    ]);
    const onClickProp = props.onClick;
    const toggleOnClickProp = useBooleanEvent(toggleOnClick);
    const [isDuplicate, metadataProps] = useMetadataProps(props, symbol2, true);
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      if (isDuplicate) return;
      if (!toggleOnClickProp(event)) return;
      store?.setDisclosureElement(event.currentTarget);
      store?.toggle();
    });
    props = {
      "aria-expanded": expanded,
      "aria-controls": useStoreState(store, "contentElement")?.id,
      ...metadataProps,
      ...props,
      ref: useMergeRefs(ref, props.ref),
      onClick
    };
    props = useButton(props);
    return props;
  });
  var Disclosure = forwardRef2(function Disclosure2(props) {
    return createElement(TagName27, useDisclosure(props));
  });

  // node_modules/@ariakit/react-components/dist/dialog/dialog-disclosure.js
  var TagName28 = "button";
  var useDialogDisclosure = createHook(function useDialogDisclosure2({ store, ...props }) {
    const context = useDialogProviderContext();
    store = store || context;
    invariant(store, "DialogDisclosure must receive a `store` prop or be wrapped in a DialogProvider component.");
    props = {
      "aria-haspopup": getPopupRole(useStoreState(store, "contentElement"), "dialog"),
      ...props
    };
    props = useDisclosure({
      store,
      ...props
    });
    return props;
  });
  var DialogDisclosure = forwardRef2(function DialogDisclosure2(props) {
    return createElement(TagName28, useDialogDisclosure(props));
  });

  // node_modules/@ariakit/react-components/dist/popover/popover-disclosure.js
  var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
  var TagName29 = "button";
  var usePopoverDisclosure = createHook(function usePopoverDisclosure2({ store, ...props }) {
    const context = usePopoverProviderContext();
    store = store || context;
    invariant(store, "PopoverDisclosure must receive a `store` prop or be wrapped in a PopoverProvider component.");
    const onClickProp = props.onClick;
    const onClick = useEvent((event) => {
      store?.setAnchorElement(event.currentTarget);
      onClickProp?.(event);
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(PopoverScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    props = {
      ...props,
      onClick
    };
    props = usePopoverAnchor({
      store,
      ...props
    });
    props = useDialogDisclosure({
      store,
      ...props
    });
    return props;
  });
  var PopoverDisclosure = forwardRef2(function PopoverDisclosure2(props) {
    return createElement(TagName29, usePopoverDisclosure(props));
  });

  // node_modules/@ariakit/react-components/dist/popover/popover-disclosure-arrow.js
  var import_react33 = __toESM(require_react(), 1);
  var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
  var TagName30 = "span";
  var pointsMap = {
    top: "4,10 8,6 12,10",
    right: "6,4 10,8 6,12",
    bottom: "4,6 8,10 12,6",
    left: "10,4 6,8 10,12"
  };
  var usePopoverDisclosureArrow = createHook(function usePopoverDisclosureArrow2({ store, placement, ...props }) {
    const context = usePopoverContext();
    store = store || context;
    invariant(store, "PopoverDisclosureArrow must be wrapped in a PopoverDisclosure component.");
    const points = pointsMap[getBasePlacement(useStoreState(store, (state) => placement || state.placement))];
    props = {
      children: (0, import_react33.useMemo)(() => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("svg", {
        display: "block",
        fill: "none",
        stroke: "currentColor",
        strokeLinecap: "round",
        strokeLinejoin: "round",
        strokeWidth: 1.5,
        viewBox: "0 0 16 16",
        height: "1em",
        width: "1em",
        children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("polyline", { points })
      }), [points]),
      "aria-hidden": true,
      ...props,
      style: {
        width: "1em",
        height: "1em",
        pointerEvents: "none",
        ...props.style
      }
    };
    return removeUndefinedValues(props);
  });
  var PopoverDisclosureArrow = forwardRef2(function PopoverDisclosureArrow2(props) {
    return createElement(TagName30, usePopoverDisclosureArrow(props));
  });

  // node_modules/@ariakit/react-components/dist/radio/radio-context.js
  var ctx12 = createStoreContext([CompositeContextProvider], [CompositeScopedContextProvider]);
  var useRadioContext = ctx12.useContext;
  var useRadioScopedContext = ctx12.useScopedContext;
  var useRadioProviderContext = ctx12.useProviderContext;
  var RadioContextProvider = ctx12.ContextProvider;
  var RadioScopedContextProvider = ctx12.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/radio/radio.js
  var import_react34 = __toESM(require_react(), 1);
  var TagName31 = "input";
  function getIsChecked(value, storeValue) {
    if (storeValue === void 0) return;
    if (value != null && storeValue != null) return storeValue === value;
    return !!storeValue;
  }
  function isNativeRadio(tagName, type) {
    return tagName === "input" && (!type || type === "radio");
  }
  var useRadio = createHook(function useRadio2({ store, name: nameProp, value, checked, ...props }) {
    const context = useRadioContext();
    store = store || context;
    const id3 = useId(props.id);
    const ref = (0, import_react34.useRef)(null);
    const isChecked = useStoreState(store, (state) => checked ?? getIsChecked(value, state?.value));
    const storeId = useStoreState(store, "id");
    const name = nameProp ?? storeId;
    (0, import_react34.useEffect)(() => {
      if (!id3) return;
      if (!isChecked) return;
      if (store?.getState().activeId === id3) return;
      store?.setActiveId(id3);
    }, [
      store,
      isChecked,
      id3
    ]);
    const onChangeProp = props.onChange;
    const nativeRadio = isNativeRadio(useTagName(ref, TagName31), props.type);
    const disabled = disabledFromProps(props);
    const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
    (0, import_react34.useEffect)(() => {
      const element = ref.current;
      if (!element) return;
      if (nativeRadio) return;
      if (isChecked !== void 0) element.checked = isChecked;
      if (name !== void 0) element.name = name;
      if (value !== void 0) element.value = `${value}`;
    }, [
      propertyUpdated,
      nativeRadio,
      isChecked,
      name,
      value
    ]);
    const onChange = useEvent((event) => {
      if (disabled) {
        event.preventDefault();
        event.stopPropagation();
        return;
      }
      if (store?.getState().value === value) return;
      if (!nativeRadio) {
        event.currentTarget.checked = true;
        schedulePropertyUpdate();
      }
      onChangeProp?.(event);
      if (event.defaultPrevented) return;
      store?.setValue(value);
    });
    const onClickProp = props.onClick;
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      if (nativeRadio) return;
      onChange(event);
    });
    const onFocusProp = props.onFocus;
    const onFocus = useEvent((event) => {
      onFocusProp?.(event);
      if (event.defaultPrevented) return;
      if (!nativeRadio) return;
      if (disabled) return;
      if (!store) return;
      const { moves, activeId } = store.getState();
      if (!moves) return;
      if (id3 && activeId !== id3) return;
      if (event.currentTarget.checked) return;
      event.currentTarget.click();
    });
    props = {
      role: !nativeRadio ? "radio" : void 0,
      type: nativeRadio ? "radio" : void 0,
      "aria-checked": isChecked,
      ...props,
      id: id3,
      ref: useMergeRefs(ref, props.ref),
      onChange,
      onClick,
      onFocus
    };
    props = useCompositeItem({
      store,
      clickOnEnter: !nativeRadio,
      ...props
    });
    return removeUndefinedValues({
      name: nativeRadio ? name : void 0,
      value: nativeRadio ? value : void 0,
      checked: isChecked,
      ...props
    });
  });
  var Radio = memo2(forwardRef2(function Radio2(props) {
    return createElement(TagName31, useRadio(props));
  }));

  // node_modules/@ariakit/react-components/dist/radio/radio-group.js
  var import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
  var TagName32 = "div";
  function isCheckedRadio(element) {
    if (!element) return false;
    if (element.tagName === "INPUT") {
      const { type, checked } = element;
      if (type === "radio") return checked;
    }
    if (element.getAttribute("role") !== "radio") return false;
    return element.getAttribute("aria-checked") === "true";
  }
  function getCheckedRadioId(store) {
    const { renderedItems } = store.getState();
    return renderedItems.find((item2) => isCheckedRadio(item2.element))?.id;
  }
  var useRadioGroup = createHook(function useRadioGroup2({ store, ...props }) {
    const context = useRadioProviderContext();
    store = store || context;
    invariant(store, "RadioGroup must receive a `store` prop or be wrapped in a RadioProvider component.");
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(RadioScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    const onBlurCaptureProp = props.onBlurCapture;
    const onBlurCapture = useEvent((event) => {
      onBlurCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (!isFocusEventOutside(event)) return;
      const checkedId = getCheckedRadioId(store);
      if (!checkedId) return;
      store.setActiveId(checkedId);
    });
    props = {
      role: "radiogroup",
      ...props,
      onBlurCapture
    };
    props = useComposite({
      store,
      ...props
    });
    return props;
  });
  var RadioGroup = forwardRef2(function RadioGroup2(props) {
    return createElement(TagName32, useRadioGroup(props));
  });

  // node_modules/@ariakit/components/dist/radio/radio-store.js
  function createRadioStore(props = {}) {
    const syncState = props.store?.getState();
    const composite = createCompositeStore({
      ...props,
      focusLoop: defaultValue(props.focusLoop, syncState?.focusLoop, true)
    });
    const radio = createStore({
      ...composite.getState(),
      value: defaultValue(props.value, syncState?.value, props.defaultValue, null)
    }, composite, props.store);
    return {
      ...composite,
      ...radio,
      setValue: (value) => radio.setState("value", value)
    };
  }

  // node_modules/@ariakit/react-components/dist/radio/radio-store.js
  function useRadioStoreProps(store, update, props) {
    store = useCompositeStoreProps(store, update, props);
    useStoreProps(store, props, "value", "setValue");
    return store;
  }
  function useRadioStore(props = {}) {
    props = useCompositeStoreOptions(props);
    const [store, update] = useStore(createRadioStore, props);
    return useRadioStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/composite/composite-typeahead.js
  var TagName33 = "div";
  var typeaheadStates = /* @__PURE__ */ new WeakMap();
  function getTypeaheadState(store) {
    let typeaheadState = typeaheadStates.get(store);
    if (!typeaheadState) {
      typeaheadState = {
        chars: "",
        cleanupTimeout: 0
      };
      typeaheadStates.set(store, typeaheadState);
    }
    return typeaheadState;
  }
  function clearChars(typeaheadState) {
    typeaheadState.chars = "";
  }
  function isValidTypeaheadEvent(event, typeaheadState) {
    const target = event.target;
    if (target && isTextField(target)) return false;
    if (event.key === " " && typeaheadState.chars.length) return true;
    return event.key.length === 1 && !event.ctrlKey && !event.altKey && !event.metaKey && /^[\p{Letter}\p{Number}]$/u.test(event.key);
  }
  function isSelfTargetOrItem(event, items) {
    if (isSelfTarget(event)) return true;
    const target = event.target;
    if (!target) return false;
    return items.some((item2) => item2.element === target);
  }
  function getEnabledItems2(items) {
    return items.filter((item2) => !item2.disabled);
  }
  function itemTextStartsWith(item2, text) {
    const itemText = item2.element?.textContent || item2.children || "value" in item2 && item2.value;
    if (!itemText) return false;
    return normalizeString(itemText).trim().toLowerCase().startsWith(text.toLowerCase());
  }
  function getSameInitialItems({ activeId, char: char2, items, typeaheadState }) {
    if (!activeId) return items;
    const activeItem = items.find((item2) => item2.id === activeId);
    if (!activeItem) return items;
    if (!itemTextStartsWith(activeItem, char2)) return items;
    const { chars } = typeaheadState;
    if (chars !== char2 && itemTextStartsWith(activeItem, chars)) return items;
    typeaheadState.chars = char2;
    return flipItems2(items.filter((item2) => itemTextStartsWith(item2, char2)), activeId).filter((item2) => item2.id !== activeId);
  }
  var useCompositeTypeahead = createHook(function useCompositeTypeahead2({ store, typeahead = true, ...props }) {
    const context = useCompositeScopedContext();
    store = store || context;
    invariant(store, "CompositeTypeahead must be a Composite component");
    const onKeyDownCaptureProp = props.onKeyDownCapture;
    const onKeyDownCapture = useEvent((event) => {
      onKeyDownCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (!typeahead) return;
      if (!store) return;
      const typeaheadState = getTypeaheadState(store);
      if (!isValidTypeaheadEvent(event, typeaheadState)) return clearChars(typeaheadState);
      const { renderedItems, items, activeId, id: id3 } = store.getState();
      let enabledItems = getEnabledItems2(items.length > renderedItems.length ? items : renderedItems);
      const document2 = getDocument(event.currentTarget);
      const selector2 = `[data-offscreen-id="${id3}"]`;
      const offscreenItems = document2.querySelectorAll(selector2);
      for (const element of offscreenItems) {
        if (element.hasAttribute("data-disabled")) continue;
        if ("disabled" in element && !!element.disabled) continue;
        enabledItems.push({
          id: element.id,
          element
        });
      }
      if (offscreenItems.length) enabledItems = sortBasedOnDOMPosition(enabledItems, (i3) => i3.element);
      if (!isSelfTargetOrItem(event, enabledItems)) return clearChars(typeaheadState);
      event.preventDefault();
      window.clearTimeout(typeaheadState.cleanupTimeout);
      typeaheadState.cleanupTimeout = window.setTimeout(() => {
        clearChars(typeaheadState);
      }, 500);
      const char2 = event.key.toLowerCase();
      typeaheadState.chars += char2;
      enabledItems = getSameInitialItems({
        activeId,
        char: char2,
        items: enabledItems,
        typeaheadState
      });
      const item2 = enabledItems.find((item3) => itemTextStartsWith(item3, typeaheadState.chars));
      if (item2) store.move(item2.id);
      else clearChars(typeaheadState);
    });
    props = {
      ...props,
      onKeyDownCapture
    };
    return removeUndefinedValues(props);
  });
  var CompositeTypeahead = forwardRef2(function CompositeTypeahead2(props) {
    return createElement(TagName33, useCompositeTypeahead(props));
  });

  // node_modules/@ariakit/react-components/dist/select/select-arrow.js
  var TagName34 = "span";
  var useSelectArrow = createHook(function useSelectArrow2({ store, ...props }) {
    const context = useSelectContext();
    store = store || context;
    props = usePopoverDisclosureArrow({
      store,
      ...props
    });
    return props;
  });
  var SelectArrow = forwardRef2(function SelectArrow2(props) {
    return createElement(TagName34, useSelectArrow(props));
  });

  // node_modules/@ariakit/react-components/dist/select/select.js
  var import_react35 = __toESM(require_react(), 1);
  var import_jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
  var TagName35 = "button";
  function getSelectedValues(select) {
    return Array.from(select.selectedOptions).map((option) => option.value);
  }
  function nextWithValue(store, next2) {
    return () => {
      const visitedIds = /* @__PURE__ */ new Set();
      let nextId = next2();
      while (nextId) {
        const nextItem = store.item(nextId);
        if (!nextItem) return;
        if (nextItem.value != null) return nextItem.id;
        if (visitedIds.has(nextId)) return;
        visitedIds.add(nextId);
        nextId = next2({ activeId: nextId });
      }
    };
  }
  var useSelect = createHook(function useSelect2({ store, name, form, required, showOnKeyDown = true, moveOnKeyDown = true, toggleOnPress = true, toggleOnClick = toggleOnPress, ...props }) {
    const context = useSelectProviderContext();
    store = store || context;
    invariant(store, "Select must receive a `store` prop or be wrapped in a SelectProvider component.");
    const onKeyDownProp = props.onKeyDown;
    const showOnKeyDownProp = useBooleanEvent(showOnKeyDown);
    const moveOnKeyDownProp = useBooleanEvent(moveOnKeyDown);
    const dir = getBasePlacement(useStoreState(store, "placement"));
    const value = useStoreState(store, "value");
    const multiSelectable = Array.isArray(value);
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (event.defaultPrevented) return;
      if (!store) return;
      const { orientation, items: items2, activeId } = store.getState();
      const isVertical = orientation !== "horizontal";
      const isHorizontal = orientation !== "vertical";
      const isGrid2 = !!items2.find((item2) => !item2.disabled && item2.value != null)?.rowId;
      const getId = {
        ArrowUp: (isGrid2 || isVertical) && nextWithValue(store, store.up),
        ArrowRight: (isGrid2 || isHorizontal) && nextWithValue(store, store.next),
        ArrowDown: (isGrid2 || isVertical) && nextWithValue(store, store.down),
        ArrowLeft: (isGrid2 || isHorizontal) && nextWithValue(store, store.previous)
      }[event.key];
      if (getId && moveOnKeyDownProp(event)) {
        event.preventDefault();
        store.move(getId());
      }
      const isTopOrBottom = dir === "top" || dir === "bottom";
      if ({
        ArrowDown: isTopOrBottom,
        ArrowUp: isTopOrBottom,
        ArrowLeft: dir === "left",
        ArrowRight: dir === "right"
      }[event.key] && showOnKeyDownProp(event)) {
        event.preventDefault();
        store.move(activeId);
        queueBeforeEvent(event.currentTarget, "keyup", store.show);
      }
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(SelectScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    const [autofill, setAutofill] = (0, import_react35.useState)(false);
    const nativeSelectChangedRef = (0, import_react35.useRef)(false);
    (0, import_react35.useEffect)(() => {
      const nativeSelectChanged = nativeSelectChangedRef.current;
      nativeSelectChangedRef.current = false;
      if (nativeSelectChanged) return;
      setAutofill(false);
    }, [value]);
    const labelId = useStoreState(store, (state) => state.labelElement?.id);
    const label = props["aria-label"];
    const labelledBy = props["aria-labelledby"] || labelId;
    const items = useStoreState(store, (state) => {
      if (!name) return;
      return state.items;
    });
    const values = (0, import_react35.useMemo)(() => {
      const itemValues = items?.flatMap((item2) => item2.value ?? []);
      return [...new Set(itemValues)];
    }, [items]);
    props = useWrapElement(props, (element) => {
      if (!name) return element;
      return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [/* @__PURE__ */ (0, import_jsx_runtime21.jsxs)("select", {
        style: getVisuallyHiddenStyle(),
        tabIndex: -1,
        "aria-hidden": true,
        "aria-label": label,
        "aria-labelledby": label != null ? void 0 : labelledBy,
        name,
        form,
        required,
        disabled: props.disabled,
        value,
        multiple: multiSelectable,
        onFocus: () => store?.getState().selectElement?.focus(),
        onChange: (event) => {
          nativeSelectChangedRef.current = true;
          setAutofill(true);
          store?.setValue(multiSelectable ? getSelectedValues(event.target) : event.target.value);
        },
        children: [toArray(value).map((value2) => {
          if (value2 == null) return null;
          if (values.includes(value2)) return null;
          return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("option", {
            value: value2,
            children: value2
          }, value2);
        }), values.map((value2) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("option", {
          value: value2,
          children: value2
        }, value2))]
      }), element] });
    }, [
      store,
      label,
      labelledBy,
      name,
      form,
      required,
      value,
      multiSelectable,
      values,
      props.disabled
    ]);
    const children = /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [value, /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(SelectArrow, {})] });
    const contentElement = useStoreState(store, "contentElement");
    props = {
      role: "combobox",
      "aria-autocomplete": "none",
      "aria-labelledby": props["aria-label"] != null ? void 0 : labelId,
      "aria-haspopup": getPopupRole(contentElement, "listbox"),
      "data-autofill": autofill || void 0,
      "data-name": name,
      children,
      ...props,
      ref: useMergeRefs(store.setSelectElement, props.ref),
      onKeyDown
    };
    props = usePopoverDisclosure({
      store,
      toggleOnClick,
      ...props
    });
    props = useCompositeTypeahead({
      store,
      ...props
    });
    return props;
  });
  var Select = forwardRef2(function Select2(props) {
    return createElement(TagName35, useSelect(props));
  });

  // node_modules/@ariakit/react-components/dist/group/group-label-context.js
  var import_react36 = __toESM(require_react(), 1);
  var GroupLabelContext = (0, import_react36.createContext)(void 0);

  // node_modules/@ariakit/react-components/dist/group/group.js
  var import_react37 = __toESM(require_react(), 1);
  var import_jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
  var TagName36 = "div";
  var useGroup = createHook(function useGroup2(props) {
    const [labelId, setLabelId] = (0, import_react37.useState)();
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(GroupLabelContext.Provider, {
      value: setLabelId,
      children: element
    }), []);
    props = {
      role: "group",
      "aria-labelledby": props["aria-label"] != null ? void 0 : labelId,
      ...props
    };
    return removeUndefinedValues(props);
  });
  var Group = forwardRef2(function Group2(props) {
    return createElement(TagName36, useGroup(props));
  });

  // node_modules/@ariakit/react-components/dist/composite/composite-group.js
  var TagName37 = "div";
  var useCompositeGroup = createHook(function useCompositeGroup2({ store, ...props }) {
    props = useGroup(props);
    return props;
  });
  var CompositeGroup = forwardRef2(function CompositeGroup2(props) {
    return createElement(TagName37, useCompositeGroup(props));
  });

  // node_modules/@ariakit/react-components/dist/group/group-label.js
  var import_react38 = __toESM(require_react(), 1);
  var TagName38 = "div";
  var useGroupLabel = createHook(function useGroupLabel2(props) {
    const setLabelId = (0, import_react38.useContext)(GroupLabelContext);
    const id3 = useId(props.id);
    useSafeLayoutEffect(() => {
      setLabelId?.(id3);
      return () => setLabelId?.(void 0);
    }, [setLabelId, id3]);
    props = {
      "aria-hidden": true,
      ...props,
      id: id3
    };
    return removeUndefinedValues(props);
  });
  var GroupLabel = forwardRef2(function GroupLabel2(props) {
    return createElement(TagName38, useGroupLabel(props));
  });

  // node_modules/@ariakit/react-components/dist/composite/composite-group-label.js
  var TagName39 = "div";
  var useCompositeGroupLabel = createHook(function useCompositeGroupLabel2({ store, ...props }) {
    props = useGroupLabel(props);
    return props;
  });
  var CompositeGroupLabel = forwardRef2(function CompositeGroupLabel2(props) {
    return createElement(TagName39, useCompositeGroupLabel(props));
  });

  // node_modules/@ariakit/react-components/dist/composite/composite-hover.js
  var import_react39 = __toESM(require_react(), 1);
  var TagName40 = "div";
  function hoveringInside(event) {
    const nextElement = event.relatedTarget;
    if (!isElement(nextElement)) return false;
    return contains(event.currentTarget, nextElement);
  }
  var symbol3 = /* @__PURE__ */ Symbol("composite-hover");
  function movingToAnotherItem(event) {
    const { relatedTarget } = event;
    if (!isElement(relatedTarget)) return false;
    let dest = relatedTarget;
    do {
      if (hasOwnProperty(dest, symbol3) && dest[symbol3]) return true;
      dest = dest.parentElement;
    } while (dest);
    return false;
  }
  var useCompositeHover = createHook(function useCompositeHover2({ store, focusOnHover = true, blurOnHoverEnd = !!focusOnHover, ...props }) {
    const context = useCompositeScopedContext();
    store = store || context;
    invariant(store, "CompositeHover must be wrapped in a Composite component.");
    const isMouseMoving = useIsMouseMoving();
    const onMouseMoveProp = props.onMouseMove;
    const focusOnHoverProp = useBooleanEvent(focusOnHover);
    const onMouseMove = useEvent((event) => {
      onMouseMoveProp?.(event);
      if (event.defaultPrevented) return;
      if (!isMouseMoving()) return;
      if (!focusOnHoverProp(event)) return;
      if (!hasFocusWithin(event.currentTarget)) {
        const baseElement = store?.getState().baseElement;
        if (baseElement && !hasFocus(baseElement)) baseElement.focus();
      }
      store?.setActiveId(event.currentTarget.id);
    });
    const onMouseLeaveProp = props.onMouseLeave;
    const blurOnHoverEndProp = useBooleanEvent(blurOnHoverEnd);
    const onMouseLeave = useEvent((event) => {
      onMouseLeaveProp?.(event);
      if (event.defaultPrevented) return;
      if (!isMouseMoving()) return;
      if (hoveringInside(event)) return;
      if (movingToAnotherItem(event)) return;
      if (!focusOnHoverProp(event)) return;
      if (!blurOnHoverEndProp(event)) return;
      store?.setActiveId(null);
      store?.getState().baseElement?.focus();
    });
    const ref = (0, import_react39.useCallback)((element) => {
      if (!element) return;
      element[symbol3] = true;
    }, []);
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref),
      onMouseMove,
      onMouseLeave
    };
    return removeUndefinedValues(props);
  });
  var CompositeHover = memo2(forwardRef2(function CompositeHover2(props) {
    return createElement(TagName40, useCompositeHover(props));
  }));

  // node_modules/@ariakit/react-components/dist/select/select-item.js
  var import_react40 = __toESM(require_react(), 1);
  var import_jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
  var TagName41 = "div";
  function isSelected(storeValue, itemValue) {
    if (itemValue == null) return;
    if (storeValue == null) return false;
    if (Array.isArray(storeValue)) return storeValue.includes(itemValue);
    return storeValue === itemValue;
  }
  var useSelectItem = createHook(function useSelectItem2({ store, value, getItem: getItemProp, hideOnClick, setValueOnClick = value != null, preventScrollOnKeyDown = true, focusOnHover = true, ...props }) {
    const context = useSelectScopedContext();
    store = store || context;
    invariant(store, "SelectItem must be wrapped in a SelectList or SelectPopover component.");
    const id3 = useId(props.id);
    const disabled = disabledFromProps(props);
    const { listElement, multiSelectable, selected, autoFocus } = useStoreStateObject(store, {
      listElement: "listElement",
      multiSelectable(state) {
        return Array.isArray(state.value);
      },
      selected(state) {
        return isSelected(state.value, value);
      },
      autoFocus(state) {
        if (value == null) return false;
        if (state.value == null) return false;
        if (state.activeId !== id3 && store?.item(state.activeId)) return false;
        if (Array.isArray(state.value)) return state.value[state.value.length - 1] === value;
        return state.value === value;
      }
    });
    const virtualFocus = useStoreState(store?.combobox, "virtualFocus");
    const getItem = (0, import_react40.useCallback)((item2) => {
      const nextItem = {
        ...item2,
        value: disabled ? void 0 : value
      };
      if (getItemProp) return getItemProp(nextItem);
      return nextItem;
    }, [
      disabled,
      value,
      getItemProp
    ]);
    hideOnClick = hideOnClick ?? (value != null && !multiSelectable);
    const onClickProp = props.onClick;
    const setValueOnClickProp = useBooleanEvent(setValueOnClick);
    const hideOnClickProp = useBooleanEvent(hideOnClick);
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      if (isDownloading(event)) return;
      if (isOpeningInNewTab(event)) return;
      if (setValueOnClickProp(event) && value != null) store?.setValue((prevValue) => {
        if (!Array.isArray(prevValue)) return value;
        if (prevValue.includes(value)) return prevValue.filter((v3) => v3 !== value);
        return [...prevValue, value];
      });
      if (hideOnClickProp(event)) store?.hide();
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(SelectItemCheckedContext.Provider, {
      value: selected ?? false,
      children: element
    }), [selected]);
    const shouldAutoFocus = props.autoFocus ?? autoFocus;
    props = {
      role: getPopupItemRole(listElement),
      "aria-selected": selected,
      children: value,
      ...props,
      id: id3,
      autoFocus: virtualFocus === false ? false : shouldAutoFocus,
      "data-autofocus": shouldAutoFocus || void 0,
      onClick
    };
    props = useCompositeItem({
      store,
      getItem,
      preventScrollOnKeyDown,
      ...props
    });
    const focusOnHoverProp = useBooleanEvent(focusOnHover);
    props = useCompositeHover({
      store,
      ...props,
      focusOnHover(event) {
        if (!focusOnHoverProp(event)) return false;
        return store.getState().open;
      }
    });
    return props;
  });
  var SelectItem = memo2(forwardRef2(function SelectItem2(props) {
    return createElement(TagName41, useSelectItem(props));
  }));

  // node_modules/@ariakit/react-components/dist/checkbox/checkbox-checked-context.js
  var import_react41 = __toESM(require_react(), 1);
  var CheckboxCheckedContext = (0, import_react41.createContext)(false);

  // node_modules/@ariakit/react-components/dist/checkbox/checkbox-check.js
  var import_react42 = __toESM(require_react(), 1);
  var import_jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
  var TagName42 = "span";
  var checkmark = /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("svg", {
    display: "block",
    fill: "none",
    stroke: "currentColor",
    strokeLinecap: "round",
    strokeLinejoin: "round",
    strokeWidth: 1.5,
    viewBox: "0 0 16 16",
    height: "1em",
    width: "1em",
    children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("polyline", { points: "4,8 7,12 12,4" })
  });
  function getChildren(props) {
    if (props.checked) return props.children || checkmark;
    return null;
  }
  var useCheckboxCheck = createHook(function useCheckboxCheck2({ store, checked, ...props }) {
    const context = (0, import_react42.useContext)(CheckboxCheckedContext);
    checked = checked ?? context;
    const children = getChildren({
      checked,
      children: props.children
    });
    props = {
      "aria-hidden": true,
      ...props,
      children,
      style: {
        width: "1em",
        height: "1em",
        pointerEvents: "none",
        ...props.style
      }
    };
    return removeUndefinedValues(props);
  });
  var CheckboxCheck = forwardRef2(function CheckboxCheck2(props) {
    return createElement(TagName42, useCheckboxCheck(props));
  });

  // node_modules/@ariakit/react-components/dist/select/select-item-check.js
  var import_react43 = __toESM(require_react(), 1);
  var TagName43 = "span";
  var useSelectItemCheck = createHook(function useSelectItemCheck2({ store, checked, ...props }) {
    const context = (0, import_react43.useContext)(SelectItemCheckedContext);
    checked = checked ?? context;
    props = useCheckboxCheck({
      ...props,
      checked
    });
    return props;
  });
  var SelectItemCheck = forwardRef2(function SelectItemCheck2(props) {
    return createElement(TagName43, useSelectItemCheck(props));
  });

  // node_modules/@ariakit/react-components/dist/select/select-label.js
  var TagName44 = "div";
  var useSelectLabel = createHook(function useSelectLabel2({ store, ...props }) {
    const context = useSelectProviderContext();
    store = store || context;
    invariant(store, "SelectLabel must receive a `store` prop or be wrapped in a SelectProvider component.");
    const id3 = useId(props.id);
    const onClickProp = props.onClick;
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      queueMicrotask(() => {
        store?.getState().selectElement?.focus();
      });
    });
    props = {
      ...props,
      id: id3,
      ref: useMergeRefs(store.setLabelElement, props.ref),
      onClick,
      style: {
        cursor: "default",
        ...props.style
      }
    };
    return removeUndefinedValues(props);
  });
  var SelectLabel = memo2(forwardRef2(function SelectLabel2(props) {
    return createElement(TagName44, useSelectLabel(props));
  }));

  // node_modules/@ariakit/react-components/dist/select/select-list.js
  var import_react44 = __toESM(require_react(), 1);
  var import_jsx_runtime25 = __toESM(require_jsx_runtime(), 1);
  var TagName45 = "div";
  var SelectListContext = (0, import_react44.createContext)(null);
  var useSelectList = createHook(function useSelectList2({ store, resetOnEscape = true, hideOnEnter = true, composite, alwaysVisible, ...props }) {
    const context = useSelectContext();
    store = store || context;
    invariant(store, "SelectList must receive a `store` prop or be wrapped in a SelectProvider component.");
    const id3 = useId(props.id);
    const value = useStoreState(store, "value");
    const multiSelectable = Array.isArray(value);
    const [defaultValue2, setDefaultValue] = (0, import_react44.useState)(value);
    const mounted = useStoreState(store, "mounted");
    (0, import_react44.useEffect)(() => {
      if (mounted) return;
      setDefaultValue(value);
    }, [mounted, value]);
    resetOnEscape = resetOnEscape && !multiSelectable;
    const onKeyDownProp = props.onKeyDown;
    const resetOnEscapeProp = useBooleanEvent(resetOnEscape);
    const hideOnEnterProp = useBooleanEvent(hideOnEnter);
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (event.defaultPrevented) return;
      if (event.key === "Escape" && resetOnEscapeProp(event)) store?.setValue(defaultValue2);
      if (event.key === " " || event.key === "Enter") {
        if (isSelfTarget(event) && hideOnEnterProp(event)) {
          event.preventDefault();
          store?.hide();
        }
      }
    });
    const headingContext = (0, import_react44.useContext)(SelectHeadingContext);
    const headingState = (0, import_react44.useState)();
    const [headingId, setHeadingId] = headingContext || headingState;
    const headingContextValue = (0, import_react44.useMemo)(() => [headingId, setHeadingId], [headingId, setHeadingId]);
    const [childStore, setChildStore] = (0, import_react44.useState)(null);
    const setStore = (0, import_react44.useContext)(SelectListContext);
    (0, import_react44.useEffect)(() => {
      if (!setStore) return;
      setStore(store);
      return () => setStore(null);
    }, [setStore, store]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(SelectScopedContextProvider, {
      value: store,
      children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(SelectListContext.Provider, {
        value: setChildStore,
        children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(SelectHeadingContext.Provider, {
          value: headingContextValue,
          children: element
        })
      })
    }), [store, headingContextValue]);
    const hasCombobox = !!store.combobox;
    composite = composite ?? (!hasCombobox && childStore !== store);
    const [, setElement] = useTransactionState(composite ? store.setListElement : null);
    const hidden = isHidden(mounted, props.hidden, alwaysVisible);
    const style2 = hidden ? {
      ...props.style,
      display: "none"
    } : props.style;
    if (composite) props = {
      role: "listbox",
      "aria-multiselectable": multiSelectable || void 0,
      ...props
    };
    const labelId = useStoreState(store, (state) => headingId || state.labelElement?.id);
    props = {
      "aria-labelledby": props["aria-label"] != null ? void 0 : labelId,
      hidden,
      ...props,
      id: id3,
      ref: useMergeRefs(setElement, props.ref),
      style: style2,
      onKeyDown
    };
    props = useComposite({
      store,
      ...props,
      composite
    });
    props = useCompositeTypeahead({
      store,
      typeahead: !hasCombobox,
      ...props
    });
    return props;
  });
  var SelectList = forwardRef2(function SelectList2(props) {
    return createElement(TagName45, useSelectList(props));
  });

  // node_modules/@ariakit/react-components/dist/select/select-popover.js
  var TagName46 = "div";
  var useSelectPopover = createHook(function useSelectPopover2({ store, alwaysVisible, ...props }) {
    const context = useSelectProviderContext();
    store = store || context;
    props = useSelectList({
      store,
      alwaysVisible,
      ...props
    });
    props = usePopover({
      store,
      alwaysVisible,
      ...props
    });
    return props;
  });
  var SelectPopover = createDialogComponent(forwardRef2(function SelectPopover2(props) {
    return createElement(TagName46, useSelectPopover(props));
  }), useSelectProviderContext);

  // node_modules/@ariakit/components/dist/select/select-store.js
  function createSelectStore({ combobox, ...props } = {}) {
    const store = mergeStore(props.store, omit2(combobox, [
      "value",
      "items",
      "renderedItems",
      "baseElement",
      "arrowElement",
      "anchorElement",
      "contentElement",
      "popoverElement",
      "disclosureElement"
    ]));
    throwOnConflictingProps(props, store);
    const syncState = store.getState();
    const composite = createCompositeStore({
      ...props,
      store,
      virtualFocus: defaultValue(props.virtualFocus, syncState.virtualFocus, true),
      includesBaseElement: defaultValue(props.includesBaseElement, syncState.includesBaseElement, false),
      activeId: defaultValue(props.activeId, syncState.activeId, props.defaultActiveId, null),
      orientation: defaultValue(props.orientation, syncState.orientation, "vertical")
    });
    const popover = createPopoverStore({
      ...props,
      store,
      placement: defaultValue(props.placement, syncState.placement, "bottom-start")
    });
    const initialValue2 = /* @__PURE__ */ new String("");
    const initialState2 = {
      ...composite.getState(),
      ...popover.getState(),
      value: defaultValue(props.value, syncState.value, props.defaultValue, initialValue2),
      setValueOnMove: defaultValue(props.setValueOnMove, syncState.setValueOnMove, false),
      labelElement: defaultValue(syncState.labelElement, null),
      selectElement: defaultValue(syncState.selectElement, null),
      listElement: defaultValue(syncState.listElement, null)
    };
    const select = createStore(initialState2, composite, popover, store);
    setup(select, () => sync(select, ["value", "items"], (state) => {
      if (state.value !== initialValue2) return;
      if (!state.items.length) return;
      const item2 = state.items.find((item3) => !item3.disabled && item3.value != null);
      if (item2?.value == null) return;
      select.setState("value", item2.value);
    }));
    setup(select, () => sync(select, ["mounted"], (state) => {
      if (state.mounted) return;
      select.setState("activeId", initialState2.activeId);
    }));
    setup(select, () => sync(select, [
      "mounted",
      "items",
      "value"
    ], (state) => {
      if (combobox) return;
      if (state.mounted) return;
      const values = toArray(state.value);
      const lastValue = values[values.length - 1];
      if (lastValue == null) return;
      const item2 = state.items.find((item3) => !item3.disabled && item3.value === lastValue);
      if (!item2) return;
      select.setState("activeId", item2.id);
    }));
    setup(select, () => batch(select, ["setValueOnMove", "moves"], (state) => {
      const { mounted, value, activeId } = select.getState();
      if (!state.setValueOnMove && mounted) return;
      if (Array.isArray(value)) return;
      if (!state.moves) return;
      if (!activeId) return;
      const item2 = composite.item(activeId);
      if (!item2 || item2.disabled || item2.value == null) return;
      select.setState("value", item2.value);
    }));
    return {
      ...composite,
      ...popover,
      ...select,
      combobox,
      setValue: (value) => select.setState("value", value),
      setLabelElement: (element) => select.setState("labelElement", element),
      setSelectElement: (element) => select.setState("selectElement", element),
      setListElement: (element) => select.setState("listElement", element)
    };
  }

  // node_modules/@ariakit/react-components/dist/select/select-store.js
  function useSelectStoreOptions(props) {
    const combobox = useComboboxProviderContext();
    props = {
      ...props,
      combobox: props.combobox !== void 0 ? props.combobox : combobox
    };
    return useCompositeStoreOptions(props);
  }
  function useSelectStoreProps(store, update, props) {
    useUpdateEffect(update, [props.combobox]);
    useStoreProps(store, props, "value", "setValue");
    useStoreProps(store, props, "setValueOnMove");
    return Object.assign(usePopoverStoreProps(useCompositeStoreProps(store, update, props), update, props), { combobox: props.combobox });
  }
  function useSelectStore(props = {}) {
    props = useSelectStoreOptions(props);
    const [store, update] = useStore(createSelectStore, props);
    return useSelectStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/composite/composite-row.js
  var import_react45 = __toESM(require_react(), 1);
  var import_jsx_runtime26 = __toESM(require_jsx_runtime(), 1);
  var TagName47 = "div";
  var useCompositeRow = createHook(function useCompositeRow2({ store, "aria-setsize": ariaSetSize, "aria-posinset": ariaPosInSet, ...props }) {
    const context = useCompositeScopedContext();
    store = store || context;
    invariant(store, "CompositeRow must be wrapped in a Composite component.");
    const id3 = useId(props.id);
    const baseElement = useStoreState(store, (state) => state.baseElement || void 0);
    const providerValue = (0, import_react45.useMemo)(() => ({
      id: id3,
      baseElement,
      ariaSetSize,
      ariaPosInSet
    }), [
      id3,
      baseElement,
      ariaSetSize,
      ariaPosInSet
    ]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(CompositeRowContext.Provider, {
      value: providerValue,
      children: element
    }), [providerValue]);
    props = {
      ...props,
      id: id3
    };
    return removeUndefinedValues(props);
  });
  var CompositeRow = forwardRef2(function CompositeRow2(props) {
    return createElement(TagName47, useCompositeRow(props));
  });

  // node_modules/@ariakit/components/dist/checkbox/checkbox-store.js
  function createCheckboxStore(props = {}) {
    throwOnConflictingProps(props, props.store);
    const syncState = props.store?.getState();
    const checkbox = createStore({ value: defaultValue(props.value, syncState?.value, props.defaultValue, false) }, props.store);
    return {
      ...checkbox,
      setValue: (value) => checkbox.setState("value", value)
    };
  }

  // node_modules/@ariakit/react-components/dist/checkbox/checkbox-store.js
  function useCheckboxStoreProps(store, update, props) {
    useUpdateEffect(update, [props.store]);
    useStoreProps(store, props, "value", "setValue");
    return store;
  }
  function useCheckboxStore(props = {}) {
    const [store, update] = useStore(createCheckboxStore, props);
    return useCheckboxStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/checkbox/checkbox-context.js
  var ctx13 = createStoreContext();
  var useCheckboxContext = ctx13.useContext;
  var useCheckboxScopedContext = ctx13.useScopedContext;
  var useCheckboxProviderContext = ctx13.useProviderContext;
  var CheckboxContextProvider = ctx13.ContextProvider;
  var CheckboxScopedContextProvider = ctx13.ScopedContextProvider;

  // node_modules/@ariakit/react-components/dist/__chunks/Bz1czXRN.js
  var import_react46 = __toESM(require_react(), 1);
  var import_jsx_runtime27 = __toESM(require_jsx_runtime(), 1);
  function getPrimitiveValue(value) {
    if (Array.isArray(value)) return value.toString();
    return value;
  }
  var TagName48 = "input";
  function setMixed(element, mixed) {
    if (mixed) element.indeterminate = true;
    else if (element.indeterminate) element.indeterminate = false;
  }
  function isNativeCheckbox(tagName, type) {
    return tagName === "input" && (!type || type === "checkbox");
  }
  var useCheckbox = createHook(function useCheckbox2({ store, name, value: valueProp, checked: checkedProp, defaultChecked, ...props }) {
    const context = useCheckboxContext();
    store = store || context;
    const [_checked, setChecked] = (0, import_react46.useState)(defaultChecked ?? false);
    const checked = useStoreState(store, (state) => {
      if (checkedProp !== void 0) return checkedProp;
      if (state?.value === void 0) return _checked;
      if (valueProp != null) {
        if (Array.isArray(state.value)) {
          const primitiveValue = getPrimitiveValue(valueProp);
          return state.value.includes(primitiveValue);
        }
        return state.value === valueProp;
      }
      if (Array.isArray(state.value)) return false;
      if (typeof state.value === "boolean") return state.value;
      return false;
    });
    const ref = (0, import_react46.useRef)(null);
    const nativeCheckbox = isNativeCheckbox(useTagName(ref, TagName48), props.type);
    const mixed = checked ? checked === "mixed" : void 0;
    const isChecked = checked === "mixed" ? false : checked;
    const disabled = disabledFromProps(props);
    const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
    (0, import_react46.useEffect)(() => {
      const element = ref.current;
      if (!element) return;
      setMixed(element, mixed);
      if (nativeCheckbox) return;
      element.checked = isChecked;
      if (name !== void 0) element.name = name;
      if (valueProp !== void 0) element.value = String(valueProp);
    }, [
      propertyUpdated,
      mixed,
      nativeCheckbox,
      isChecked,
      name,
      valueProp
    ]);
    const onChangeProp = props.onChange;
    const onChange = useEvent((event) => {
      if (disabled) {
        event.stopPropagation();
        event.preventDefault();
        return;
      }
      setMixed(event.currentTarget, mixed);
      if (!nativeCheckbox) {
        event.currentTarget.checked = !event.currentTarget.checked;
        schedulePropertyUpdate();
      }
      onChangeProp?.(event);
      if (event.defaultPrevented) return;
      const elementChecked = event.currentTarget.checked;
      setChecked(elementChecked);
      store?.setValue((prevValue) => {
        if (valueProp == null) return elementChecked;
        const primitiveValue = getPrimitiveValue(valueProp);
        if (!Array.isArray(prevValue)) return prevValue === primitiveValue ? false : primitiveValue;
        if (elementChecked) {
          if (prevValue.includes(primitiveValue)) return prevValue;
          return [...prevValue, primitiveValue];
        }
        return prevValue.filter((v3) => v3 !== primitiveValue);
      });
    });
    const onClickProp = props.onClick;
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      if (nativeCheckbox) return;
      onChange(event);
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(CheckboxCheckedContext.Provider, {
      value: isChecked,
      children: element
    }), [isChecked]);
    props = {
      role: !nativeCheckbox ? "checkbox" : void 0,
      type: nativeCheckbox ? "checkbox" : void 0,
      "aria-checked": checked,
      ...props,
      ref: useMergeRefs(ref, props.ref),
      onChange,
      onClick
    };
    props = useCommand({
      clickOnEnter: !nativeCheckbox,
      ...props
    });
    return removeUndefinedValues({
      name: nativeCheckbox ? name : void 0,
      value: nativeCheckbox ? valueProp : void 0,
      checked: isChecked,
      ...props
    });
  });
  var Checkbox = forwardRef2(function Checkbox2(props) {
    return createElement(TagName48, useCheckbox(props));
  });

  // node_modules/@ariakit/react-components/dist/menu/menu-context.js
  var import_react47 = __toESM(require_react(), 1);
  var menu = createStoreContext([CompositeContextProvider, HovercardContextProvider], [CompositeScopedContextProvider, HovercardScopedContextProvider]);
  var useMenuContext = menu.useContext;
  var useMenuScopedContext = menu.useScopedContext;
  var useMenuProviderContext = menu.useProviderContext;
  var MenuContextProvider = menu.ContextProvider;
  var MenuScopedContextProvider = menu.ScopedContextProvider;
  var MenuItemCheckedContext = (0, import_react47.createContext)(void 0);
  var MenuListHiddenContext = (0, import_react47.createContext)(false);

  // node_modules/@ariakit/react-components/dist/menu/menu-list.js
  var import_react48 = __toESM(require_react(), 1);
  var import_jsx_runtime28 = __toESM(require_jsx_runtime(), 1);
  var TagName49 = "div";
  function useAriaLabelledBy({ store, ...props }) {
    const [id3, setId] = (0, import_react48.useState)(void 0);
    const label = props["aria-label"];
    const disclosureElement = useStoreState(store, "disclosureElement");
    const contentElement = useStoreState(store, "contentElement");
    (0, import_react48.useEffect)(() => {
      const disclosure = disclosureElement;
      if (!disclosure) return;
      const menu2 = contentElement;
      if (!menu2) return;
      if (label || menu2.hasAttribute("aria-label")) setId(void 0);
      else if (disclosure.id) setId(disclosure.id);
    }, [
      label,
      disclosureElement,
      contentElement
    ]);
    return id3;
  }
  var useMenuList = createHook(function useMenuList2({ store, alwaysVisible, composite, ...props }) {
    const context = useMenuProviderContext();
    store = store || context;
    invariant(store, "MenuList must receive a `store` prop or be wrapped in a MenuProvider component.");
    const parentMenu = store.parent;
    const parentMenubar = store.menubar;
    const hasParentMenu = !!parentMenu;
    const id3 = useId(props.id);
    const onKeyDownProp = props.onKeyDown;
    const dir = useStoreState(store, (state) => getBasePlacement(state.placement));
    const orientation = useStoreState(store, (state) => state.orientation === "both" ? void 0 : state.orientation);
    const isHorizontal = orientation !== "vertical";
    const isMenubarHorizontal = useStoreState(parentMenubar, (state) => !!state && state.orientation !== "vertical");
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (event.defaultPrevented) return;
      if (hasParentMenu || parentMenubar && !isHorizontal) {
        const action = {
          ArrowRight: () => dir === "left" && !isHorizontal,
          ArrowLeft: () => dir === "right" && !isHorizontal,
          ArrowUp: () => dir === "bottom" && isHorizontal,
          ArrowDown: () => dir === "top" && isHorizontal
        }[event.key];
        if (action?.()) {
          event.stopPropagation();
          event.preventDefault();
          return store?.hide();
        }
      }
      if (parentMenubar) {
        const action = {
          ArrowRight: () => {
            if (!isMenubarHorizontal) return;
            return parentMenubar.next();
          },
          ArrowLeft: () => {
            if (!isMenubarHorizontal) return;
            return parentMenubar.previous();
          },
          ArrowDown: () => {
            if (isMenubarHorizontal) return;
            return parentMenubar.next();
          },
          ArrowUp: () => {
            if (isMenubarHorizontal) return;
            return parentMenubar.previous();
          }
        }[event.key];
        const id4 = action?.();
        if (id4 !== void 0) {
          event.stopPropagation();
          event.preventDefault();
          parentMenubar.move(id4);
        }
      }
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(MenuScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    const ariaLabelledBy = useAriaLabelledBy({
      store,
      ...props
    });
    const hidden = isHidden(useStoreState(store, "mounted"), props.hidden, alwaysVisible);
    const style2 = hidden ? {
      ...props.style,
      display: "none"
    } : props.style;
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(MenuListHiddenContext.Provider, {
      value: hidden,
      children: element
    }), [hidden]);
    props = {
      "aria-labelledby": ariaLabelledBy,
      hidden,
      ...props,
      id: id3,
      ref: useMergeRefs(id3 ? store.setContentElement : null, props.ref),
      style: style2,
      onKeyDown
    };
    const hasCombobox = !!store.combobox;
    composite = composite ?? !hasCombobox;
    if (composite) props = {
      role: "menu",
      "aria-orientation": orientation,
      ...props
    };
    props = useComposite({
      store,
      composite,
      ...props
    });
    props = useCompositeTypeahead({
      store,
      typeahead: !hasCombobox,
      ...props
    });
    return props;
  });
  var MenuList = forwardRef2(function MenuList2(props) {
    return createElement(TagName49, useMenuList(props));
  });

  // node_modules/@ariakit/react-components/dist/menu/menu.js
  var import_react49 = __toESM(require_react(), 1);
  var TagName50 = "div";
  var useMenu = createHook(function useMenu2({ store, modal: modalProp = false, portal = modalProp, hideOnEscape = true, autoFocusOnShow = true, hideOnHoverOutside, alwaysVisible, ...props }) {
    const context = useMenuProviderContext();
    store = store || context;
    invariant(store, "Menu must receive a `store` prop or be wrapped in a MenuProvider component.");
    const ref = (0, import_react49.useRef)(null);
    const parentMenu = store.parent;
    const parentMenubar = store.menubar;
    const hasParentMenu = !!parentMenu;
    const parentIsMenubar = !!parentMenubar && !hasParentMenu;
    const modal = hasParentMenu ? false : modalProp;
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref)
    };
    const { "aria-labelledby": ariaLabelledBy, ...menuListProps } = useMenuList({
      store,
      alwaysVisible,
      ...props
    });
    props = menuListProps;
    const [initialFocusRef, setInitialFocusRef] = (0, import_react49.useState)();
    const initialFocusElement = useStoreState(store, (state) => {
      if (!state.autoFocusOnShow) return;
      const isEnabled = (item2) => !item2.disabled && !!item2.element;
      switch (state.initialFocus) {
        case "first":
          return state.renderedItems.find(isEnabled)?.element || null;
        case "last":
          for (let i3 = state.renderedItems.length - 1; i3 >= 0; i3 -= 1) {
            const item2 = state.renderedItems[i3];
            if (item2 && isEnabled(item2)) return item2.element;
          }
          return null;
        default:
          return state.baseElement;
      }
    });
    (0, import_react49.useEffect)(() => {
      let cleaning = false;
      setInitialFocusRef((prevInitialFocusRef) => {
        if (cleaning) return;
        if (modal && prevInitialFocusRef?.current?.isConnected) return prevInitialFocusRef;
        if (initialFocusElement === void 0) return;
        if (initialFocusElement && initialFocusElement === prevInitialFocusRef?.current) return prevInitialFocusRef;
        const ref2 = (0, import_react49.createRef)();
        ref2.current = initialFocusElement;
        return ref2;
      });
      return () => {
        cleaning = true;
      };
    }, [modal, initialFocusElement]);
    const canAutoFocusOnShow = !!initialFocusRef || !!props.initialFocus || modal;
    const autoFocusOnShowProp = autoFocusOnShow === false ? false : canAutoFocusOnShow && autoFocusOnShow;
    const contentElement = useStoreState(store.combobox || store, "contentElement");
    const parentContentElement = useStoreState(parentMenu?.combobox || parentMenu, "contentElement");
    const preserveTabOrderAnchor = (0, import_react49.useMemo)(() => {
      if (!parentContentElement) return;
      if (!contentElement) return;
      const role = contentElement.getAttribute("role");
      const parentRole = parentContentElement.getAttribute("role");
      if ((parentRole === "menu" || parentRole === "menubar") && role === "menu") return;
      return parentContentElement;
    }, [contentElement, parentContentElement]);
    if (preserveTabOrderAnchor !== void 0) props = {
      preserveTabOrderAnchor,
      ...props
    };
    props = useHovercard({
      store,
      alwaysVisible,
      initialFocus: initialFocusRef,
      autoFocusOnShow: autoFocusOnShowProp,
      ...props,
      hideOnEscape(event) {
        if (isFalsyBooleanCallback(hideOnEscape, event)) return false;
        store?.hideAll();
        return true;
      },
      hideOnHoverOutside(event) {
        const disclosureElement = store?.getState().disclosureElement;
        const getHideOnHoverOutside = () => {
          if (typeof hideOnHoverOutside === "function") return hideOnHoverOutside(event);
          if (hideOnHoverOutside != null) return hideOnHoverOutside;
          if (hasParentMenu) return true;
          if (!parentIsMenubar) return false;
          if (!disclosureElement) return true;
          if (hasFocusWithin(disclosureElement)) return false;
          return true;
        };
        if (!getHideOnHoverOutside()) return false;
        if (event.defaultPrevented) return true;
        if (!hasParentMenu) return true;
        if (!disclosureElement) return true;
        fireEvent(disclosureElement, "mouseout", event);
        if (!hasFocusWithin(disclosureElement)) return true;
        requestAnimationFrame(() => {
          if (hasFocusWithin(disclosureElement)) return;
          store?.hide();
        });
        return false;
      },
      modal,
      portal,
      backdrop: hasParentMenu ? false : props.backdrop
    });
    props = {
      "aria-labelledby": ariaLabelledBy,
      ...props
    };
    return props;
  });
  var Menu = createDialogComponent(forwardRef2(function Menu2(props) {
    return createElement(TagName50, useMenu(props));
  }), useMenuProviderContext);

  // node_modules/@ariakit/react-components/dist/menu/menu-button.js
  var import_react50 = __toESM(require_react(), 1);
  var import_jsx_runtime29 = __toESM(require_jsx_runtime(), 1);
  var TagName51 = "button";
  function getInitialFocus(event, dir) {
    return {
      ArrowDown: dir === "bottom" || dir === "top" ? "first" : false,
      ArrowUp: dir === "bottom" || dir === "top" ? "last" : false,
      ArrowRight: dir === "right" ? "first" : false,
      ArrowLeft: dir === "left" ? "first" : false
    }[event.key];
  }
  function hasActiveItem(items, excludeElement) {
    return !!items?.some((item2) => {
      if (!item2.element) return false;
      if (item2.element === excludeElement) return false;
      return item2.element.getAttribute("aria-expanded") === "true";
    });
  }
  var useMenuButton = createHook(function useMenuButton2({ store, focusable, accessibleWhenDisabled, showOnHover, ...props }) {
    const context = useMenuProviderContext();
    store = store || context;
    invariant(store, "MenuButton must receive a `store` prop or be wrapped in a MenuProvider component.");
    const ref = (0, import_react50.useRef)(null);
    const parentMenu = store.parent;
    const parentMenubar = store.menubar;
    const hasParentMenu = !!parentMenu;
    const parentIsMenubar = !!parentMenubar && !hasParentMenu;
    const disabled = disabledFromProps(props);
    const isDisabled = (element) => disabled || disabledFromElement(element);
    const showMenu = () => {
      const trigger = ref.current;
      if (!trigger) return;
      store?.setDisclosureElement(trigger);
      store?.setAnchorElement(trigger);
      store?.show();
    };
    const onFocusProp = props.onFocus;
    const onFocus = useEvent((event) => {
      onFocusProp?.(event);
      if (isDisabled(event.currentTarget)) return;
      if (event.defaultPrevented) return;
      store?.setAutoFocusOnShow(false);
      store?.setActiveId(null);
      if (!parentMenubar) return;
      if (!parentIsMenubar) return;
      const { items } = parentMenubar.getState();
      if (hasActiveItem(items, event.currentTarget)) showMenu();
    });
    const dir = useStoreState(store, (state) => getBasePlacement(state.placement));
    const onKeyDownProp = props.onKeyDown;
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (isDisabled(event.currentTarget)) return;
      if (event.defaultPrevented) return;
      const initialFocus = getInitialFocus(event, dir);
      if (initialFocus) {
        event.preventDefault();
        const { open } = store.getState();
        if (open) {
          const id4 = initialFocus === "last" ? store.last() : store.first();
          store.move(id4);
          return;
        }
        showMenu();
        store?.setAutoFocusOnShow(true);
        store?.setInitialFocus(initialFocus);
      }
    });
    const onClickProp = props.onClick;
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      if (!store) return;
      const isKeyboardClick = !event.detail;
      const { open } = store.getState();
      if (!open || isKeyboardClick) {
        if (!hasParentMenu || isKeyboardClick) store.setAutoFocusOnShow(true);
        store.setInitialFocus(isKeyboardClick ? "first" : "container");
      }
      if (hasParentMenu) showMenu();
    });
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(MenuContextProvider, {
      value: store,
      children: element
    }), [store]);
    if (hasParentMenu) props = {
      ...props,
      render: /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(Role.div, { render: props.render })
    };
    const id3 = useId(props.id);
    const parentContentElement = useStoreState(parentMenu?.combobox || parentMenu, "contentElement");
    props = {
      role: hasParentMenu || parentIsMenubar ? getPopupItemRole(parentContentElement, "menuitem") : void 0,
      "aria-haspopup": getPopupRole(useStoreState(store, "contentElement"), !!store.combobox ? "dialog" : "menu"),
      ...props,
      id: id3,
      ref: useMergeRefs(ref, props.ref),
      onFocus,
      onKeyDown,
      onClick
    };
    props = useHovercardAnchor({
      store,
      focusable,
      accessibleWhenDisabled,
      ...props,
      showOnHover: (event) => {
        const getShowOnHover = () => {
          if (typeof showOnHover === "function") return showOnHover(event);
          if (showOnHover != null) return showOnHover;
          if (hasParentMenu) return true;
          if (!parentMenubar) return false;
          const { items } = parentMenubar.getState();
          return parentIsMenubar && hasActiveItem(items);
        };
        if (!getShowOnHover()) return false;
        const parent = parentIsMenubar ? parentMenubar : parentMenu;
        if (!parent) return true;
        parent.setActiveId(event.currentTarget.id);
        return true;
      }
    });
    props = usePopoverDisclosure({
      store,
      toggleOnClick: !hasParentMenu,
      focusable,
      accessibleWhenDisabled,
      ...props
    });
    props = useCompositeTypeahead({
      store,
      typeahead: parentIsMenubar,
      ...props
    });
    return props;
  });
  var MenuButton = forwardRef2(function MenuButton2(props) {
    return createElement(TagName51, useMenuButton(props));
  });

  // node_modules/@ariakit/react-components/dist/menu/menu-group.js
  var TagName52 = "div";
  var useMenuGroup = createHook(function useMenuGroup2(props) {
    props = useCompositeGroup(props);
    return props;
  });
  var MenuGroup = forwardRef2(function MenuGroup2(props) {
    return createElement(TagName52, useMenuGroup(props));
  });

  // node_modules/@ariakit/react-components/dist/menu/menu-group-label.js
  var TagName53 = "div";
  var useMenuGroupLabel = createHook(function useMenuGroupLabel2(props) {
    props = useCompositeGroupLabel(props);
    return props;
  });
  var MenuGroupLabel = forwardRef2(function MenuGroupLabel2(props) {
    return createElement(TagName53, useMenuGroupLabel(props));
  });

  // node_modules/@ariakit/react-components/dist/menu/menu-item.js
  var import_react51 = __toESM(require_react(), 1);
  var TagName54 = "div";
  function menuHasFocus(baseElement, items, currentTarget) {
    if (!baseElement) return false;
    if (hasFocusWithin(baseElement)) return true;
    const expandedMenuId = items?.find((item2) => {
      if (item2.element === currentTarget) return false;
      return item2.element?.getAttribute("aria-expanded") === "true";
    })?.element?.getAttribute("aria-controls");
    if (!expandedMenuId) return false;
    const expandedMenu = getDocument(baseElement).getElementById(expandedMenuId);
    if (!expandedMenu) return false;
    if (hasFocusWithin(expandedMenu)) return true;
    return !!expandedMenu.querySelector("[role=menuitem][aria-expanded=true]");
  }
  var useMenuItem = createHook(function useMenuItem2({ store, hideOnClick = true, preventScrollOnKeyDown = true, focusOnHover, blurOnHoverEnd, ...props }) {
    const menuContext = useMenuScopedContext(true);
    const menubarContext = useMenubarScopedContext();
    store = store || menuContext || menubarContext;
    invariant(store, "MenuItem must be wrapped in a MenuList, Menu or Menubar component");
    const onClickProp = props.onClick;
    const hideOnClickProp = useBooleanEvent(hideOnClick);
    const hideMenu = "hideAll" in store ? store.hideAll : void 0;
    const isWithinMenu = !!hideMenu;
    const onClick = useEvent((event) => {
      onClickProp?.(event);
      if (event.defaultPrevented) return;
      if (isDownloading(event)) return;
      if (isOpeningInNewTab(event)) return;
      if (!hideMenu) return;
      const popupType = event.currentTarget.getAttribute("aria-haspopup");
      if (popupType && popupType !== "false") return;
      if (!hideOnClickProp(event)) return;
      hideMenu();
    });
    const contentElement = useStoreState(store, (state) => "contentElement" in state ? state.contentElement : null);
    const menuListHidden = (0, import_react51.useContext)(MenuListHiddenContext);
    props = {
      role: getPopupItemRole(contentElement, "menuitem"),
      ...props,
      onClick
    };
    props = useCompositeItem({
      store,
      preventScrollOnKeyDown,
      ...props,
      shouldRegisterItem: menuListHidden ? false : props.shouldRegisterItem
    });
    props = useCompositeHover({
      store,
      ...props,
      focusOnHover(event) {
        const getFocusOnHover = () => {
          if (typeof focusOnHover === "function") return focusOnHover(event);
          if (focusOnHover != null) return focusOnHover;
          return true;
        };
        if (!store) return false;
        if (!getFocusOnHover()) return false;
        const { baseElement, items } = store.getState();
        if (isWithinMenu) {
          if (event.currentTarget.hasAttribute("aria-expanded")) event.currentTarget.focus();
          return true;
        }
        if (menuHasFocus(baseElement, items, event.currentTarget)) {
          event.currentTarget.focus();
          return true;
        }
        return false;
      },
      blurOnHoverEnd(event) {
        if (typeof blurOnHoverEnd === "function") return blurOnHoverEnd(event);
        if (blurOnHoverEnd != null) return blurOnHoverEnd;
        return isWithinMenu;
      }
    });
    return props;
  });
  var MenuItem = memo2(forwardRef2(function MenuItem2(props) {
    return createElement(TagName54, useMenuItem(props));
  }));

  // node_modules/@ariakit/react-components/dist/menu/menu-item-check.js
  var import_react52 = __toESM(require_react(), 1);
  var TagName55 = "span";
  var useMenuItemCheck = createHook(function useMenuItemCheck2({ store, checked, ...props }) {
    const context = (0, import_react52.useContext)(MenuItemCheckedContext);
    checked = checked ?? context;
    props = useCheckboxCheck({
      ...props,
      checked
    });
    return props;
  });
  var MenuItemCheck = forwardRef2(function MenuItemCheck2(props) {
    return createElement(TagName55, useMenuItemCheck(props));
  });

  // node_modules/@ariakit/react-components/dist/menu/menu-item-checkbox.js
  var import_react53 = __toESM(require_react(), 1);
  var TagName56 = "div";
  function getValue(storeValue, value, checked) {
    if (value === void 0) {
      if (Array.isArray(storeValue)) return storeValue;
      return !!checked;
    }
    const primitiveValue = getPrimitiveValue(value);
    if (!Array.isArray(storeValue)) {
      if (checked) return primitiveValue;
      return storeValue === primitiveValue ? false : storeValue;
    }
    if (checked) {
      if (storeValue.includes(primitiveValue)) return storeValue;
      return [...storeValue, primitiveValue];
    }
    return storeValue.filter((v3) => v3 !== primitiveValue);
  }
  var useMenuItemCheckbox = createHook(function useMenuItemCheckbox2({ store, name, value, checked, defaultChecked: defaultCheckedProp, hideOnClick = false, ...props }) {
    const context = useMenuScopedContext();
    store = store || context;
    invariant(store, "MenuItemCheckbox must be wrapped in a MenuList or Menu component");
    const defaultChecked = useInitialValue(defaultCheckedProp);
    (0, import_react53.useEffect)(() => {
      store?.setValue(name, (prevValue = value !== void 0 ? [] : false) => {
        if (!defaultChecked) return prevValue;
        return getValue(prevValue, value, true);
      });
    }, [
      store,
      name,
      value,
      defaultChecked
    ]);
    (0, import_react53.useEffect)(() => {
      if (checked === void 0) return;
      store?.setValue(name, (prevValue) => {
        return getValue(prevValue, value, checked);
      });
    }, [
      store,
      name,
      value,
      checked
    ]);
    const checkboxStore = useCheckboxStore({
      value: useStoreState(store, (state) => state.values[name]),
      setValue(internalValue) {
        store?.setValue(name, () => {
          if (checked === void 0) return internalValue;
          const nextValue = getValue(internalValue, value, checked);
          if (!Array.isArray(nextValue)) return nextValue;
          if (!Array.isArray(internalValue)) return nextValue;
          if (shallowEqual(internalValue, nextValue)) return internalValue;
          return nextValue;
        });
      }
    });
    props = {
      role: "menuitemcheckbox",
      ...props
    };
    props = useCheckbox({
      store: checkboxStore,
      name,
      value,
      checked,
      ...props
    });
    props = useMenuItem({
      store,
      hideOnClick,
      ...props
    });
    return props;
  });
  var MenuItemCheckbox = memo2(forwardRef2(function MenuItemCheckbox2(props) {
    return createElement(TagName56, useMenuItemCheckbox(props));
  }));

  // node_modules/@ariakit/react-components/dist/menu/menu-item-radio.js
  var import_react54 = __toESM(require_react(), 1);
  var import_jsx_runtime30 = __toESM(require_jsx_runtime(), 1);
  var TagName57 = "div";
  function getValue2(prevValue, value, checked) {
    if (checked === void 0) return prevValue;
    if (checked) return value;
    return prevValue === value ? false : prevValue;
  }
  var useMenuItemRadio = createHook(function useMenuItemRadio2({ store, name, value, checked, defaultChecked: defaultCheckedProp, onChange: onChangeProp, hideOnClick = false, ...props }) {
    const context = useMenuScopedContext();
    store = store || context;
    invariant(store, "MenuItemRadio must be wrapped in a MenuList or Menu component");
    const defaultChecked = useInitialValue(defaultCheckedProp);
    (0, import_react54.useEffect)(() => {
      store?.setValue(name, (prevValue = false) => {
        return getValue2(prevValue, value, defaultChecked);
      });
    }, [
      store,
      name,
      value,
      defaultChecked
    ]);
    (0, import_react54.useEffect)(() => {
      if (checked === void 0) return;
      store?.setValue(name, (prevValue) => {
        return getValue2(prevValue, value, checked);
      });
    }, [
      store,
      name,
      value,
      checked
    ]);
    const isChecked = useStoreState(store, (state) => state.values[name] === value);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(MenuItemCheckedContext.Provider, {
      value: isChecked,
      children: element
    }), [isChecked]);
    props = {
      role: "menuitemradio",
      ...props
    };
    props = useRadio({
      name,
      value,
      checked: isChecked,
      onChange(event) {
        onChangeProp?.(event);
        if (event.defaultPrevented) return;
        const element = event.currentTarget;
        store?.setValue(name, (prevValue) => {
          return getValue2(prevValue, value, checked ?? element.checked);
        });
      },
      ...props
    });
    props = useMenuItem({
      store,
      hideOnClick,
      ...props
    });
    return props;
  });
  var MenuItemRadio = memo2(forwardRef2(function MenuItemRadio2(props) {
    return createElement(TagName57, useMenuItemRadio(props));
  }));

  // node_modules/@ariakit/components/dist/menu/menu-store.js
  function createMenuStore({ combobox, parent, menubar: menubar2, ...props } = {}) {
    const parentIsMenubar = !!menubar2 && !parent;
    const store = mergeStore(props.store, pick2(parent, ["values"]), omit2(combobox, [
      "arrowElement",
      "anchorElement",
      "contentElement",
      "popoverElement",
      "disclosureElement"
    ]));
    throwOnConflictingProps(props, store);
    const syncState = store.getState();
    const composite = createCompositeStore({
      ...props,
      store,
      orientation: defaultValue(props.orientation, syncState.orientation, "vertical")
    });
    const hovercard = createHovercardStore({
      ...props,
      store,
      placement: defaultValue(props.placement, syncState.placement, "bottom-start"),
      timeout: defaultValue(props.timeout, syncState.timeout, parentIsMenubar ? 0 : 150),
      hideTimeout: defaultValue(props.hideTimeout, syncState.hideTimeout, 0)
    });
    const menu2 = createStore({
      ...composite.getState(),
      ...hovercard.getState(),
      initialFocus: defaultValue(syncState.initialFocus, "container"),
      values: defaultValue(props.values, syncState.values, props.defaultValues, {})
    }, composite, hovercard, store);
    setup(menu2, () => sync(menu2, ["mounted"], (state) => {
      if (state.mounted) return;
      menu2.setState("activeId", null);
    }));
    setup(menu2, () => sync(parent, ["orientation"], (state) => {
      menu2.setState("placement", state.orientation === "vertical" ? "right-start" : "bottom-start");
    }));
    return {
      ...composite,
      ...hovercard,
      ...menu2,
      combobox,
      parent,
      menubar: menubar2,
      hideAll: () => {
        hovercard.hide();
        parent?.hideAll();
      },
      setInitialFocus: (value) => menu2.setState("initialFocus", value),
      setValues: (values) => menu2.setState("values", values),
      setValue: (name, value) => {
        if (name === "__proto__") return;
        if (name === "constructor") return;
        if (Array.isArray(name)) return;
        menu2.setState("values", (values) => {
          const prevValue = values[name];
          const nextValue = applyState(value, prevValue);
          if (nextValue === prevValue) return values;
          return {
            ...values,
            [name]: nextValue !== void 0 && nextValue
          };
        });
      }
    };
  }

  // node_modules/@ariakit/react-components/dist/menu/menu-store.js
  function useMenuStoreProps(store, update, props) {
    useUpdateEffect(update, [
      props.combobox,
      props.parent,
      props.menubar
    ]);
    useStoreProps(store, props, "values", "setValues");
    return Object.assign(useHovercardStoreProps(useCompositeStoreProps(store, update, props), update, props), {
      combobox: props.combobox,
      parent: props.parent,
      menubar: props.menubar
    });
  }
  function useMenuStore(props = {}) {
    const parent = useMenuContext();
    const menubar2 = useMenubarContext();
    const combobox = useComboboxProviderContext();
    props = {
      ...props,
      parent: props.parent !== void 0 ? props.parent : parent,
      menubar: props.menubar !== void 0 ? props.menubar : menubar2,
      combobox: props.combobox !== void 0 ? props.combobox : combobox
    };
    const [store, update] = useStore(createMenuStore, props);
    return useMenuStoreProps(store, update, props);
  }

  // node_modules/@ariakit/react-components/dist/menu/menu-separator.js
  var TagName58 = "hr";
  var useMenuSeparator = createHook(function useMenuSeparator2({ store, ...props }) {
    const context = useMenuContext();
    store = store || context;
    props = useCompositeSeparator({
      store,
      ...props
    });
    return props;
  });
  var MenuSeparator = forwardRef2(function MenuSeparator2(props) {
    return createElement(TagName58, useMenuSeparator(props));
  });

  // packages/components/build-module/composite/index.mjs
  var import_i18n = __toESM(require_i18n(), 1);
  var import_element8 = __toESM(require_element(), 1);

  // packages/components/build-module/composite/context.mjs
  var import_element = __toESM(require_element(), 1);
  var CompositeContext = (0, import_element.createContext)({});
  CompositeContext.displayName = "CompositeContext";
  var useCompositeContext2 = () => (0, import_element.useContext)(CompositeContext);

  // packages/components/build-module/composite/group.mjs
  var import_element2 = __toESM(require_element(), 1);
  var import_jsx_runtime31 = __toESM(require_jsx_runtime(), 1);
  var CompositeGroup22 = (0, import_element2.forwardRef)(function CompositeGroup3(props, ref) {
    const context = useCompositeContext2();
    const store = props.store ?? context.store;
    return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(CompositeGroup, {
      store,
      ...props,
      ref
    });
  });

  // packages/components/build-module/composite/group-label.mjs
  var import_element3 = __toESM(require_element(), 1);
  var import_jsx_runtime32 = __toESM(require_jsx_runtime(), 1);
  var CompositeGroupLabel22 = (0, import_element3.forwardRef)(function CompositeGroupLabel3(props, ref) {
    const context = useCompositeContext2();
    const store = props.store ?? context.store;
    return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(CompositeGroupLabel, {
      store,
      ...props,
      ref
    });
  });

  // packages/components/build-module/composite/hover.mjs
  var import_element4 = __toESM(require_element(), 1);
  var import_jsx_runtime33 = __toESM(require_jsx_runtime(), 1);
  var CompositeHover22 = (0, import_element4.forwardRef)(function CompositeHover3(props, ref) {
    const context = useCompositeContext2();
    const store = props.store ?? context.store;
    return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(CompositeHover, {
      store,
      ...props,
      ref
    });
  });

  // packages/components/build-module/composite/item.mjs
  var import_element5 = __toESM(require_element(), 1);
  var import_jsx_runtime34 = __toESM(require_jsx_runtime(), 1);
  var CompositeItem22 = (0, import_element5.forwardRef)(function CompositeItem3(props, ref) {
    const context = useCompositeContext2();
    const store = props.store ?? context.store;
    return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(CompositeItem, {
      store,
      ...props,
      ref
    });
  });

  // packages/components/build-module/composite/row.mjs
  var import_element6 = __toESM(require_element(), 1);
  var import_jsx_runtime35 = __toESM(require_jsx_runtime(), 1);
  var CompositeRow22 = (0, import_element6.forwardRef)(function CompositeRow3(props, ref) {
    const context = useCompositeContext2();
    const store = props.store ?? context.store;
    return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(CompositeRow, {
      store,
      ...props,
      ref
    });
  });

  // packages/components/build-module/composite/typeahead.mjs
  var import_element7 = __toESM(require_element(), 1);
  var import_jsx_runtime36 = __toESM(require_jsx_runtime(), 1);
  var CompositeTypeahead22 = (0, import_element7.forwardRef)(function CompositeTypeahead3(props, ref) {
    const context = useCompositeContext2();
    const store = props.store ?? context.store;
    return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(CompositeTypeahead, {
      store,
      ...props,
      ref
    });
  });

  // packages/components/build-module/composite/index.mjs
  var import_jsx_runtime37 = __toESM(require_jsx_runtime(), 1);
  var Composite22 = Object.assign((0, import_element8.forwardRef)(function Composite3({
    // Composite store props
    activeId,
    defaultActiveId,
    setActiveId,
    focusLoop = false,
    focusWrap = false,
    focusShift = false,
    virtualFocus = false,
    orientation = "both",
    rtl: rtl2 = (0, import_i18n.isRTL)(),
    // Composite component props
    children,
    disabled = false,
    // Rest props
    ...props
  }, ref) {
    const storeProp = props.store;
    const internalStore = useCompositeStore({
      activeId,
      defaultActiveId,
      setActiveId,
      focusLoop,
      focusWrap,
      focusShift,
      virtualFocus,
      orientation,
      rtl: rtl2
    });
    const store = storeProp ?? internalStore;
    const contextValue = (0, import_element8.useMemo)(() => ({
      store
    }), [store]);
    return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(Composite, {
      disabled,
      store,
      ...props,
      ref,
      children: /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(CompositeContext.Provider, {
        value: contextValue,
        children
      })
    });
  }), {
    /**
     * Renders a group element for composite items.
     *
     * @example
     * ```jsx
     * import { Composite } from '@wordpress/components';
     *
     * <Composite>
     *   <Composite.Group>
     *     <Composite.GroupLabel>Label</Composite.GroupLabel>
     *     <Composite.Item>Item 1</Composite.Item>
     *     <Composite.Item>Item 2</Composite.Item>
     *   </CompositeGroup>
     * </Composite>
     * ```
     */
    Group: Object.assign(CompositeGroup22, {
      displayName: "Composite.Group"
    }),
    /**
     * Renders a label in a composite group. This component must be wrapped with
     * `Composite.Group` so the `aria-labelledby` prop is properly set on the
     * composite group element.
     *
     * @example
     * ```jsx
     * import { Composite } from '@wordpress/components';
     *
     * <Composite>
     *   <Composite.Group>
     *     <Composite.GroupLabel>Label</Composite.GroupLabel>
     *     <Composite.Item>Item 1</Composite.Item>
     *     <Composite.Item>Item 2</Composite.Item>
     *   </CompositeGroup>
     * </Composite>
     * ```
     */
    GroupLabel: Object.assign(CompositeGroupLabel22, {
      displayName: "Composite.GroupLabel"
    }),
    /**
     * Renders a composite item.
     *
     * @example
     * ```jsx
     * import { Composite } from '@wordpress/components';
     *
     * <Composite>
     *   <Composite.Item>Item 1</Composite.Item>
     *   <Composite.Item>Item 2</Composite.Item>
     *   <Composite.Item>Item 3</Composite.Item>
     * </Composite>
     * ```
     */
    Item: Object.assign(CompositeItem22, {
      displayName: "Composite.Item"
    }),
    /**
     * Renders a composite row. Wrapping `Composite.Item` elements within
     * `Composite.Row` will create a two-dimensional composite widget, such as a
     * grid.
     *
     * @example
     * ```jsx
     * import { Composite } from '@wordpress/components';
     *
     * <Composite>
     *   <Composite.Row>
     *     <Composite.Item>Item 1.1</Composite.Item>
     *     <Composite.Item>Item 1.2</Composite.Item>
     *     <Composite.Item>Item 1.3</Composite.Item>
     *   </Composite.Row>
     *   <Composite.Row>
     *     <Composite.Item>Item 2.1</Composite.Item>
     *     <Composite.Item>Item 2.2</Composite.Item>
     *     <Composite.Item>Item 2.3</Composite.Item>
     *   </Composite.Row>
     * </Composite>
     * ```
     */
    Row: Object.assign(CompositeRow22, {
      displayName: "Composite.Row"
    }),
    /**
     * Renders an element in a composite widget that receives focus on mouse move
     * and loses focus to the composite base element on mouse leave. This should
     * be combined with the `Composite.Item` component.
     *
     * @example
     * ```jsx
     * import { Composite } from '@wordpress/components';
     *
     * <Composite>
     *   <Composite.Hover render={ <Composite.Item /> }>
     *     Item 1
     *   </Composite.Hover>
     *   <Composite.Hover render={ <Composite.Item /> }>
     *     Item 2
     *   </Composite.Hover>
     * </Composite>
     * ```
     */
    Hover: Object.assign(CompositeHover22, {
      displayName: "Composite.Hover"
    }),
    /**
     * Renders a component that adds typeahead functionality to composite
     * components. Hitting printable character keys will move focus to the next
     * composite item that begins with the input characters.
     *
     * @example
     * ```jsx
     * import { Composite } from '@wordpress/components';
     *
     * <Composite render={ <CompositeTypeahead /> }>
     *   <Composite.Item>Item 1</Composite.Item>
     *   <Composite.Item>Item 2</Composite.Item>
     * </Composite>
     * ```
     */
    Typeahead: Object.assign(CompositeTypeahead22, {
      displayName: "Composite.Typeahead"
    }),
    /**
     * The React context used by the composite components. It can be used by
     * to access the composite store, and to forward the context when composite
     * sub-components are rendered across portals (ie. `SlotFill` components)
     * that would not otherwise forward the context to the `Fill` children.
     *
     * @example
     * ```jsx
     * import { Composite } from '@wordpress/components';
     * import { useContext } from '@wordpress/element';
     *
     * const compositeContext = useContext( Composite.Context );
     * ```
     */
    Context: Object.assign(CompositeContext, {
      displayName: "Composite.Context"
    })
  });

  // packages/components/build-module/tooltip/index.mjs
  var import_compose = __toESM(require_compose(), 1);
  var import_element14 = __toESM(require_element(), 1);
  var import_deprecated = __toESM(require_deprecated(), 1);

  // packages/components/build-module/shortcut/index.mjs
  var import_jsx_runtime38 = __toESM(require_jsx_runtime(), 1);
  function Shortcut(props) {
    const {
      shortcut,
      className: className2
    } = props;
    if (!shortcut) {
      return null;
    }
    let displayText;
    let ariaLabel;
    if (typeof shortcut === "string") {
      displayText = shortcut;
    }
    if (shortcut !== null && typeof shortcut === "object") {
      displayText = shortcut.display;
      ariaLabel = shortcut.ariaLabel;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("span", {
      className: className2,
      "aria-label": ariaLabel,
      children: displayText
    });
  }
  var shortcut_default = Shortcut;

  // packages/components/node_modules/framer-motion/dist/es/utils/warn-once.mjs
  var warned = /* @__PURE__ */ new Set();
  function warnOnce(condition, message2, element) {
    if (condition || warned.has(message2))
      return;
    console.warn(message2);
    if (element)
      console.warn(element);
    warned.add(message2);
  }

  // packages/components/node_modules/framer-motion/dist/es/render/components/create-proxy.mjs
  function createDOMMotionComponentProxy(componentFactory) {
    if (typeof Proxy === "undefined") {
      return componentFactory;
    }
    const componentCache = /* @__PURE__ */ new Map();
    const deprecatedFactoryFunction = (...args) => {
      if (true) {
        warnOnce(false, "motion() is deprecated. Use motion.create() instead.");
      }
      return componentFactory(...args);
    };
    return new Proxy(deprecatedFactoryFunction, {
      /**
       * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
       * The prop name is passed through as `key` and we can use that to generate a `motion`
       * DOM component with that name.
       */
      get: (_target, key) => {
        if (key === "create")
          return componentFactory;
        if (!componentCache.has(key)) {
          componentCache.set(key, componentFactory(key));
        }
        return componentCache.get(key);
      }
    });
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs
  function isAnimationControls(v3) {
    return v3 !== null && typeof v3 === "object" && typeof v3.start === "function";
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs
  var isKeyframesTarget = (v3) => {
    return Array.isArray(v3);
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/shallow-compare.mjs
  function shallowCompare(next2, prev2) {
    if (!Array.isArray(prev2))
      return false;
    const prevLength = prev2.length;
    if (prevLength !== next2.length)
      return false;
    for (let i3 = 0; i3 < prevLength; i3++) {
      if (prev2[i3] !== next2[i3])
        return false;
    }
    return true;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/is-variant-label.mjs
  function isVariantLabel(v3) {
    return typeof v3 === "string" || Array.isArray(v3);
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/resolve-variants.mjs
  function getValueState(visualElement) {
    const state = [{}, {}];
    visualElement === null || visualElement === void 0 ? void 0 : visualElement.values.forEach((value, key) => {
      state[0][key] = value.get();
      state[1][key] = value.getVelocity();
    });
    return state;
  }
  function resolveVariantFromProps(props, definition, custom, visualElement) {
    if (typeof definition === "function") {
      const [current, velocity] = getValueState(visualElement);
      definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
    }
    if (typeof definition === "string") {
      definition = props.variants && props.variants[definition];
    }
    if (typeof definition === "function") {
      const [current, velocity] = getValueState(visualElement);
      definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
    }
    return definition;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs
  function resolveVariant(visualElement, definition, custom) {
    const props = visualElement.getProps();
    return resolveVariantFromProps(props, definition, custom !== void 0 ? custom : props.custom, visualElement);
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/variant-props.mjs
  var variantPriorityOrder = [
    "animate",
    "whileInView",
    "whileFocus",
    "whileHover",
    "whileTap",
    "whileDrag",
    "exit"
  ];
  var variantProps = ["initial", ...variantPriorityOrder];

  // packages/components/node_modules/framer-motion/dist/es/render/html/utils/transform.mjs
  var transformPropOrder = [
    "transformPerspective",
    "x",
    "y",
    "z",
    "translateX",
    "translateY",
    "translateZ",
    "scale",
    "scaleX",
    "scaleY",
    "rotate",
    "rotateX",
    "rotateY",
    "rotateZ",
    "skew",
    "skewX",
    "skewY"
  ];
  var transformProps = new Set(transformPropOrder);

  // packages/components/node_modules/framer-motion/dist/es/utils/time-conversion.mjs
  var secondsToMilliseconds = (seconds) => seconds * 1e3;
  var millisecondsToSeconds = (milliseconds) => milliseconds / 1e3;

  // packages/components/node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs
  var underDampedSpring = {
    type: "spring",
    stiffness: 500,
    damping: 25,
    restSpeed: 10
  };
  var criticallyDampedSpring = (target) => ({
    type: "spring",
    stiffness: 550,
    damping: target === 0 ? 2 * Math.sqrt(550) : 30,
    restSpeed: 10
  });
  var keyframesTransition = {
    type: "keyframes",
    duration: 0.8
  };
  var ease = {
    type: "keyframes",
    ease: [0.25, 0.1, 0.35, 1],
    duration: 0.3
  };
  var getDefaultTransition = (valueKey, { keyframes: keyframes4 }) => {
    if (keyframes4.length > 2) {
      return keyframesTransition;
    } else if (transformProps.has(valueKey)) {
      return valueKey.startsWith("scale") ? criticallyDampedSpring(keyframes4[1]) : underDampedSpring;
    }
    return ease;
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/utils/get-value-transition.mjs
  function getValueTransition(transition, key) {
    return transition ? transition[key] || transition["default"] || transition : void 0;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/GlobalConfig.mjs
  var MotionGlobalConfig = {
    skipAnimations: false,
    useManualTiming: false
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs
  var instantAnimationState = {
    current: false
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs
  var isNotNull = (value) => value !== null;
  function getFinalKeyframe(keyframes4, { repeat, repeatType = "loop" }, finalKeyframe) {
    const resolvedKeyframes = keyframes4.filter(isNotNull);
    const index2 = repeat && repeatType !== "loop" && repeat % 2 === 1 ? 0 : resolvedKeyframes.length - 1;
    return !index2 || finalKeyframe === void 0 ? resolvedKeyframes[index2] : finalKeyframe;
  }

  // node_modules/motion-utils/dist/es/noop.mjs
  var noop2 = (any) => any;

  // node_modules/motion-utils/dist/es/errors.mjs
  var warning = noop2;
  var invariant2 = noop2;
  if (true) {
    warning = (check, message2) => {
      if (!check && typeof console !== "undefined") {
        console.warn(message2);
      }
    };
    invariant2 = (check, message2) => {
      if (!check) {
        throw new Error(message2);
      }
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/frameloop/render-step.mjs
  function createRenderStep(runNextFrame) {
    let thisFrame = /* @__PURE__ */ new Set();
    let nextFrame = /* @__PURE__ */ new Set();
    let isProcessing = false;
    let flushNextFrame = false;
    const toKeepAlive = /* @__PURE__ */ new WeakSet();
    let latestFrameData = {
      delta: 0,
      timestamp: 0,
      isProcessing: false
    };
    function triggerCallback(callback) {
      if (toKeepAlive.has(callback)) {
        step.schedule(callback);
        runNextFrame();
      }
      callback(latestFrameData);
    }
    const step = {
      /**
       * Schedule a process to run on the next frame.
       */
      schedule: (callback, keepAlive = false, immediate = false) => {
        const addToCurrentFrame = immediate && isProcessing;
        const queue = addToCurrentFrame ? thisFrame : nextFrame;
        if (keepAlive)
          toKeepAlive.add(callback);
        if (!queue.has(callback))
          queue.add(callback);
        return callback;
      },
      /**
       * Cancel the provided callback from running on the next frame.
       */
      cancel: (callback) => {
        nextFrame.delete(callback);
        toKeepAlive.delete(callback);
      },
      /**
       * Execute all schedule callbacks.
       */
      process: (frameData2) => {
        latestFrameData = frameData2;
        if (isProcessing) {
          flushNextFrame = true;
          return;
        }
        isProcessing = true;
        [thisFrame, nextFrame] = [nextFrame, thisFrame];
        thisFrame.forEach(triggerCallback);
        thisFrame.clear();
        isProcessing = false;
        if (flushNextFrame) {
          flushNextFrame = false;
          step.process(frameData2);
        }
      }
    };
    return step;
  }

  // packages/components/node_modules/framer-motion/dist/es/frameloop/batcher.mjs
  var stepsOrder = [
    "read",
    // Read
    "resolveKeyframes",
    // Write/Read/Write/Read
    "update",
    // Compute
    "preRender",
    // Compute
    "render",
    // Write
    "postRender"
    // Compute
  ];
  var maxElapsed = 40;
  function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
    let runNextFrame = false;
    let useDefaultElapsed = true;
    const state = {
      delta: 0,
      timestamp: 0,
      isProcessing: false
    };
    const flagRunNextFrame = () => runNextFrame = true;
    const steps = stepsOrder.reduce((acc, key) => {
      acc[key] = createRenderStep(flagRunNextFrame);
      return acc;
    }, {});
    const { read, resolveKeyframes, update, preRender, render, postRender } = steps;
    const processBatch = () => {
      const timestamp = MotionGlobalConfig.useManualTiming ? state.timestamp : performance.now();
      runNextFrame = false;
      state.delta = useDefaultElapsed ? 1e3 / 60 : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
      state.timestamp = timestamp;
      state.isProcessing = true;
      read.process(state);
      resolveKeyframes.process(state);
      update.process(state);
      preRender.process(state);
      render.process(state);
      postRender.process(state);
      state.isProcessing = false;
      if (runNextFrame && allowKeepAlive) {
        useDefaultElapsed = false;
        scheduleNextBatch(processBatch);
      }
    };
    const wake = () => {
      runNextFrame = true;
      useDefaultElapsed = true;
      if (!state.isProcessing) {
        scheduleNextBatch(processBatch);
      }
    };
    const schedule = stepsOrder.reduce((acc, key) => {
      const step = steps[key];
      acc[key] = (process2, keepAlive = false, immediate = false) => {
        if (!runNextFrame)
          wake();
        return step.schedule(process2, keepAlive, immediate);
      };
      return acc;
    }, {});
    const cancel = (process2) => {
      for (let i3 = 0; i3 < stepsOrder.length; i3++) {
        steps[stepsOrder[i3]].cancel(process2);
      }
    };
    return { schedule, cancel, state, steps };
  }

  // packages/components/node_modules/framer-motion/dist/es/frameloop/frame.mjs
  var { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop2, true);

  // packages/components/node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs
  var calcBezier = (t4, a1, a22) => (((1 - 3 * a22 + 3 * a1) * t4 + (3 * a22 - 6 * a1)) * t4 + 3 * a1) * t4;
  var subdivisionPrecision = 1e-7;
  var subdivisionMaxIterations = 12;
  function binarySubdivide(x2, lowerBound, upperBound, mX1, mX2) {
    let currentX;
    let currentT;
    let i3 = 0;
    do {
      currentT = lowerBound + (upperBound - lowerBound) / 2;
      currentX = calcBezier(currentT, mX1, mX2) - x2;
      if (currentX > 0) {
        upperBound = currentT;
      } else {
        lowerBound = currentT;
      }
    } while (Math.abs(currentX) > subdivisionPrecision && ++i3 < subdivisionMaxIterations);
    return currentT;
  }
  function cubicBezier(mX1, mY1, mX2, mY2) {
    if (mX1 === mY1 && mX2 === mY2)
      return noop2;
    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);
    return (t4) => t4 === 0 || t4 === 1 ? t4 : calcBezier(getTForX(t4), mY1, mY2);
  }

  // packages/components/node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs
  var mirrorEasing = (easing) => (p3) => p3 <= 0.5 ? easing(2 * p3) / 2 : (2 - easing(2 * (1 - p3))) / 2;

  // packages/components/node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs
  var reverseEasing = (easing) => (p3) => 1 - easing(1 - p3);

  // packages/components/node_modules/framer-motion/dist/es/easing/back.mjs
  var backOut = /* @__PURE__ */ cubicBezier(0.33, 1.53, 0.69, 0.99);
  var backIn = /* @__PURE__ */ reverseEasing(backOut);
  var backInOut = /* @__PURE__ */ mirrorEasing(backIn);

  // packages/components/node_modules/framer-motion/dist/es/easing/anticipate.mjs
  var anticipate = (p3) => (p3 *= 2) < 1 ? 0.5 * backIn(p3) : 0.5 * (2 - Math.pow(2, -10 * (p3 - 1)));

  // packages/components/node_modules/framer-motion/dist/es/easing/circ.mjs
  var circIn = (p3) => 1 - Math.sin(Math.acos(p3));
  var circOut = reverseEasing(circIn);
  var circInOut = mirrorEasing(circIn);

  // packages/components/node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs
  var isZeroValueString = (v3) => /^0[^.\s]+$/u.test(v3);

  // packages/components/node_modules/framer-motion/dist/es/animation/utils/is-none.mjs
  function isNone(value) {
    if (typeof value === "number") {
      return value === 0;
    } else if (value !== null) {
      return value === "none" || value === "0" || isZeroValueString(value);
    } else {
      return true;
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs
  var isNumericalString = (v3) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(v3);

  // packages/components/node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs
  var checkStringStartsWith = (token2) => (key) => typeof key === "string" && key.startsWith(token2);
  var isCSSVariableName = /* @__PURE__ */ checkStringStartsWith("--");
  var startsAsVariableToken = /* @__PURE__ */ checkStringStartsWith("var(--");
  var isCSSVariableToken = (value) => {
    const startsWithToken = startsAsVariableToken(value);
    if (!startsWithToken)
      return false;
    return singleCssVariableRegex.test(value.split("/*")[0].trim());
  };
  var singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;

  // packages/components/node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs
  var splitCSSVariableRegex = (
    // eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
    /^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u
  );
  function parseCSSVariable(current) {
    const match4 = splitCSSVariableRegex.exec(current);
    if (!match4)
      return [,];
    const [, token1, token2, fallback] = match4;
    return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, fallback];
  }
  var maxDepth = 4;
  function getVariableValue(current, element, depth = 1) {
    invariant2(depth <= maxDepth, `Max CSS variable fallback depth detected in property "${current}". This may indicate a circular fallback dependency.`);
    const [token2, fallback] = parseCSSVariable(current);
    if (!token2)
      return;
    const resolved = window.getComputedStyle(element).getPropertyValue(token2);
    if (resolved) {
      const trimmed = resolved.trim();
      return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;
    }
    return isCSSVariableToken(fallback) ? getVariableValue(fallback, element, depth + 1) : fallback;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/clamp.mjs
  var clamp2 = (min3, max3, v3) => {
    if (v3 > max3)
      return max3;
    if (v3 < min3)
      return min3;
    return v3;
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/numbers/index.mjs
  var number = {
    test: (v3) => typeof v3 === "number",
    parse: parseFloat,
    transform: (v3) => v3
  };
  var alpha = {
    ...number,
    transform: (v3) => clamp2(0, 1, v3)
  };
  var scale = {
    ...number,
    default: 1
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/numbers/units.mjs
  var createUnitType = (unit) => ({
    test: (v3) => typeof v3 === "string" && v3.endsWith(unit) && v3.split(" ").length === 1,
    parse: parseFloat,
    transform: (v3) => `${v3}${unit}`
  });
  var degrees = /* @__PURE__ */ createUnitType("deg");
  var percent = /* @__PURE__ */ createUnitType("%");
  var px = /* @__PURE__ */ createUnitType("px");
  var vh = /* @__PURE__ */ createUnitType("vh");
  var vw = /* @__PURE__ */ createUnitType("vw");
  var progressPercentage = {
    ...percent,
    parse: (v3) => percent.parse(v3) / 100,
    transform: (v3) => percent.transform(v3 * 100)
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs
  var positionalKeys = /* @__PURE__ */ new Set([
    "width",
    "height",
    "top",
    "left",
    "right",
    "bottom",
    "x",
    "y",
    "translateX",
    "translateY"
  ]);
  var isNumOrPxType = (v3) => v3 === number || v3 === px;
  var getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(", ")[pos]);
  var getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {
    if (transform === "none" || !transform)
      return 0;
    const matrix3d = transform.match(/^matrix3d\((.+)\)$/u);
    if (matrix3d) {
      return getPosFromMatrix(matrix3d[1], pos3);
    } else {
      const matrix = transform.match(/^matrix\((.+)\)$/u);
      if (matrix) {
        return getPosFromMatrix(matrix[1], pos2);
      } else {
        return 0;
      }
    }
  };
  var transformKeys = /* @__PURE__ */ new Set(["x", "y", "z"]);
  var nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));
  function removeNonTranslationalTransform(visualElement) {
    const removedTransforms = [];
    nonTranslationalTransformKeys.forEach((key) => {
      const value = visualElement.getValue(key);
      if (value !== void 0) {
        removedTransforms.push([key, value.get()]);
        value.set(key.startsWith("scale") ? 1 : 0);
      }
    });
    return removedTransforms;
  }
  var positionalValues = {
    // Dimensions
    width: ({ x: x2 }, { paddingLeft = "0", paddingRight = "0" }) => x2.max - x2.min - parseFloat(paddingLeft) - parseFloat(paddingRight),
    height: ({ y: y3 }, { paddingTop = "0", paddingBottom = "0" }) => y3.max - y3.min - parseFloat(paddingTop) - parseFloat(paddingBottom),
    top: (_bbox, { top }) => parseFloat(top),
    left: (_bbox, { left }) => parseFloat(left),
    bottom: ({ y: y3 }, { top }) => parseFloat(top) + (y3.max - y3.min),
    right: ({ x: x2 }, { left }) => parseFloat(left) + (x2.max - x2.min),
    // Transform
    x: getTranslateFromMatrix(4, 13),
    y: getTranslateFromMatrix(5, 14)
  };
  positionalValues.translateX = positionalValues.x;
  positionalValues.translateY = positionalValues.y;

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs
  var testValueType = (v3) => (type) => type.test(v3);

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs
  var auto = {
    test: (v3) => v3 === "auto",
    parse: (v3) => v3
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs
  var dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];
  var findDimensionValueType = (v3) => dimensionValueTypes.find(testValueType(v3));

  // packages/components/node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs
  var toResolve = /* @__PURE__ */ new Set();
  var isScheduled = false;
  var anyNeedsMeasurement = false;
  function measureAllKeyframes() {
    if (anyNeedsMeasurement) {
      const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);
      const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));
      const transformsToRestore = /* @__PURE__ */ new Map();
      elementsToMeasure.forEach((element) => {
        const removedTransforms = removeNonTranslationalTransform(element);
        if (!removedTransforms.length)
          return;
        transformsToRestore.set(element, removedTransforms);
        element.render();
      });
      resolversToMeasure.forEach((resolver) => resolver.measureInitialState());
      elementsToMeasure.forEach((element) => {
        element.render();
        const restore = transformsToRestore.get(element);
        if (restore) {
          restore.forEach(([key, value]) => {
            var _a;
            (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);
          });
        }
      });
      resolversToMeasure.forEach((resolver) => resolver.measureEndState());
      resolversToMeasure.forEach((resolver) => {
        if (resolver.suspendedScrollY !== void 0) {
          window.scrollTo(0, resolver.suspendedScrollY);
        }
      });
    }
    anyNeedsMeasurement = false;
    isScheduled = false;
    toResolve.forEach((resolver) => resolver.complete());
    toResolve.clear();
  }
  function readAllKeyframes() {
    toResolve.forEach((resolver) => {
      resolver.readKeyframes();
      if (resolver.needsMeasurement) {
        anyNeedsMeasurement = true;
      }
    });
  }
  function flushKeyframeResolvers() {
    readAllKeyframes();
    measureAllKeyframes();
  }
  var KeyframeResolver = class {
    constructor(unresolvedKeyframes, onComplete, name, motionValue2, element, isAsync = false) {
      this.isComplete = false;
      this.isAsync = false;
      this.needsMeasurement = false;
      this.isScheduled = false;
      this.unresolvedKeyframes = [...unresolvedKeyframes];
      this.onComplete = onComplete;
      this.name = name;
      this.motionValue = motionValue2;
      this.element = element;
      this.isAsync = isAsync;
    }
    scheduleResolve() {
      this.isScheduled = true;
      if (this.isAsync) {
        toResolve.add(this);
        if (!isScheduled) {
          isScheduled = true;
          frame.read(readAllKeyframes);
          frame.resolveKeyframes(measureAllKeyframes);
        }
      } else {
        this.readKeyframes();
        this.complete();
      }
    }
    readKeyframes() {
      const { unresolvedKeyframes, name, element, motionValue: motionValue2 } = this;
      for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
        if (unresolvedKeyframes[i3] === null) {
          if (i3 === 0) {
            const currentValue = motionValue2 === null || motionValue2 === void 0 ? void 0 : motionValue2.get();
            const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
            if (currentValue !== void 0) {
              unresolvedKeyframes[0] = currentValue;
            } else if (element && name) {
              const valueAsRead = element.readValue(name, finalKeyframe);
              if (valueAsRead !== void 0 && valueAsRead !== null) {
                unresolvedKeyframes[0] = valueAsRead;
              }
            }
            if (unresolvedKeyframes[0] === void 0) {
              unresolvedKeyframes[0] = finalKeyframe;
            }
            if (motionValue2 && currentValue === void 0) {
              motionValue2.set(unresolvedKeyframes[0]);
            }
          } else {
            unresolvedKeyframes[i3] = unresolvedKeyframes[i3 - 1];
          }
        }
      }
    }
    setFinalKeyframe() {
    }
    measureInitialState() {
    }
    renderEndStyles() {
    }
    measureEndState() {
    }
    complete() {
      this.isComplete = true;
      this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);
      toResolve.delete(this);
    }
    cancel() {
      if (!this.isComplete) {
        this.isScheduled = false;
        toResolve.delete(this);
      }
    }
    resume() {
      if (!this.isComplete)
        this.scheduleResolve();
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/utils/sanitize.mjs
  var sanitize = (v3) => Math.round(v3 * 1e5) / 1e5;

  // packages/components/node_modules/framer-motion/dist/es/value/types/utils/float-regex.mjs
  var floatRegex = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;

  // packages/components/node_modules/framer-motion/dist/es/value/types/utils/is-nullish.mjs
  function isNullish(v3) {
    return v3 == null;
  }

  // packages/components/node_modules/framer-motion/dist/es/value/types/utils/single-color-regex.mjs
  var singleColorRegex = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu;

  // packages/components/node_modules/framer-motion/dist/es/value/types/color/utils.mjs
  var isColorString = (type, testProp) => (v3) => {
    return Boolean(typeof v3 === "string" && singleColorRegex.test(v3) && v3.startsWith(type) || testProp && !isNullish(v3) && Object.prototype.hasOwnProperty.call(v3, testProp));
  };
  var splitColor = (aName, bName, cName) => (v3) => {
    if (typeof v3 !== "string")
      return v3;
    const [a3, b3, c3, alpha2] = v3.match(floatRegex);
    return {
      [aName]: parseFloat(a3),
      [bName]: parseFloat(b3),
      [cName]: parseFloat(c3),
      alpha: alpha2 !== void 0 ? parseFloat(alpha2) : 1
    };
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/color/rgba.mjs
  var clampRgbUnit = (v3) => clamp2(0, 255, v3);
  var rgbUnit = {
    ...number,
    transform: (v3) => Math.round(clampRgbUnit(v3))
  };
  var rgba = {
    test: /* @__PURE__ */ isColorString("rgb", "red"),
    parse: /* @__PURE__ */ splitColor("red", "green", "blue"),
    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => "rgba(" + rgbUnit.transform(red) + ", " + rgbUnit.transform(green) + ", " + rgbUnit.transform(blue) + ", " + sanitize(alpha.transform(alpha$1)) + ")"
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/color/hex.mjs
  function parseHex(v3) {
    let r4 = "";
    let g3 = "";
    let b3 = "";
    let a3 = "";
    if (v3.length > 5) {
      r4 = v3.substring(1, 3);
      g3 = v3.substring(3, 5);
      b3 = v3.substring(5, 7);
      a3 = v3.substring(7, 9);
    } else {
      r4 = v3.substring(1, 2);
      g3 = v3.substring(2, 3);
      b3 = v3.substring(3, 4);
      a3 = v3.substring(4, 5);
      r4 += r4;
      g3 += g3;
      b3 += b3;
      a3 += a3;
    }
    return {
      red: parseInt(r4, 16),
      green: parseInt(g3, 16),
      blue: parseInt(b3, 16),
      alpha: a3 ? parseInt(a3, 16) / 255 : 1
    };
  }
  var hex = {
    test: /* @__PURE__ */ isColorString("#"),
    parse: parseHex,
    transform: rgba.transform
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/color/hsla.mjs
  var hsla = {
    test: /* @__PURE__ */ isColorString("hsl", "hue"),
    parse: /* @__PURE__ */ splitColor("hue", "saturation", "lightness"),
    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {
      return "hsla(" + Math.round(hue) + ", " + percent.transform(sanitize(saturation)) + ", " + percent.transform(sanitize(lightness)) + ", " + sanitize(alpha.transform(alpha$1)) + ")";
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/color/index.mjs
  var color = {
    test: (v3) => rgba.test(v3) || hex.test(v3) || hsla.test(v3),
    parse: (v3) => {
      if (rgba.test(v3)) {
        return rgba.parse(v3);
      } else if (hsla.test(v3)) {
        return hsla.parse(v3);
      } else {
        return hex.parse(v3);
      }
    },
    transform: (v3) => {
      return typeof v3 === "string" ? v3 : v3.hasOwnProperty("red") ? rgba.transform(v3) : hsla.transform(v3);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/utils/color-regex.mjs
  var colorRegex = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;

  // packages/components/node_modules/framer-motion/dist/es/value/types/complex/index.mjs
  function test(v3) {
    var _a, _b;
    return isNaN(v3) && typeof v3 === "string" && (((_a = v3.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) + (((_b = v3.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) > 0;
  }
  var NUMBER_TOKEN = "number";
  var COLOR_TOKEN = "color";
  var VAR_TOKEN = "var";
  var VAR_FUNCTION_TOKEN = "var(";
  var SPLIT_TOKEN = "${}";
  var complexRegex = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
  function analyseComplexValue(value) {
    const originalValue = value.toString();
    const values = [];
    const indexes = {
      color: [],
      number: [],
      var: []
    };
    const types = [];
    let i3 = 0;
    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {
      if (color.test(parsedValue)) {
        indexes.color.push(i3);
        types.push(COLOR_TOKEN);
        values.push(color.parse(parsedValue));
      } else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
        indexes.var.push(i3);
        types.push(VAR_TOKEN);
        values.push(parsedValue);
      } else {
        indexes.number.push(i3);
        types.push(NUMBER_TOKEN);
        values.push(parseFloat(parsedValue));
      }
      ++i3;
      return SPLIT_TOKEN;
    });
    const split = tokenised.split(SPLIT_TOKEN);
    return { values, split, indexes, types };
  }
  function parseComplexValue(v3) {
    return analyseComplexValue(v3).values;
  }
  function createTransformer(source) {
    const { split, types } = analyseComplexValue(source);
    const numSections = split.length;
    return (v3) => {
      let output = "";
      for (let i3 = 0; i3 < numSections; i3++) {
        output += split[i3];
        if (v3[i3] !== void 0) {
          const type = types[i3];
          if (type === NUMBER_TOKEN) {
            output += sanitize(v3[i3]);
          } else if (type === COLOR_TOKEN) {
            output += color.transform(v3[i3]);
          } else {
            output += v3[i3];
          }
        }
      }
      return output;
    };
  }
  var convertNumbersToZero = (v3) => typeof v3 === "number" ? 0 : v3;
  function getAnimatableNone(v3) {
    const parsed = parseComplexValue(v3);
    const transformer = createTransformer(v3);
    return transformer(parsed.map(convertNumbersToZero));
  }
  var complex = {
    test,
    parse: parseComplexValue,
    createTransformer,
    getAnimatableNone
  };

  // packages/components/node_modules/framer-motion/dist/es/value/types/complex/filter.mjs
  var maxDefaults = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
  function applyDefaultFilter(v3) {
    const [name, value] = v3.slice(0, -1).split("(");
    if (name === "drop-shadow")
      return v3;
    const [number2] = value.match(floatRegex) || [];
    if (!number2)
      return v3;
    const unit = value.replace(number2, "");
    let defaultValue2 = maxDefaults.has(name) ? 1 : 0;
    if (number2 !== value)
      defaultValue2 *= 100;
    return name + "(" + defaultValue2 + unit + ")";
  }
  var functionRegex = /\b([a-z-]*)\(.*?\)/gu;
  var filter = {
    ...complex,
    getAnimatableNone: (v3) => {
      const functions = v3.match(functionRegex);
      return functions ? functions.map(applyDefaultFilter).join(" ") : v3;
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/number-browser.mjs
  var browserNumberValueTypes = {
    // Border props
    borderWidth: px,
    borderTopWidth: px,
    borderRightWidth: px,
    borderBottomWidth: px,
    borderLeftWidth: px,
    borderRadius: px,
    radius: px,
    borderTopLeftRadius: px,
    borderTopRightRadius: px,
    borderBottomRightRadius: px,
    borderBottomLeftRadius: px,
    // Positioning props
    width: px,
    maxWidth: px,
    height: px,
    maxHeight: px,
    top: px,
    right: px,
    bottom: px,
    left: px,
    // Spacing props
    padding: px,
    paddingTop: px,
    paddingRight: px,
    paddingBottom: px,
    paddingLeft: px,
    margin: px,
    marginTop: px,
    marginRight: px,
    marginBottom: px,
    marginLeft: px,
    // Misc
    backgroundPositionX: px,
    backgroundPositionY: px
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/transform.mjs
  var transformValueTypes = {
    rotate: degrees,
    rotateX: degrees,
    rotateY: degrees,
    rotateZ: degrees,
    scale,
    scaleX: scale,
    scaleY: scale,
    scaleZ: scale,
    skew: degrees,
    skewX: degrees,
    skewY: degrees,
    distance: px,
    translateX: px,
    translateY: px,
    translateZ: px,
    x: px,
    y: px,
    z: px,
    perspective: px,
    transformPerspective: px,
    opacity: alpha,
    originX: progressPercentage,
    originY: progressPercentage,
    originZ: px
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs
  var int = {
    ...number,
    transform: Math.round
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs
  var numberValueTypes = {
    ...browserNumberValueTypes,
    ...transformValueTypes,
    zIndex: int,
    size: px,
    // SVG
    fillOpacity: alpha,
    strokeOpacity: alpha,
    numOctaves: int
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs
  var defaultValueTypes = {
    ...numberValueTypes,
    // Color props
    color,
    backgroundColor: color,
    outlineColor: color,
    fill: color,
    stroke: color,
    // Border props
    borderColor: color,
    borderTopColor: color,
    borderRightColor: color,
    borderBottomColor: color,
    borderLeftColor: color,
    filter,
    WebkitFilter: filter
  };
  var getDefaultValueType = (key) => defaultValueTypes[key];

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs
  function getAnimatableNone2(key, value) {
    let defaultValueType = getDefaultValueType(key);
    if (defaultValueType !== filter)
      defaultValueType = complex;
    return defaultValueType.getAnimatableNone ? defaultValueType.getAnimatableNone(value) : void 0;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs
  var invalidTemplates = /* @__PURE__ */ new Set(["auto", "none", "0"]);
  function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
    let i3 = 0;
    let animatableTemplate = void 0;
    while (i3 < unresolvedKeyframes.length && !animatableTemplate) {
      const keyframe = unresolvedKeyframes[i3];
      if (typeof keyframe === "string" && !invalidTemplates.has(keyframe) && analyseComplexValue(keyframe).values.length) {
        animatableTemplate = unresolvedKeyframes[i3];
      }
      i3++;
    }
    if (animatableTemplate && name) {
      for (const noneIndex of noneKeyframeIndexes) {
        unresolvedKeyframes[noneIndex] = getAnimatableNone2(name, animatableTemplate);
      }
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs
  var DOMKeyframesResolver = class extends KeyframeResolver {
    constructor(unresolvedKeyframes, onComplete, name, motionValue2, element) {
      super(unresolvedKeyframes, onComplete, name, motionValue2, element, true);
    }
    readKeyframes() {
      const { unresolvedKeyframes, element, name } = this;
      if (!element || !element.current)
        return;
      super.readKeyframes();
      for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
        let keyframe = unresolvedKeyframes[i3];
        if (typeof keyframe === "string") {
          keyframe = keyframe.trim();
          if (isCSSVariableToken(keyframe)) {
            const resolved = getVariableValue(keyframe, element.current);
            if (resolved !== void 0) {
              unresolvedKeyframes[i3] = resolved;
            }
            if (i3 === unresolvedKeyframes.length - 1) {
              this.finalKeyframe = keyframe;
            }
          }
        }
      }
      this.resolveNoneKeyframes();
      if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {
        return;
      }
      const [origin, target] = unresolvedKeyframes;
      const originType = findDimensionValueType(origin);
      const targetType = findDimensionValueType(target);
      if (originType === targetType)
        return;
      if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {
        for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
          const value = unresolvedKeyframes[i3];
          if (typeof value === "string") {
            unresolvedKeyframes[i3] = parseFloat(value);
          }
        }
      } else {
        this.needsMeasurement = true;
      }
    }
    resolveNoneKeyframes() {
      const { unresolvedKeyframes, name } = this;
      const noneKeyframeIndexes = [];
      for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
        if (isNone(unresolvedKeyframes[i3])) {
          noneKeyframeIndexes.push(i3);
        }
      }
      if (noneKeyframeIndexes.length) {
        makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);
      }
    }
    measureInitialState() {
      const { element, unresolvedKeyframes, name } = this;
      if (!element || !element.current)
        return;
      if (name === "height") {
        this.suspendedScrollY = window.pageYOffset;
      }
      this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
      unresolvedKeyframes[0] = this.measuredOrigin;
      const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
      if (measureKeyframe !== void 0) {
        element.getValue(name, measureKeyframe).jump(measureKeyframe, false);
      }
    }
    measureEndState() {
      var _a;
      const { element, name, unresolvedKeyframes } = this;
      if (!element || !element.current)
        return;
      const value = element.getValue(name);
      value && value.jump(this.measuredOrigin, false);
      const finalKeyframeIndex = unresolvedKeyframes.length - 1;
      const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];
      unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
      if (finalKeyframe !== null && this.finalKeyframe === void 0) {
        this.finalKeyframe = finalKeyframe;
      }
      if ((_a = this.removedTransforms) === null || _a === void 0 ? void 0 : _a.length) {
        this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {
          element.getValue(unsetTransformName).set(unsetTransformValue);
        });
      }
      this.resolveNoneKeyframes();
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/utils/is-generator.mjs
  function isGenerator(type) {
    return typeof type === "function";
  }

  // packages/components/node_modules/framer-motion/dist/es/frameloop/sync-time.mjs
  var now;
  function clearTime() {
    now = void 0;
  }
  var time = {
    now: () => {
      if (now === void 0) {
        time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
      }
      return now;
    },
    set: (newTime) => {
      now = newTime;
      queueMicrotask(clearTime);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs
  var isAnimatable = (value, name) => {
    if (name === "zIndex")
      return false;
    if (typeof value === "number" || Array.isArray(value))
      return true;
    if (typeof value === "string" && // It's animatable if we have a string
    (complex.test(value) || value === "0") && // And it contains numbers and/or colors
    !value.startsWith("url(")) {
      return true;
    }
    return false;
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs
  function hasKeyframesChanged(keyframes4) {
    const current = keyframes4[0];
    if (keyframes4.length === 1)
      return true;
    for (let i3 = 0; i3 < keyframes4.length; i3++) {
      if (keyframes4[i3] !== current)
        return true;
    }
  }
  function canAnimate(keyframes4, name, type, velocity) {
    const originKeyframe = keyframes4[0];
    if (originKeyframe === null)
      return false;
    if (name === "display" || name === "visibility")
      return true;
    const targetKeyframe = keyframes4[keyframes4.length - 1];
    const isOriginAnimatable = isAnimatable(originKeyframe, name);
    const isTargetAnimatable = isAnimatable(targetKeyframe, name);
    warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from "${originKeyframe}" to "${targetKeyframe}". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \`style\` property.`);
    if (!isOriginAnimatable || !isTargetAnimatable) {
      return false;
    }
    return hasKeyframesChanged(keyframes4) || (type === "spring" || isGenerator(type)) && velocity;
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs
  var MAX_RESOLVE_DELAY = 40;
  var BaseAnimation = class {
    constructor({ autoplay = true, delay: delay2 = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", ...options2 }) {
      this.isStopped = false;
      this.hasAttemptedResolve = false;
      this.createdAt = time.now();
      this.options = {
        autoplay,
        delay: delay2,
        type,
        repeat,
        repeatDelay,
        repeatType,
        ...options2
      };
      this.updateFinishedPromise();
    }
    /**
     * This method uses the createdAt and resolvedAt to calculate the
     * animation startTime. *Ideally*, we would use the createdAt time as t=0
     * as the following frame would then be the first frame of the animation in
     * progress, which would feel snappier.
     *
     * However, if there's a delay (main thread work) between the creation of
     * the animation and the first commited frame, we prefer to use resolvedAt
     * to avoid a sudden jump into the animation.
     */
    calcStartTime() {
      if (!this.resolvedAt)
        return this.createdAt;
      return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY ? this.resolvedAt : this.createdAt;
    }
    /**
     * A getter for resolved data. If keyframes are not yet resolved, accessing
     * this.resolved will synchronously flush all pending keyframe resolvers.
     * This is a deoptimisation, but at its worst still batches read/writes.
     */
    get resolved() {
      if (!this._resolved && !this.hasAttemptedResolve) {
        flushKeyframeResolvers();
      }
      return this._resolved;
    }
    /**
     * A method to be called when the keyframes resolver completes. This method
     * will check if its possible to run the animation and, if not, skip it.
     * Otherwise, it will call initPlayback on the implementing class.
     */
    onKeyframesResolved(keyframes4, finalKeyframe) {
      this.resolvedAt = time.now();
      this.hasAttemptedResolve = true;
      const { name, type, velocity, delay: delay2, onComplete, onUpdate, isGenerator: isGenerator2 } = this.options;
      if (!isGenerator2 && !canAnimate(keyframes4, name, type, velocity)) {
        if (instantAnimationState.current || !delay2) {
          onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(getFinalKeyframe(keyframes4, this.options, finalKeyframe));
          onComplete === null || onComplete === void 0 ? void 0 : onComplete();
          this.resolveFinishedPromise();
          return;
        } else {
          this.options.duration = 0;
        }
      }
      const resolvedAnimation = this.initPlayback(keyframes4, finalKeyframe);
      if (resolvedAnimation === false)
        return;
      this._resolved = {
        keyframes: keyframes4,
        finalKeyframe,
        ...resolvedAnimation
      };
      this.onPostResolved();
    }
    onPostResolved() {
    }
    /**
     * Allows the returned animation to be awaited or promise-chained. Currently
     * resolves when the animation finishes at all but in a future update could/should
     * reject if its cancels.
     */
    then(resolve, reject) {
      return this.currentFinishedPromise.then(resolve, reject);
    }
    flatten() {
      this.options.type = "keyframes";
      this.options.ease = "linear";
    }
    updateFinishedPromise() {
      this.currentFinishedPromise = new Promise((resolve) => {
        this.resolveFinishedPromise = resolve;
      });
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/progress.mjs
  var progress = (from2, to, value) => {
    const toFromDifference = to - from2;
    return toFromDifference === 0 ? 1 : (value - from2) / toFromDifference;
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/linear.mjs
  var generateLinearEasing = (easing, duration, resolution = 10) => {
    let points = "";
    const numPoints = Math.max(Math.round(duration / resolution), 2);
    for (let i3 = 0; i3 < numPoints; i3++) {
      points += easing(progress(0, numPoints - 1, i3)) + ", ";
    }
    return `linear(${points.substring(0, points.length - 2)})`;
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs
  function velocityPerSecond(velocity, frameDuration) {
    return frameDuration ? velocity * (1e3 / frameDuration) : 0;
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs
  var velocitySampleDuration = 5;
  function calcGeneratorVelocity(resolveValue, t4, current) {
    const prevT = Math.max(t4 - velocitySampleDuration, 0);
    return velocityPerSecond(current - resolveValue(prevT), t4 - prevT);
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/spring/defaults.mjs
  var springDefaults = {
    // Default spring physics
    stiffness: 100,
    damping: 10,
    mass: 1,
    velocity: 0,
    // Default duration/bounce-based options
    duration: 800,
    // in ms
    bounce: 0.3,
    visualDuration: 0.3,
    // in seconds
    // Rest thresholds
    restSpeed: {
      granular: 0.01,
      default: 2
    },
    restDelta: {
      granular: 5e-3,
      default: 0.5
    },
    // Limits
    minDuration: 0.01,
    // in seconds
    maxDuration: 10,
    // in seconds
    minDamping: 0.05,
    maxDamping: 1
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs
  var safeMin = 1e-3;
  function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
    let envelope;
    let derivative;
    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less");
    let dampingRatio = 1 - bounce;
    dampingRatio = clamp2(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
    duration = clamp2(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));
    if (dampingRatio < 1) {
      envelope = (undampedFreq2) => {
        const exponentialDecay = undampedFreq2 * dampingRatio;
        const delta = exponentialDecay * duration;
        const a3 = exponentialDecay - velocity;
        const b3 = calcAngularFreq(undampedFreq2, dampingRatio);
        const c3 = Math.exp(-delta);
        return safeMin - a3 / b3 * c3;
      };
      derivative = (undampedFreq2) => {
        const exponentialDecay = undampedFreq2 * dampingRatio;
        const delta = exponentialDecay * duration;
        const d3 = delta * velocity + velocity;
        const e3 = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq2, 2) * duration;
        const f3 = Math.exp(-delta);
        const g3 = calcAngularFreq(Math.pow(undampedFreq2, 2), dampingRatio);
        const factor = -envelope(undampedFreq2) + safeMin > 0 ? -1 : 1;
        return factor * ((d3 - e3) * f3) / g3;
      };
    } else {
      envelope = (undampedFreq2) => {
        const a3 = Math.exp(-undampedFreq2 * duration);
        const b3 = (undampedFreq2 - velocity) * duration + 1;
        return -safeMin + a3 * b3;
      };
      derivative = (undampedFreq2) => {
        const a3 = Math.exp(-undampedFreq2 * duration);
        const b3 = (velocity - undampedFreq2) * (duration * duration);
        return a3 * b3;
      };
    }
    const initialGuess = 5 / duration;
    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
    duration = secondsToMilliseconds(duration);
    if (isNaN(undampedFreq)) {
      return {
        stiffness: springDefaults.stiffness,
        damping: springDefaults.damping,
        duration
      };
    } else {
      const stiffness = Math.pow(undampedFreq, 2) * mass;
      return {
        stiffness,
        damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
        duration
      };
    }
  }
  var rootIterations = 12;
  function approximateRoot(envelope, derivative, initialGuess) {
    let result = initialGuess;
    for (let i3 = 1; i3 < rootIterations; i3++) {
      result = result - envelope(result) / derivative(result);
    }
    return result;
  }
  function calcAngularFreq(undampedFreq, dampingRatio) {
    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.mjs
  var maxGeneratorDuration = 2e4;
  function calcGeneratorDuration(generator) {
    let duration = 0;
    const timeStep = 50;
    let state = generator.next(duration);
    while (!state.done && duration < maxGeneratorDuration) {
      duration += timeStep;
      state = generator.next(duration);
    }
    return duration >= maxGeneratorDuration ? Infinity : duration;
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs
  var durationKeys = ["duration", "bounce"];
  var physicsKeys = ["stiffness", "damping", "mass"];
  function isSpringType(options2, keys) {
    return keys.some((key) => options2[key] !== void 0);
  }
  function getSpringOptions(options2) {
    let springOptions = {
      velocity: springDefaults.velocity,
      stiffness: springDefaults.stiffness,
      damping: springDefaults.damping,
      mass: springDefaults.mass,
      isResolvedFromDuration: false,
      ...options2
    };
    if (!isSpringType(options2, physicsKeys) && isSpringType(options2, durationKeys)) {
      if (options2.visualDuration) {
        const visualDuration = options2.visualDuration;
        const root = 2 * Math.PI / (visualDuration * 1.2);
        const stiffness = root * root;
        const damping = 2 * clamp2(0.05, 1, 1 - options2.bounce) * Math.sqrt(stiffness);
        springOptions = {
          ...springOptions,
          mass: springDefaults.mass,
          stiffness,
          damping
        };
      } else {
        const derived = findSpring(options2);
        springOptions = {
          ...springOptions,
          ...derived,
          mass: springDefaults.mass
        };
        springOptions.isResolvedFromDuration = true;
      }
    }
    return springOptions;
  }
  function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
    const options2 = typeof optionsOrVisualDuration !== "object" ? {
      visualDuration: optionsOrVisualDuration,
      keyframes: [0, 1],
      bounce
    } : optionsOrVisualDuration;
    let { restSpeed, restDelta } = options2;
    const origin = options2.keyframes[0];
    const target = options2.keyframes[options2.keyframes.length - 1];
    const state = { done: false, value: origin };
    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
      ...options2,
      velocity: -millisecondsToSeconds(options2.velocity || 0)
    });
    const initialVelocity = velocity || 0;
    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
    const initialDelta = target - origin;
    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
    const isGranularScale = Math.abs(initialDelta) < 5;
    restSpeed || (restSpeed = isGranularScale ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default);
    restDelta || (restDelta = isGranularScale ? springDefaults.restDelta.granular : springDefaults.restDelta.default);
    let resolveSpring;
    if (dampingRatio < 1) {
      const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
      resolveSpring = (t4) => {
        const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t4);
        return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq * Math.sin(angularFreq * t4) + initialDelta * Math.cos(angularFreq * t4));
      };
    } else if (dampingRatio === 1) {
      resolveSpring = (t4) => target - Math.exp(-undampedAngularFreq * t4) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t4);
    } else {
      const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
      resolveSpring = (t4) => {
        const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t4);
        const freqForT = Math.min(dampedAngularFreq * t4, 300);
        return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
      };
    }
    const generator = {
      calculatedDuration: isResolvedFromDuration ? duration || null : null,
      next: (t4) => {
        const current = resolveSpring(t4);
        if (!isResolvedFromDuration) {
          let currentVelocity = 0;
          if (dampingRatio < 1) {
            currentVelocity = t4 === 0 ? secondsToMilliseconds(initialVelocity) : calcGeneratorVelocity(resolveSpring, t4, current);
          }
          const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
          const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
          state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;
        } else {
          state.done = t4 >= duration;
        }
        state.value = state.done ? target : current;
        return state;
      },
      toString: () => {
        const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
        const easing = generateLinearEasing((progress2) => generator.next(calculatedDuration * progress2).value, calculatedDuration, 30);
        return calculatedDuration + "ms " + easing;
      }
    };
    return generator;
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/inertia.mjs
  function inertia({ keyframes: keyframes4, velocity = 0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min: min3, max: max3, restDelta = 0.5, restSpeed }) {
    const origin = keyframes4[0];
    const state = {
      done: false,
      value: origin
    };
    const isOutOfBounds = (v3) => min3 !== void 0 && v3 < min3 || max3 !== void 0 && v3 > max3;
    const nearestBoundary = (v3) => {
      if (min3 === void 0)
        return max3;
      if (max3 === void 0)
        return min3;
      return Math.abs(min3 - v3) < Math.abs(max3 - v3) ? min3 : max3;
    };
    let amplitude = power * velocity;
    const ideal = origin + amplitude;
    const target = modifyTarget === void 0 ? ideal : modifyTarget(ideal);
    if (target !== ideal)
      amplitude = target - origin;
    const calcDelta = (t4) => -amplitude * Math.exp(-t4 / timeConstant);
    const calcLatest = (t4) => target + calcDelta(t4);
    const applyFriction = (t4) => {
      const delta = calcDelta(t4);
      const latest = calcLatest(t4);
      state.done = Math.abs(delta) <= restDelta;
      state.value = state.done ? target : latest;
    };
    let timeReachedBoundary;
    let spring$1;
    const checkCatchBoundary = (t4) => {
      if (!isOutOfBounds(state.value))
        return;
      timeReachedBoundary = t4;
      spring$1 = spring({
        keyframes: [state.value, nearestBoundary(state.value)],
        velocity: calcGeneratorVelocity(calcLatest, t4, state.value),
        // TODO: This should be passing * 1000
        damping: bounceDamping,
        stiffness: bounceStiffness,
        restDelta,
        restSpeed
      });
    };
    checkCatchBoundary(0);
    return {
      calculatedDuration: null,
      next: (t4) => {
        let hasUpdatedFrame = false;
        if (!spring$1 && timeReachedBoundary === void 0) {
          hasUpdatedFrame = true;
          applyFriction(t4);
          checkCatchBoundary(t4);
        }
        if (timeReachedBoundary !== void 0 && t4 >= timeReachedBoundary) {
          return spring$1.next(t4 - timeReachedBoundary);
        } else {
          !hasUpdatedFrame && applyFriction(t4);
          return state;
        }
      }
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/easing/ease.mjs
  var easeIn = /* @__PURE__ */ cubicBezier(0.42, 0, 1, 1);
  var easeOut = /* @__PURE__ */ cubicBezier(0, 0, 0.58, 1);
  var easeInOut = /* @__PURE__ */ cubicBezier(0.42, 0, 0.58, 1);

  // packages/components/node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs
  var isEasingArray = (ease2) => {
    return Array.isArray(ease2) && typeof ease2[0] !== "number";
  };

  // packages/components/node_modules/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs
  var isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === "number";

  // packages/components/node_modules/framer-motion/dist/es/easing/utils/map.mjs
  var easingLookup = {
    linear: noop2,
    easeIn,
    easeInOut,
    easeOut,
    circIn,
    circInOut,
    circOut,
    backIn,
    backInOut,
    backOut,
    anticipate
  };
  var easingDefinitionToFunction = (definition) => {
    if (isBezierDefinition(definition)) {
      invariant2(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);
      const [x1, y1, x2, y22] = definition;
      return cubicBezier(x1, y1, x2, y22);
    } else if (typeof definition === "string") {
      invariant2(easingLookup[definition] !== void 0, `Invalid easing type '${definition}'`);
      return easingLookup[definition];
    }
    return definition;
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/pipe.mjs
  var combineFunctions = (a3, b3) => (v3) => b3(a3(v3));
  var pipe = (...transformers) => transformers.reduce(combineFunctions);

  // packages/components/node_modules/framer-motion/dist/es/utils/mix/number.mjs
  var mixNumber = (from2, to, progress2) => {
    return from2 + (to - from2) * progress2;
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs
  function hueToRgb(p3, q2, t4) {
    if (t4 < 0)
      t4 += 1;
    if (t4 > 1)
      t4 -= 1;
    if (t4 < 1 / 6)
      return p3 + (q2 - p3) * 6 * t4;
    if (t4 < 1 / 2)
      return q2;
    if (t4 < 2 / 3)
      return p3 + (q2 - p3) * (2 / 3 - t4) * 6;
    return p3;
  }
  function hslaToRgba({ hue, saturation, lightness, alpha: alpha2 }) {
    hue /= 360;
    saturation /= 100;
    lightness /= 100;
    let red = 0;
    let green = 0;
    let blue = 0;
    if (!saturation) {
      red = green = blue = lightness;
    } else {
      const q2 = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
      const p3 = 2 * lightness - q2;
      red = hueToRgb(p3, q2, hue + 1 / 3);
      green = hueToRgb(p3, q2, hue);
      blue = hueToRgb(p3, q2, hue - 1 / 3);
    }
    return {
      red: Math.round(red * 255),
      green: Math.round(green * 255),
      blue: Math.round(blue * 255),
      alpha: alpha2
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/mix/immediate.mjs
  function mixImmediate(a3, b3) {
    return (p3) => p3 > 0 ? b3 : a3;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/mix/color.mjs
  var mixLinearColor = (from2, to, v3) => {
    const fromExpo = from2 * from2;
    const expo = v3 * (to * to - fromExpo) + fromExpo;
    return expo < 0 ? 0 : Math.sqrt(expo);
  };
  var colorTypes = [hex, rgba, hsla];
  var getColorType = (v3) => colorTypes.find((type) => type.test(v3));
  function asRGBA(color2) {
    const type = getColorType(color2);
    warning(Boolean(type), `'${color2}' is not an animatable color. Use the equivalent color code instead.`);
    if (!Boolean(type))
      return false;
    let model = type.parse(color2);
    if (type === hsla) {
      model = hslaToRgba(model);
    }
    return model;
  }
  var mixColor = (from2, to) => {
    const fromRGBA = asRGBA(from2);
    const toRGBA = asRGBA(to);
    if (!fromRGBA || !toRGBA) {
      return mixImmediate(from2, to);
    }
    const blended = { ...fromRGBA };
    return (v3) => {
      blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v3);
      blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v3);
      blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v3);
      blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v3);
      return rgba.transform(blended);
    };
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/mix/visibility.mjs
  var invisibleValues = /* @__PURE__ */ new Set(["none", "hidden"]);
  function mixVisibility(origin, target) {
    if (invisibleValues.has(origin)) {
      return (p3) => p3 <= 0 ? origin : target;
    } else {
      return (p3) => p3 >= 1 ? target : origin;
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/mix/complex.mjs
  function mixNumber2(a3, b3) {
    return (p3) => mixNumber(a3, b3, p3);
  }
  function getMixer(a3) {
    if (typeof a3 === "number") {
      return mixNumber2;
    } else if (typeof a3 === "string") {
      return isCSSVariableToken(a3) ? mixImmediate : color.test(a3) ? mixColor : mixComplex;
    } else if (Array.isArray(a3)) {
      return mixArray;
    } else if (typeof a3 === "object") {
      return color.test(a3) ? mixColor : mixObject;
    }
    return mixImmediate;
  }
  function mixArray(a3, b3) {
    const output = [...a3];
    const numValues = output.length;
    const blendValue = a3.map((v3, i3) => getMixer(v3)(v3, b3[i3]));
    return (p3) => {
      for (let i3 = 0; i3 < numValues; i3++) {
        output[i3] = blendValue[i3](p3);
      }
      return output;
    };
  }
  function mixObject(a3, b3) {
    const output = { ...a3, ...b3 };
    const blendValue = {};
    for (const key in output) {
      if (a3[key] !== void 0 && b3[key] !== void 0) {
        blendValue[key] = getMixer(a3[key])(a3[key], b3[key]);
      }
    }
    return (v3) => {
      for (const key in blendValue) {
        output[key] = blendValue[key](v3);
      }
      return output;
    };
  }
  function matchOrder(origin, target) {
    var _a;
    const orderedOrigin = [];
    const pointers = { color: 0, var: 0, number: 0 };
    for (let i3 = 0; i3 < target.values.length; i3++) {
      const type = target.types[i3];
      const originIndex = origin.indexes[type][pointers[type]];
      const originValue = (_a = origin.values[originIndex]) !== null && _a !== void 0 ? _a : 0;
      orderedOrigin[i3] = originValue;
      pointers[type]++;
    }
    return orderedOrigin;
  }
  var mixComplex = (origin, target) => {
    const template = complex.createTransformer(target);
    const originStats = analyseComplexValue(origin);
    const targetStats = analyseComplexValue(target);
    const canInterpolate = originStats.indexes.var.length === targetStats.indexes.var.length && originStats.indexes.color.length === targetStats.indexes.color.length && originStats.indexes.number.length >= targetStats.indexes.number.length;
    if (canInterpolate) {
      if (invisibleValues.has(origin) && !targetStats.values.length || invisibleValues.has(target) && !originStats.values.length) {
        return mixVisibility(origin, target);
      }
      return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);
    } else {
      warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);
      return mixImmediate(origin, target);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/mix/index.mjs
  function mix(from2, to, p3) {
    if (typeof from2 === "number" && typeof to === "number" && typeof p3 === "number") {
      return mixNumber(from2, to, p3);
    }
    const mixer = getMixer(from2);
    return mixer(from2, to);
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/interpolate.mjs
  function createMixers(output, ease2, customMixer) {
    const mixers = [];
    const mixerFactory = customMixer || mix;
    const numMixers = output.length - 1;
    for (let i3 = 0; i3 < numMixers; i3++) {
      let mixer = mixerFactory(output[i3], output[i3 + 1]);
      if (ease2) {
        const easingFunction = Array.isArray(ease2) ? ease2[i3] || noop2 : ease2;
        mixer = pipe(easingFunction, mixer);
      }
      mixers.push(mixer);
    }
    return mixers;
  }
  function interpolate(input, output, { clamp: isClamp = true, ease: ease2, mixer } = {}) {
    const inputLength = input.length;
    invariant2(inputLength === output.length, "Both input and output ranges must be the same length");
    if (inputLength === 1)
      return () => output[0];
    if (inputLength === 2 && input[0] === input[1])
      return () => output[1];
    if (input[0] > input[inputLength - 1]) {
      input = [...input].reverse();
      output = [...output].reverse();
    }
    const mixers = createMixers(output, ease2, mixer);
    const numMixers = mixers.length;
    const interpolator = (v3) => {
      let i3 = 0;
      if (numMixers > 1) {
        for (; i3 < input.length - 2; i3++) {
          if (v3 < input[i3 + 1])
            break;
        }
      }
      const progressInRange = progress(input[i3], input[i3 + 1], v3);
      return mixers[i3](progressInRange);
    };
    return isClamp ? (v3) => interpolator(clamp2(input[0], input[inputLength - 1], v3)) : interpolator;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/offsets/fill.mjs
  function fillOffset(offset4, remaining) {
    const min3 = offset4[offset4.length - 1];
    for (let i3 = 1; i3 <= remaining; i3++) {
      const offsetProgress = progress(0, remaining, i3);
      offset4.push(mixNumber(min3, 1, offsetProgress));
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/offsets/default.mjs
  function defaultOffset(arr) {
    const offset4 = [0];
    fillOffset(offset4, arr.length - 1);
    return offset4;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/offsets/time.mjs
  function convertOffsetToTimes(offset4, duration) {
    return offset4.map((o4) => o4 * duration);
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs
  function defaultEasing(values, easing) {
    return values.map(() => easing || easeInOut).splice(0, values.length - 1);
  }
  function keyframes({ duration = 300, keyframes: keyframeValues, times, ease: ease2 = "easeInOut" }) {
    const easingFunctions = isEasingArray(ease2) ? ease2.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease2);
    const state = {
      done: false,
      value: keyframeValues[0]
    };
    const absoluteTimes = convertOffsetToTimes(
      // Only use the provided offsets if they're the correct length
      // TODO Maybe we should warn here if there's a length mismatch
      times && times.length === keyframeValues.length ? times : defaultOffset(keyframeValues),
      duration
    );
    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {
      ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions)
    });
    return {
      calculatedDuration: duration,
      next: (t4) => {
        state.value = mapTimeToKeyframe(t4);
        state.done = t4 >= duration;
        return state;
      }
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs
  var frameloopDriver = (update) => {
    const passTimestamp = ({ timestamp }) => update(timestamp);
    return {
      start: () => frame.update(passTimestamp, true),
      stop: () => cancelFrame(passTimestamp),
      /**
       * If we're processing this frame we can use the
       * framelocked timestamp to keep things in sync.
       */
      now: () => frameData.isProcessing ? frameData.timestamp : time.now()
    };
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs
  var generators = {
    decay: inertia,
    inertia,
    tween: keyframes,
    keyframes,
    spring
  };
  var percentToProgress = (percent2) => percent2 / 100;
  var MainThreadAnimation = class extends BaseAnimation {
    constructor(options2) {
      super(options2);
      this.holdTime = null;
      this.cancelTime = null;
      this.currentTime = 0;
      this.playbackSpeed = 1;
      this.pendingPlayState = "running";
      this.startTime = null;
      this.state = "idle";
      this.stop = () => {
        this.resolver.cancel();
        this.isStopped = true;
        if (this.state === "idle")
          return;
        this.teardown();
        const { onStop } = this.options;
        onStop && onStop();
      };
      const { name, motionValue: motionValue2, element, keyframes: keyframes4 } = this.options;
      const KeyframeResolver$1 = (element === null || element === void 0 ? void 0 : element.KeyframeResolver) || KeyframeResolver;
      const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);
      this.resolver = new KeyframeResolver$1(keyframes4, onResolved, name, motionValue2, element);
      this.resolver.scheduleResolve();
    }
    flatten() {
      super.flatten();
      if (this._resolved) {
        Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
      }
    }
    initPlayback(keyframes$1) {
      const { type = "keyframes", repeat = 0, repeatDelay = 0, repeatType, velocity = 0 } = this.options;
      const generatorFactory = isGenerator(type) ? type : generators[type] || keyframes;
      let mapPercentToKeyframes;
      let mirroredGenerator;
      if (generatorFactory !== keyframes && typeof keyframes$1[0] !== "number") {
        if (true) {
          invariant2(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);
        }
        mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));
        keyframes$1 = [0, 100];
      }
      const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });
      if (repeatType === "mirror") {
        mirroredGenerator = generatorFactory({
          ...this.options,
          keyframes: [...keyframes$1].reverse(),
          velocity: -velocity
        });
      }
      if (generator.calculatedDuration === null) {
        generator.calculatedDuration = calcGeneratorDuration(generator);
      }
      const { calculatedDuration } = generator;
      const resolvedDuration = calculatedDuration + repeatDelay;
      const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;
      return {
        generator,
        mirroredGenerator,
        mapPercentToKeyframes,
        calculatedDuration,
        resolvedDuration,
        totalDuration
      };
    }
    onPostResolved() {
      const { autoplay = true } = this.options;
      this.play();
      if (this.pendingPlayState === "paused" || !autoplay) {
        this.pause();
      } else {
        this.state = this.pendingPlayState;
      }
    }
    tick(timestamp, sample = false) {
      const { resolved } = this;
      if (!resolved) {
        const { keyframes: keyframes5 } = this.options;
        return { done: true, value: keyframes5[keyframes5.length - 1] };
      }
      const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes: keyframes4, calculatedDuration, totalDuration, resolvedDuration } = resolved;
      if (this.startTime === null)
        return generator.next(0);
      const { delay: delay2, repeat, repeatType, repeatDelay, onUpdate } = this.options;
      if (this.speed > 0) {
        this.startTime = Math.min(this.startTime, timestamp);
      } else if (this.speed < 0) {
        this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);
      }
      if (sample) {
        this.currentTime = timestamp;
      } else if (this.holdTime !== null) {
        this.currentTime = this.holdTime;
      } else {
        this.currentTime = Math.round(timestamp - this.startTime) * this.speed;
      }
      const timeWithoutDelay = this.currentTime - delay2 * (this.speed >= 0 ? 1 : -1);
      const isInDelayPhase = this.speed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;
      this.currentTime = Math.max(timeWithoutDelay, 0);
      if (this.state === "finished" && this.holdTime === null) {
        this.currentTime = totalDuration;
      }
      let elapsed = this.currentTime;
      let frameGenerator = generator;
      if (repeat) {
        const progress2 = Math.min(this.currentTime, totalDuration) / resolvedDuration;
        let currentIteration = Math.floor(progress2);
        let iterationProgress = progress2 % 1;
        if (!iterationProgress && progress2 >= 1) {
          iterationProgress = 1;
        }
        iterationProgress === 1 && currentIteration--;
        currentIteration = Math.min(currentIteration, repeat + 1);
        const isOddIteration = Boolean(currentIteration % 2);
        if (isOddIteration) {
          if (repeatType === "reverse") {
            iterationProgress = 1 - iterationProgress;
            if (repeatDelay) {
              iterationProgress -= repeatDelay / resolvedDuration;
            }
          } else if (repeatType === "mirror") {
            frameGenerator = mirroredGenerator;
          }
        }
        elapsed = clamp2(0, 1, iterationProgress) * resolvedDuration;
      }
      const state = isInDelayPhase ? { done: false, value: keyframes4[0] } : frameGenerator.next(elapsed);
      if (mapPercentToKeyframes) {
        state.value = mapPercentToKeyframes(state.value);
      }
      let { done } = state;
      if (!isInDelayPhase && calculatedDuration !== null) {
        done = this.speed >= 0 ? this.currentTime >= totalDuration : this.currentTime <= 0;
      }
      const isAnimationFinished = this.holdTime === null && (this.state === "finished" || this.state === "running" && done);
      if (isAnimationFinished && finalKeyframe !== void 0) {
        state.value = getFinalKeyframe(keyframes4, this.options, finalKeyframe);
      }
      if (onUpdate) {
        onUpdate(state.value);
      }
      if (isAnimationFinished) {
        this.finish();
      }
      return state;
    }
    get duration() {
      const { resolved } = this;
      return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;
    }
    get time() {
      return millisecondsToSeconds(this.currentTime);
    }
    set time(newTime) {
      newTime = secondsToMilliseconds(newTime);
      this.currentTime = newTime;
      if (this.holdTime !== null || this.speed === 0) {
        this.holdTime = newTime;
      } else if (this.driver) {
        this.startTime = this.driver.now() - newTime / this.speed;
      }
    }
    get speed() {
      return this.playbackSpeed;
    }
    set speed(newSpeed) {
      const hasChanged = this.playbackSpeed !== newSpeed;
      this.playbackSpeed = newSpeed;
      if (hasChanged) {
        this.time = millisecondsToSeconds(this.currentTime);
      }
    }
    play() {
      if (!this.resolver.isScheduled) {
        this.resolver.resume();
      }
      if (!this._resolved) {
        this.pendingPlayState = "running";
        return;
      }
      if (this.isStopped)
        return;
      const { driver = frameloopDriver, onPlay, startTime } = this.options;
      if (!this.driver) {
        this.driver = driver((timestamp) => this.tick(timestamp));
      }
      onPlay && onPlay();
      const now2 = this.driver.now();
      if (this.holdTime !== null) {
        this.startTime = now2 - this.holdTime;
      } else if (!this.startTime) {
        this.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
      } else if (this.state === "finished") {
        this.startTime = now2;
      }
      if (this.state === "finished") {
        this.updateFinishedPromise();
      }
      this.cancelTime = this.startTime;
      this.holdTime = null;
      this.state = "running";
      this.driver.start();
    }
    pause() {
      var _a;
      if (!this._resolved) {
        this.pendingPlayState = "paused";
        return;
      }
      this.state = "paused";
      this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;
    }
    complete() {
      if (this.state !== "running") {
        this.play();
      }
      this.pendingPlayState = this.state = "finished";
      this.holdTime = null;
    }
    finish() {
      this.teardown();
      this.state = "finished";
      const { onComplete } = this.options;
      onComplete && onComplete();
    }
    cancel() {
      if (this.cancelTime !== null) {
        this.tick(this.cancelTime);
      }
      this.teardown();
      this.updateFinishedPromise();
    }
    teardown() {
      this.state = "idle";
      this.stopDriver();
      this.resolveFinishedPromise();
      this.updateFinishedPromise();
      this.startTime = this.cancelTime = null;
      this.resolver.cancel();
    }
    stopDriver() {
      if (!this.driver)
        return;
      this.driver.stop();
      this.driver = void 0;
    }
    sample(time2) {
      this.startTime = 0;
      return this.tick(time2, true);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs
  var acceleratedValues = /* @__PURE__ */ new Set([
    "opacity",
    "clipPath",
    "filter",
    "transform"
    // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
    // or until we implement support for linear() easing.
    // "background-color"
  ]);

  // packages/components/node_modules/framer-motion/dist/es/utils/memo.mjs
  function memo3(callback) {
    let result;
    return () => {
      if (result === void 0)
        result = callback();
      return result;
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-flags.mjs
  var supportsFlags = {
    linearEasing: void 0
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/memo-supports.mjs
  function memoSupports(callback, supportsFlag) {
    const memoized = memo3(callback);
    return () => {
      var _a;
      return (_a = supportsFlags[supportsFlag]) !== null && _a !== void 0 ? _a : memoized();
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-linear-easing.mjs
  var supportsLinearEasing = /* @__PURE__ */ memoSupports(() => {
    try {
      document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
    } catch (e3) {
      return false;
    }
    return true;
  }, "linearEasing");

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/easing.mjs
  function isWaapiSupportedEasing(easing) {
    return Boolean(typeof easing === "function" && supportsLinearEasing() || !easing || typeof easing === "string" && (easing in supportedWaapiEasing || supportsLinearEasing()) || isBezierDefinition(easing) || Array.isArray(easing) && easing.every(isWaapiSupportedEasing));
  }
  var cubicBezierAsString = ([a3, b3, c3, d3]) => `cubic-bezier(${a3}, ${b3}, ${c3}, ${d3})`;
  var supportedWaapiEasing = {
    linear: "linear",
    ease: "ease",
    easeIn: "ease-in",
    easeOut: "ease-out",
    easeInOut: "ease-in-out",
    circIn: /* @__PURE__ */ cubicBezierAsString([0, 0.65, 0.55, 1]),
    circOut: /* @__PURE__ */ cubicBezierAsString([0.55, 0, 1, 0.45]),
    backIn: /* @__PURE__ */ cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),
    backOut: /* @__PURE__ */ cubicBezierAsString([0.33, 1.53, 0.69, 0.99])
  };
  function mapEasingToNativeEasing(easing, duration) {
    if (!easing) {
      return void 0;
    } else if (typeof easing === "function" && supportsLinearEasing()) {
      return generateLinearEasing(easing, duration);
    } else if (isBezierDefinition(easing)) {
      return cubicBezierAsString(easing);
    } else if (Array.isArray(easing)) {
      return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) || supportedWaapiEasing.easeOut);
    } else {
      return supportedWaapiEasing[easing];
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs
  function startWaapiAnimation(element, valueName, keyframes4, { delay: delay2 = 0, duration = 300, repeat = 0, repeatType = "loop", ease: ease2 = "easeInOut", times } = {}) {
    const keyframeOptions = { [valueName]: keyframes4 };
    if (times)
      keyframeOptions.offset = times;
    const easing = mapEasingToNativeEasing(ease2, duration);
    if (Array.isArray(easing))
      keyframeOptions.easing = easing;
    return element.animate(keyframeOptions, {
      delay: delay2,
      duration,
      easing: !Array.isArray(easing) ? easing : "linear",
      fill: "both",
      iterations: repeat + 1,
      direction: repeatType === "reverse" ? "alternate" : "normal"
    });
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/attach-timeline.mjs
  function attachTimeline(animation, timeline) {
    animation.timeline = timeline;
    animation.onfinish = null;
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-waapi.mjs
  var supportsWaapi = /* @__PURE__ */ memo3(() => Object.hasOwnProperty.call(Element.prototype, "animate"));

  // packages/components/node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs
  var sampleDelta = 10;
  var maxDuration = 2e4;
  function requiresPregeneratedKeyframes(options2) {
    return isGenerator(options2.type) || options2.type === "spring" || !isWaapiSupportedEasing(options2.ease);
  }
  function pregenerateKeyframes(keyframes4, options2) {
    const sampleAnimation = new MainThreadAnimation({
      ...options2,
      keyframes: keyframes4,
      repeat: 0,
      delay: 0,
      isGenerator: true
    });
    let state = { done: false, value: keyframes4[0] };
    const pregeneratedKeyframes = [];
    let t4 = 0;
    while (!state.done && t4 < maxDuration) {
      state = sampleAnimation.sample(t4);
      pregeneratedKeyframes.push(state.value);
      t4 += sampleDelta;
    }
    return {
      times: void 0,
      keyframes: pregeneratedKeyframes,
      duration: t4 - sampleDelta,
      ease: "linear"
    };
  }
  var unsupportedEasingFunctions = {
    anticipate,
    backInOut,
    circInOut
  };
  function isUnsupportedEase(key) {
    return key in unsupportedEasingFunctions;
  }
  var AcceleratedAnimation = class extends BaseAnimation {
    constructor(options2) {
      super(options2);
      const { name, motionValue: motionValue2, element, keyframes: keyframes4 } = this.options;
      this.resolver = new DOMKeyframesResolver(keyframes4, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue2, element);
      this.resolver.scheduleResolve();
    }
    initPlayback(keyframes4, finalKeyframe) {
      var _a;
      let { duration = 300, times, ease: ease2, type, motionValue: motionValue2, name, startTime } = this.options;
      if (!((_a = motionValue2.owner) === null || _a === void 0 ? void 0 : _a.current)) {
        return false;
      }
      if (typeof ease2 === "string" && supportsLinearEasing() && isUnsupportedEase(ease2)) {
        ease2 = unsupportedEasingFunctions[ease2];
      }
      if (requiresPregeneratedKeyframes(this.options)) {
        const { onComplete, onUpdate, motionValue: motionValue3, element, ...options2 } = this.options;
        const pregeneratedAnimation = pregenerateKeyframes(keyframes4, options2);
        keyframes4 = pregeneratedAnimation.keyframes;
        if (keyframes4.length === 1) {
          keyframes4[1] = keyframes4[0];
        }
        duration = pregeneratedAnimation.duration;
        times = pregeneratedAnimation.times;
        ease2 = pregeneratedAnimation.ease;
        type = "keyframes";
      }
      const animation = startWaapiAnimation(motionValue2.owner.current, name, keyframes4, { ...this.options, duration, times, ease: ease2 });
      animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
      if (this.pendingTimeline) {
        attachTimeline(animation, this.pendingTimeline);
        this.pendingTimeline = void 0;
      } else {
        animation.onfinish = () => {
          const { onComplete } = this.options;
          motionValue2.set(getFinalKeyframe(keyframes4, this.options, finalKeyframe));
          onComplete && onComplete();
          this.cancel();
          this.resolveFinishedPromise();
        };
      }
      return {
        animation,
        duration,
        times,
        type,
        ease: ease2,
        keyframes: keyframes4
      };
    }
    get duration() {
      const { resolved } = this;
      if (!resolved)
        return 0;
      const { duration } = resolved;
      return millisecondsToSeconds(duration);
    }
    get time() {
      const { resolved } = this;
      if (!resolved)
        return 0;
      const { animation } = resolved;
      return millisecondsToSeconds(animation.currentTime || 0);
    }
    set time(newTime) {
      const { resolved } = this;
      if (!resolved)
        return;
      const { animation } = resolved;
      animation.currentTime = secondsToMilliseconds(newTime);
    }
    get speed() {
      const { resolved } = this;
      if (!resolved)
        return 1;
      const { animation } = resolved;
      return animation.playbackRate;
    }
    set speed(newSpeed) {
      const { resolved } = this;
      if (!resolved)
        return;
      const { animation } = resolved;
      animation.playbackRate = newSpeed;
    }
    get state() {
      const { resolved } = this;
      if (!resolved)
        return "idle";
      const { animation } = resolved;
      return animation.playState;
    }
    get startTime() {
      const { resolved } = this;
      if (!resolved)
        return null;
      const { animation } = resolved;
      return animation.startTime;
    }
    /**
     * Replace the default DocumentTimeline with another AnimationTimeline.
     * Currently used for scroll animations.
     */
    attachTimeline(timeline) {
      if (!this._resolved) {
        this.pendingTimeline = timeline;
      } else {
        const { resolved } = this;
        if (!resolved)
          return noop2;
        const { animation } = resolved;
        attachTimeline(animation, timeline);
      }
      return noop2;
    }
    play() {
      if (this.isStopped)
        return;
      const { resolved } = this;
      if (!resolved)
        return;
      const { animation } = resolved;
      if (animation.playState === "finished") {
        this.updateFinishedPromise();
      }
      animation.play();
    }
    pause() {
      const { resolved } = this;
      if (!resolved)
        return;
      const { animation } = resolved;
      animation.pause();
    }
    stop() {
      this.resolver.cancel();
      this.isStopped = true;
      if (this.state === "idle")
        return;
      this.resolveFinishedPromise();
      this.updateFinishedPromise();
      const { resolved } = this;
      if (!resolved)
        return;
      const { animation, keyframes: keyframes4, duration, type, ease: ease2, times } = resolved;
      if (animation.playState === "idle" || animation.playState === "finished") {
        return;
      }
      if (this.time) {
        const { motionValue: motionValue2, onUpdate, onComplete, element, ...options2 } = this.options;
        const sampleAnimation = new MainThreadAnimation({
          ...options2,
          keyframes: keyframes4,
          duration,
          type,
          ease: ease2,
          times,
          isGenerator: true
        });
        const sampleTime = secondsToMilliseconds(this.time);
        motionValue2.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);
      }
      const { onStop } = this.options;
      onStop && onStop();
      this.cancel();
    }
    complete() {
      const { resolved } = this;
      if (!resolved)
        return;
      resolved.animation.finish();
    }
    cancel() {
      const { resolved } = this;
      if (!resolved)
        return;
      resolved.animation.cancel();
    }
    static supports(options2) {
      const { motionValue: motionValue2, name, repeatDelay, repeatType, damping, type } = options2;
      return supportsWaapi() && name && acceleratedValues.has(name) && motionValue2 && motionValue2.owner && motionValue2.owner.current instanceof HTMLElement && /**
       * If we're outputting values to onUpdate then we can't use WAAPI as there's
       * no way to read the value from WAAPI every frame.
       */
      !motionValue2.owner.getProps().onUpdate && !repeatDelay && repeatType !== "mirror" && damping !== 0 && type !== "inertia";
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/scroll/supports.mjs
  var supportsScrollTimeline = memo3(() => window.ScrollTimeline !== void 0);

  // packages/components/node_modules/framer-motion/dist/es/animation/GroupPlaybackControls.mjs
  var GroupPlaybackControls = class {
    constructor(animations2) {
      this.stop = () => this.runAll("stop");
      this.animations = animations2.filter(Boolean);
    }
    then(onResolve, onReject) {
      return Promise.all(this.animations).then(onResolve).catch(onReject);
    }
    /**
     * TODO: Filter out cancelled or stopped animations before returning
     */
    getAll(propName) {
      return this.animations[0][propName];
    }
    setAll(propName, newValue) {
      for (let i3 = 0; i3 < this.animations.length; i3++) {
        this.animations[i3][propName] = newValue;
      }
    }
    attachTimeline(timeline, fallback) {
      const subscriptions = this.animations.map((animation) => {
        if (supportsScrollTimeline() && animation.attachTimeline) {
          return animation.attachTimeline(timeline);
        } else {
          return fallback(animation);
        }
      });
      return () => {
        subscriptions.forEach((cancel, i3) => {
          cancel && cancel();
          this.animations[i3].stop();
        });
      };
    }
    get time() {
      return this.getAll("time");
    }
    set time(time2) {
      this.setAll("time", time2);
    }
    get speed() {
      return this.getAll("speed");
    }
    set speed(speed) {
      this.setAll("speed", speed);
    }
    get startTime() {
      return this.getAll("startTime");
    }
    get duration() {
      let max3 = 0;
      for (let i3 = 0; i3 < this.animations.length; i3++) {
        max3 = Math.max(max3, this.animations[i3].duration);
      }
      return max3;
    }
    runAll(methodName) {
      this.animations.forEach((controls) => controls[methodName]());
    }
    flatten() {
      this.runAll("flatten");
    }
    play() {
      this.runAll("play");
    }
    pause() {
      this.runAll("pause");
    }
    cancel() {
      this.runAll("cancel");
    }
    complete() {
      this.runAll("complete");
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/animation/utils/is-transition-defined.mjs
  function isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from: from2, elapsed, ...transition }) {
    return !!Object.keys(transition).length;
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs
  var animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
    const valueTransition = getValueTransition(transition, name) || {};
    const delay2 = valueTransition.delay || transition.delay || 0;
    let { elapsed = 0 } = transition;
    elapsed = elapsed - secondsToMilliseconds(delay2);
    let options2 = {
      keyframes: Array.isArray(target) ? target : [null, target],
      ease: "easeOut",
      velocity: value.getVelocity(),
      ...valueTransition,
      delay: -elapsed,
      onUpdate: (v3) => {
        value.set(v3);
        valueTransition.onUpdate && valueTransition.onUpdate(v3);
      },
      onComplete: () => {
        onComplete();
        valueTransition.onComplete && valueTransition.onComplete();
      },
      name,
      motionValue: value,
      element: isHandoff ? void 0 : element
    };
    if (!isTransitionDefined(valueTransition)) {
      options2 = {
        ...options2,
        ...getDefaultTransition(name, options2)
      };
    }
    if (options2.duration) {
      options2.duration = secondsToMilliseconds(options2.duration);
    }
    if (options2.repeatDelay) {
      options2.repeatDelay = secondsToMilliseconds(options2.repeatDelay);
    }
    if (options2.from !== void 0) {
      options2.keyframes[0] = options2.from;
    }
    let shouldSkip = false;
    if (options2.type === false || options2.duration === 0 && !options2.repeatDelay) {
      options2.duration = 0;
      if (options2.delay === 0) {
        shouldSkip = true;
      }
    }
    if (instantAnimationState.current || MotionGlobalConfig.skipAnimations) {
      shouldSkip = true;
      options2.duration = 0;
      options2.delay = 0;
    }
    if (shouldSkip && !isHandoff && value.get() !== void 0) {
      const finalKeyframe = getFinalKeyframe(options2.keyframes, valueTransition);
      if (finalKeyframe !== void 0) {
        frame.update(() => {
          options2.onUpdate(finalKeyframe);
          options2.onComplete();
        });
        return new GroupPlaybackControls([]);
      }
    }
    if (!isHandoff && AcceleratedAnimation.supports(options2)) {
      return new AcceleratedAnimation(options2);
    } else {
      return new MainThreadAnimation(options2);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/resolve-value.mjs
  var isCustomValue = (v3) => {
    return Boolean(v3 && typeof v3 === "object" && v3.mix && v3.toValue);
  };
  var resolveFinalValueInKeyframes = (v3) => {
    return isKeyframesTarget(v3) ? v3[v3.length - 1] || 0 : v3;
  };

  // packages/components/node_modules/framer-motion/dist/es/utils/array.mjs
  function addUniqueItem(arr, item2) {
    if (arr.indexOf(item2) === -1)
      arr.push(item2);
  }
  function removeItem(arr, item2) {
    const index2 = arr.indexOf(item2);
    if (index2 > -1)
      arr.splice(index2, 1);
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/subscription-manager.mjs
  var SubscriptionManager = class {
    constructor() {
      this.subscriptions = [];
    }
    add(handler) {
      addUniqueItem(this.subscriptions, handler);
      return () => removeItem(this.subscriptions, handler);
    }
    notify(a3, b3, c3) {
      const numSubscriptions = this.subscriptions.length;
      if (!numSubscriptions)
        return;
      if (numSubscriptions === 1) {
        this.subscriptions[0](a3, b3, c3);
      } else {
        for (let i3 = 0; i3 < numSubscriptions; i3++) {
          const handler = this.subscriptions[i3];
          handler && handler(a3, b3, c3);
        }
      }
    }
    getSize() {
      return this.subscriptions.length;
    }
    clear() {
      this.subscriptions.length = 0;
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/value/index.mjs
  var MAX_VELOCITY_DELTA = 30;
  var isFloat = (value) => {
    return !isNaN(parseFloat(value));
  };
  var collectMotionValues = {
    current: void 0
  };
  var MotionValue = class {
    /**
     * @param init - The initiating value
     * @param config - Optional configuration options
     *
     * -  `transformer`: A function to transform incoming values with.
     *
     * @internal
     */
    constructor(init2, options2 = {}) {
      this.version = "11.15.0";
      this.canTrackVelocity = null;
      this.events = {};
      this.updateAndNotify = (v3, render = true) => {
        const currentTime = time.now();
        if (this.updatedAt !== currentTime) {
          this.setPrevFrameValue();
        }
        this.prev = this.current;
        this.setCurrent(v3);
        if (this.current !== this.prev && this.events.change) {
          this.events.change.notify(this.current);
        }
        if (render && this.events.renderRequest) {
          this.events.renderRequest.notify(this.current);
        }
      };
      this.hasAnimated = false;
      this.setCurrent(init2);
      this.owner = options2.owner;
    }
    setCurrent(current) {
      this.current = current;
      this.updatedAt = time.now();
      if (this.canTrackVelocity === null && current !== void 0) {
        this.canTrackVelocity = isFloat(this.current);
      }
    }
    setPrevFrameValue(prevFrameValue = this.current) {
      this.prevFrameValue = prevFrameValue;
      this.prevUpdatedAt = this.updatedAt;
    }
    /**
     * Adds a function that will be notified when the `MotionValue` is updated.
     *
     * It returns a function that, when called, will cancel the subscription.
     *
     * When calling `onChange` inside a React component, it should be wrapped with the
     * `useEffect` hook. As it returns an unsubscribe function, this should be returned
     * from the `useEffect` function to ensure you don't add duplicate subscribers..
     *
     * ```jsx
     * export const MyComponent = () => {
     *   const x = useMotionValue(0)
     *   const y = useMotionValue(0)
     *   const opacity = useMotionValue(1)
     *
     *   useEffect(() => {
     *     function updateOpacity() {
     *       const maxXY = Math.max(x.get(), y.get())
     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
     *       opacity.set(newOpacity)
     *     }
     *
     *     const unsubscribeX = x.on("change", updateOpacity)
     *     const unsubscribeY = y.on("change", updateOpacity)
     *
     *     return () => {
     *       unsubscribeX()
     *       unsubscribeY()
     *     }
     *   }, [])
     *
     *   return <motion.div style={{ x }} />
     * }
     * ```
     *
     * @param subscriber - A function that receives the latest value.
     * @returns A function that, when called, will cancel this subscription.
     *
     * @deprecated
     */
    onChange(subscription) {
      if (true) {
        warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on("change", callback).`);
      }
      return this.on("change", subscription);
    }
    on(eventName, callback) {
      if (!this.events[eventName]) {
        this.events[eventName] = new SubscriptionManager();
      }
      const unsubscribe = this.events[eventName].add(callback);
      if (eventName === "change") {
        return () => {
          unsubscribe();
          frame.read(() => {
            if (!this.events.change.getSize()) {
              this.stop();
            }
          });
        };
      }
      return unsubscribe;
    }
    clearListeners() {
      for (const eventManagers in this.events) {
        this.events[eventManagers].clear();
      }
    }
    /**
     * Attaches a passive effect to the `MotionValue`.
     *
     * @internal
     */
    attach(passiveEffect, stopPassiveEffect) {
      this.passiveEffect = passiveEffect;
      this.stopPassiveEffect = stopPassiveEffect;
    }
    /**
     * Sets the state of the `MotionValue`.
     *
     * @remarks
     *
     * ```jsx
     * const x = useMotionValue(0)
     * x.set(10)
     * ```
     *
     * @param latest - Latest value to set.
     * @param render - Whether to notify render subscribers. Defaults to `true`
     *
     * @public
     */
    set(v3, render = true) {
      if (!render || !this.passiveEffect) {
        this.updateAndNotify(v3, render);
      } else {
        this.passiveEffect(v3, this.updateAndNotify);
      }
    }
    setWithVelocity(prev2, current, delta) {
      this.set(current);
      this.prev = void 0;
      this.prevFrameValue = prev2;
      this.prevUpdatedAt = this.updatedAt - delta;
    }
    /**
     * Set the state of the `MotionValue`, stopping any active animations,
     * effects, and resets velocity to `0`.
     */
    jump(v3, endAnimation = true) {
      this.updateAndNotify(v3);
      this.prev = v3;
      this.prevUpdatedAt = this.prevFrameValue = void 0;
      endAnimation && this.stop();
      if (this.stopPassiveEffect)
        this.stopPassiveEffect();
    }
    /**
     * Returns the latest state of `MotionValue`
     *
     * @returns - The latest state of `MotionValue`
     *
     * @public
     */
    get() {
      if (collectMotionValues.current) {
        collectMotionValues.current.push(this);
      }
      return this.current;
    }
    /**
     * @public
     */
    getPrevious() {
      return this.prev;
    }
    /**
     * Returns the latest velocity of `MotionValue`
     *
     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
     *
     * @public
     */
    getVelocity() {
      const currentTime = time.now();
      if (!this.canTrackVelocity || this.prevFrameValue === void 0 || currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {
        return 0;
      }
      const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);
      return velocityPerSecond(parseFloat(this.current) - parseFloat(this.prevFrameValue), delta);
    }
    /**
     * Registers a new animation to control this `MotionValue`. Only one
     * animation can drive a `MotionValue` at one time.
     *
     * ```jsx
     * value.start()
     * ```
     *
     * @param animation - A function that starts the provided animation
     *
     * @internal
     */
    start(startAnimation) {
      this.stop();
      return new Promise((resolve) => {
        this.hasAnimated = true;
        this.animation = startAnimation(resolve);
        if (this.events.animationStart) {
          this.events.animationStart.notify();
        }
      }).then(() => {
        if (this.events.animationComplete) {
          this.events.animationComplete.notify();
        }
        this.clearAnimation();
      });
    }
    /**
     * Stop the currently active animation.
     *
     * @public
     */
    stop() {
      if (this.animation) {
        this.animation.stop();
        if (this.events.animationCancel) {
          this.events.animationCancel.notify();
        }
      }
      this.clearAnimation();
    }
    /**
     * Returns `true` if this value is currently animating.
     *
     * @public
     */
    isAnimating() {
      return !!this.animation;
    }
    clearAnimation() {
      delete this.animation;
    }
    /**
     * Destroy and clean up subscribers to this `MotionValue`.
     *
     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
     * created a `MotionValue` via the `motionValue` function.
     *
     * @public
     */
    destroy() {
      this.clearListeners();
      this.stop();
      if (this.stopPassiveEffect) {
        this.stopPassiveEffect();
      }
    }
  };
  function motionValue(init2, options2) {
    return new MotionValue(init2, options2);
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/setters.mjs
  function setMotionValue(visualElement, key, value) {
    if (visualElement.hasValue(key)) {
      visualElement.getValue(key).set(value);
    } else {
      visualElement.addValue(key, motionValue(value));
    }
  }
  function setTarget(visualElement, definition) {
    const resolved = resolveVariant(visualElement, definition);
    let { transitionEnd = {}, transition = {}, ...target } = resolved || {};
    target = { ...target, ...transitionEnd };
    for (const key in target) {
      const value = resolveFinalValueInKeyframes(target[key]);
      setMotionValue(visualElement, key, value);
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs
  var camelToDash = (str) => str.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase();

  // packages/components/node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs
  var optimizedAppearDataId = "framerAppearId";
  var optimizedAppearDataAttribute = "data-" + camelToDash(optimizedAppearDataId);

  // packages/components/node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs
  function getOptimisedAppearId(visualElement) {
    return visualElement.props[optimizedAppearDataAttribute];
  }

  // packages/components/node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs
  var isMotionValue = (value) => Boolean(value && value.getVelocity);

  // packages/components/node_modules/framer-motion/dist/es/value/use-will-change/is.mjs
  function isWillChangeMotionValue(value) {
    return Boolean(isMotionValue(value) && value.add);
  }

  // packages/components/node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.mjs
  function addValueToWillChange(visualElement, key) {
    const willChange = visualElement.getValue("willChange");
    if (isWillChangeMotionValue(willChange)) {
      return willChange.add(key);
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs
  function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
    needsAnimating[key] = false;
    return shouldBlock;
  }
  function animateTarget(visualElement, targetAndTransition, { delay: delay2 = 0, transitionOverride, type } = {}) {
    var _a;
    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;
    if (transitionOverride)
      transition = transitionOverride;
    const animations2 = [];
    const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];
    for (const key in target) {
      const value = visualElement.getValue(key, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);
      const valueTarget = target[key];
      if (valueTarget === void 0 || animationTypeState && shouldBlockAnimation(animationTypeState, key)) {
        continue;
      }
      const valueTransition = {
        delay: delay2,
        ...getValueTransition(transition || {}, key)
      };
      let isHandoff = false;
      if (window.MotionHandoffAnimation) {
        const appearId = getOptimisedAppearId(visualElement);
        if (appearId) {
          const startTime = window.MotionHandoffAnimation(appearId, key, frame);
          if (startTime !== null) {
            valueTransition.startTime = startTime;
            isHandoff = true;
          }
        }
      }
      addValueToWillChange(visualElement, key);
      value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key) ? { type: false } : valueTransition, visualElement, isHandoff));
      const animation = value.animation;
      if (animation) {
        animations2.push(animation);
      }
    }
    if (transitionEnd) {
      Promise.all(animations2).then(() => {
        frame.update(() => {
          transitionEnd && setTarget(visualElement, transitionEnd);
        });
      });
    }
    return animations2;
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs
  function animateVariant(visualElement, variant, options2 = {}) {
    var _a;
    const resolved = resolveVariant(visualElement, variant, options2.type === "exit" ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom : void 0);
    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
    if (options2.transitionOverride) {
      transition = options2.transitionOverride;
    }
    const getAnimation = resolved ? () => Promise.all(animateTarget(visualElement, resolved, options2)) : () => Promise.resolve();
    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size ? (forwardDelay = 0) => {
      const { delayChildren = 0, staggerChildren, staggerDirection } = transition;
      return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options2);
    } : () => Promise.resolve();
    const { when } = transition;
    if (when) {
      const [first, last] = when === "beforeChildren" ? [getAnimation, getChildAnimations] : [getChildAnimations, getAnimation];
      return first().then(() => last());
    } else {
      return Promise.all([getAnimation(), getChildAnimations(options2.delay)]);
    }
  }
  function animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options2) {
    const animations2 = [];
    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;
    const generateStaggerDuration = staggerDirection === 1 ? (i3 = 0) => i3 * staggerChildren : (i3 = 0) => maxStaggerDuration - i3 * staggerChildren;
    Array.from(visualElement.variantChildren).sort(sortByTreeOrder).forEach((child, i3) => {
      child.notify("AnimationStart", variant);
      animations2.push(animateVariant(child, variant, {
        ...options2,
        delay: delayChildren + generateStaggerDuration(i3)
      }).then(() => child.notify("AnimationComplete", variant)));
    });
    return Promise.all(animations2);
  }
  function sortByTreeOrder(a3, b3) {
    return a3.sortNodePosition(b3);
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs
  function animateVisualElement(visualElement, definition, options2 = {}) {
    visualElement.notify("AnimationStart", definition);
    let animation;
    if (Array.isArray(definition)) {
      const animations2 = definition.map((variant) => animateVariant(visualElement, variant, options2));
      animation = Promise.all(animations2);
    } else if (typeof definition === "string") {
      animation = animateVariant(visualElement, definition, options2);
    } else {
      const resolvedDefinition = typeof definition === "function" ? resolveVariant(visualElement, definition, options2.custom) : definition;
      animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options2));
    }
    return animation.then(() => {
      visualElement.notify("AnimationComplete", definition);
    });
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/get-variant-context.mjs
  var numVariantProps = variantProps.length;
  function getVariantContext(visualElement) {
    if (!visualElement)
      return void 0;
    if (!visualElement.isControllingVariants) {
      const context2 = visualElement.parent ? getVariantContext(visualElement.parent) || {} : {};
      if (visualElement.props.initial !== void 0) {
        context2.initial = visualElement.props.initial;
      }
      return context2;
    }
    const context = {};
    for (let i3 = 0; i3 < numVariantProps; i3++) {
      const name = variantProps[i3];
      const prop = visualElement.props[name];
      if (isVariantLabel(prop) || prop === false) {
        context[name] = prop;
      }
    }
    return context;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/animation-state.mjs
  var reversePriorityOrder = [...variantPriorityOrder].reverse();
  var numAnimationTypes = variantPriorityOrder.length;
  function animateList(visualElement) {
    return (animations2) => Promise.all(animations2.map(({ animation, options: options2 }) => animateVisualElement(visualElement, animation, options2)));
  }
  function createAnimationState(visualElement) {
    let animate = animateList(visualElement);
    let state = createState();
    let isInitialRender = true;
    const buildResolvedTypeValues = (type) => (acc, definition) => {
      var _a;
      const resolved = resolveVariant(visualElement, definition, type === "exit" ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom : void 0);
      if (resolved) {
        const { transition, transitionEnd, ...target } = resolved;
        acc = { ...acc, ...target, ...transitionEnd };
      }
      return acc;
    };
    function setAnimateFunction(makeAnimator) {
      animate = makeAnimator(visualElement);
    }
    function animateChanges(changedActiveType) {
      const { props } = visualElement;
      const context = getVariantContext(visualElement.parent) || {};
      const animations2 = [];
      const removedKeys = /* @__PURE__ */ new Set();
      let encounteredKeys = {};
      let removedVariantIndex = Infinity;
      for (let i3 = 0; i3 < numAnimationTypes; i3++) {
        const type = reversePriorityOrder[i3];
        const typeState = state[type];
        const prop = props[type] !== void 0 ? props[type] : context[type];
        const propIsVariant = isVariantLabel(prop);
        const activeDelta = type === changedActiveType ? typeState.isActive : null;
        if (activeDelta === false)
          removedVariantIndex = i3;
        let isInherited = prop === context[type] && prop !== props[type] && propIsVariant;
        if (isInherited && isInitialRender && visualElement.manuallyAnimateOnMount) {
          isInherited = false;
        }
        typeState.protectedKeys = { ...encounteredKeys };
        if (
          // If it isn't active and hasn't *just* been set as inactive
          !typeState.isActive && activeDelta === null || // If we didn't and don't have any defined prop for this animation type
          !prop && !typeState.prevProp || // Or if the prop doesn't define an animation
          isAnimationControls(prop) || typeof prop === "boolean"
        ) {
          continue;
        }
        const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
        let shouldAnimateType = variantDidChange || // If we're making this variant active, we want to always make it active
        type === changedActiveType && typeState.isActive && !isInherited && propIsVariant || // If we removed a higher-priority variant (i is in reverse order)
        i3 > removedVariantIndex && propIsVariant;
        let handledRemovedValues = false;
        const definitionList = Array.isArray(prop) ? prop : [prop];
        let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
        if (activeDelta === false)
          resolvedValues = {};
        const { prevResolvedValues = {} } = typeState;
        const allKeys = {
          ...prevResolvedValues,
          ...resolvedValues
        };
        const markToAnimate = (key) => {
          shouldAnimateType = true;
          if (removedKeys.has(key)) {
            handledRemovedValues = true;
            removedKeys.delete(key);
          }
          typeState.needsAnimating[key] = true;
          const motionValue2 = visualElement.getValue(key);
          if (motionValue2)
            motionValue2.liveStyle = false;
        };
        for (const key in allKeys) {
          const next2 = resolvedValues[key];
          const prev2 = prevResolvedValues[key];
          if (encounteredKeys.hasOwnProperty(key))
            continue;
          let valueHasChanged = false;
          if (isKeyframesTarget(next2) && isKeyframesTarget(prev2)) {
            valueHasChanged = !shallowCompare(next2, prev2);
          } else {
            valueHasChanged = next2 !== prev2;
          }
          if (valueHasChanged) {
            if (next2 !== void 0 && next2 !== null) {
              markToAnimate(key);
            } else {
              removedKeys.add(key);
            }
          } else if (next2 !== void 0 && removedKeys.has(key)) {
            markToAnimate(key);
          } else {
            typeState.protectedKeys[key] = true;
          }
        }
        typeState.prevProp = prop;
        typeState.prevResolvedValues = resolvedValues;
        if (typeState.isActive) {
          encounteredKeys = { ...encounteredKeys, ...resolvedValues };
        }
        if (isInitialRender && visualElement.blockInitialAnimation) {
          shouldAnimateType = false;
        }
        const willAnimateViaParent = isInherited && variantDidChange;
        const needsAnimating = !willAnimateViaParent || handledRemovedValues;
        if (shouldAnimateType && needsAnimating) {
          animations2.push(...definitionList.map((animation) => ({
            animation,
            options: { type }
          })));
        }
      }
      if (removedKeys.size) {
        const fallbackAnimation = {};
        removedKeys.forEach((key) => {
          const fallbackTarget = visualElement.getBaseTarget(key);
          const motionValue2 = visualElement.getValue(key);
          if (motionValue2)
            motionValue2.liveStyle = true;
          fallbackAnimation[key] = fallbackTarget !== null && fallbackTarget !== void 0 ? fallbackTarget : null;
        });
        animations2.push({ animation: fallbackAnimation });
      }
      let shouldAnimate = Boolean(animations2.length);
      if (isInitialRender && (props.initial === false || props.initial === props.animate) && !visualElement.manuallyAnimateOnMount) {
        shouldAnimate = false;
      }
      isInitialRender = false;
      return shouldAnimate ? animate(animations2) : Promise.resolve();
    }
    function setActive(type, isActive) {
      var _a;
      if (state[type].isActive === isActive)
        return Promise.resolve();
      (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
        var _a2;
        return (_a2 = child.animationState) === null || _a2 === void 0 ? void 0 : _a2.setActive(type, isActive);
      });
      state[type].isActive = isActive;
      const animations2 = animateChanges(type);
      for (const key in state) {
        state[key].protectedKeys = {};
      }
      return animations2;
    }
    return {
      animateChanges,
      setActive,
      setAnimateFunction,
      getState: () => state,
      reset: () => {
        state = createState();
        isInitialRender = true;
      }
    };
  }
  function checkVariantsDidChange(prev2, next2) {
    if (typeof next2 === "string") {
      return next2 !== prev2;
    } else if (Array.isArray(next2)) {
      return !shallowCompare(next2, prev2);
    }
    return false;
  }
  function createTypeState(isActive = false) {
    return {
      isActive,
      protectedKeys: {},
      needsAnimating: {},
      prevResolvedValues: {}
    };
  }
  function createState() {
    return {
      animate: createTypeState(true),
      whileInView: createTypeState(),
      whileHover: createTypeState(),
      whileTap: createTypeState(),
      whileDrag: createTypeState(),
      whileFocus: createTypeState(),
      exit: createTypeState()
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/features/Feature.mjs
  var Feature = class {
    constructor(node2) {
      this.isMounted = false;
      this.node = node2;
    }
    update() {
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/motion/features/animation/index.mjs
  var AnimationFeature = class extends Feature {
    /**
     * We dynamically generate the AnimationState manager as it contains a reference
     * to the underlying animation library. We only want to load that if we load this,
     * so people can optionally code split it out using the `m` component.
     */
    constructor(node2) {
      super(node2);
      node2.animationState || (node2.animationState = createAnimationState(node2));
    }
    updateAnimationControlsSubscription() {
      const { animate } = this.node.getProps();
      if (isAnimationControls(animate)) {
        this.unmountControls = animate.subscribe(this.node);
      }
    }
    /**
     * Subscribe any provided AnimationControls to the component's VisualElement
     */
    mount() {
      this.updateAnimationControlsSubscription();
    }
    update() {
      const { animate } = this.node.getProps();
      const { animate: prevAnimate } = this.node.prevProps || {};
      if (animate !== prevAnimate) {
        this.updateAnimationControlsSubscription();
      }
    }
    unmount() {
      var _a;
      this.node.animationState.reset();
      (_a = this.unmountControls) === null || _a === void 0 ? void 0 : _a.call(this);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs
  var id = 0;
  var ExitAnimationFeature = class extends Feature {
    constructor() {
      super(...arguments);
      this.id = id++;
    }
    update() {
      if (!this.node.presenceContext)
        return;
      const { isPresent, onExitComplete } = this.node.presenceContext;
      const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};
      if (!this.node.animationState || isPresent === prevIsPresent) {
        return;
      }
      const exitAnimation = this.node.animationState.setActive("exit", !isPresent);
      if (onExitComplete && !isPresent) {
        exitAnimation.then(() => onExitComplete(this.id));
      }
    }
    mount() {
      const { register } = this.node.presenceContext || {};
      if (register) {
        this.unmount = register(this.id);
      }
    }
    unmount() {
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/motion/features/animations.mjs
  var animations = {
    animation: {
      Feature: AnimationFeature
    },
    exit: {
      Feature: ExitAnimationFeature
    }
  };

  // node_modules/motion-dom/dist/es/gestures/drag/state/is-active.mjs
  var isDragging = {
    x: false,
    y: false
  };
  function isDragActive() {
    return isDragging.x || isDragging.y;
  }

  // node_modules/motion-dom/dist/es/utils/resolve-elements.mjs
  function resolveElements(elementOrSelector, scope, selectorCache) {
    var _a;
    if (elementOrSelector instanceof Element) {
      return [elementOrSelector];
    } else if (typeof elementOrSelector === "string") {
      let root = document;
      if (scope) {
        root = scope.current;
      }
      const elements2 = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);
      return elements2 ? Array.from(elements2) : [];
    }
    return Array.from(elementOrSelector);
  }

  // node_modules/motion-dom/dist/es/gestures/utils/setup.mjs
  function setupGesture(elementOrSelector, options2) {
    const elements2 = resolveElements(elementOrSelector);
    const gestureAbortController = new AbortController();
    const eventOptions = {
      passive: true,
      ...options2,
      signal: gestureAbortController.signal
    };
    const cancel = () => gestureAbortController.abort();
    return [elements2, eventOptions, cancel];
  }

  // node_modules/motion-dom/dist/es/gestures/hover.mjs
  function filterEvents(callback) {
    return (event) => {
      if (event.pointerType === "touch" || isDragActive())
        return;
      callback(event);
    };
  }
  function hover(elementOrSelector, onHoverStart, options2 = {}) {
    const [elements2, eventOptions, cancel] = setupGesture(elementOrSelector, options2);
    const onPointerEnter = filterEvents((enterEvent) => {
      const { target } = enterEvent;
      const onHoverEnd = onHoverStart(enterEvent);
      if (!onHoverEnd || !target)
        return;
      const onPointerLeave = filterEvents((leaveEvent) => {
        onHoverEnd(leaveEvent);
        target.removeEventListener("pointerleave", onPointerLeave);
      });
      target.addEventListener("pointerleave", onPointerLeave, eventOptions);
    });
    elements2.forEach((element) => {
      element.addEventListener("pointerenter", onPointerEnter, eventOptions);
    });
    return cancel;
  }

  // node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs
  var isPrimaryPointer = (event) => {
    if (event.pointerType === "mouse") {
      return typeof event.button !== "number" || event.button <= 0;
    } else {
      return event.isPrimary !== false;
    }
  };

  // node_modules/motion-dom/dist/es/gestures/press/utils/state.mjs
  var isPressing = /* @__PURE__ */ new WeakSet();

  // node_modules/motion-dom/dist/es/gestures/press/utils/keyboard.mjs
  function filterEvents2(callback) {
    return (event) => {
      if (event.key !== "Enter")
        return;
      callback(event);
    };
  }
  function firePointerEvent(target, type) {
    target.dispatchEvent(new PointerEvent("pointer" + type, { isPrimary: true, bubbles: true }));
  }
  var enableKeyboardPress = (focusEvent, eventOptions) => {
    const element = focusEvent.currentTarget;
    if (!element)
      return;
    const handleKeydown = filterEvents2(() => {
      if (isPressing.has(element))
        return;
      firePointerEvent(element, "down");
      const handleKeyup = filterEvents2(() => {
        firePointerEvent(element, "up");
      });
      const handleBlur = () => firePointerEvent(element, "cancel");
      element.addEventListener("keyup", handleKeyup, eventOptions);
      element.addEventListener("blur", handleBlur, eventOptions);
    });
    element.addEventListener("keydown", handleKeydown, eventOptions);
    element.addEventListener("blur", () => element.removeEventListener("keydown", handleKeydown), eventOptions);
  };

  // node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.mjs
  var focusableElements = /* @__PURE__ */ new Set([
    "BUTTON",
    "INPUT",
    "SELECT",
    "TEXTAREA",
    "A"
  ]);
  function isElementKeyboardAccessible(element) {
    return focusableElements.has(element.tagName) || element.tabIndex !== -1;
  }

  // node_modules/motion-dom/dist/es/gestures/utils/is-node-or-child.mjs
  var isNodeOrChild = (parent, child) => {
    if (!child) {
      return false;
    } else if (parent === child) {
      return true;
    } else {
      return isNodeOrChild(parent, child.parentElement);
    }
  };

  // node_modules/motion-dom/dist/es/gestures/press/index.mjs
  function isValidPressEvent(event) {
    return isPrimaryPointer(event) && !isDragActive();
  }
  function press(elementOrSelector, onPressStart, options2 = {}) {
    const [elements2, eventOptions, cancelEvents] = setupGesture(elementOrSelector, options2);
    const startPress = (startEvent) => {
      const element = startEvent.currentTarget;
      if (!isValidPressEvent(startEvent) || isPressing.has(element))
        return;
      isPressing.add(element);
      const onPressEnd = onPressStart(startEvent);
      const onPointerEnd = (endEvent, success) => {
        window.removeEventListener("pointerup", onPointerUp);
        window.removeEventListener("pointercancel", onPointerCancel);
        if (!isValidPressEvent(endEvent) || !isPressing.has(element)) {
          return;
        }
        isPressing.delete(element);
        if (onPressEnd) {
          onPressEnd(endEvent, { success });
        }
      };
      const onPointerUp = (upEvent) => {
        onPointerEnd(upEvent, options2.useGlobalTarget || isNodeOrChild(element, upEvent.target));
      };
      const onPointerCancel = (cancelEvent) => {
        onPointerEnd(cancelEvent, false);
      };
      window.addEventListener("pointerup", onPointerUp, eventOptions);
      window.addEventListener("pointercancel", onPointerCancel, eventOptions);
    };
    elements2.forEach((element) => {
      if (!isElementKeyboardAccessible(element)) {
        element.tabIndex = 0;
      }
      const target = options2.useGlobalTarget ? window : element;
      target.addEventListener("pointerdown", startPress, eventOptions);
      element.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions), eventOptions);
    });
    return cancelEvents;
  }

  // node_modules/motion-dom/dist/es/gestures/drag/state/set-active.mjs
  function setDragLock(axis) {
    if (axis === "x" || axis === "y") {
      if (isDragging[axis]) {
        return null;
      } else {
        isDragging[axis] = true;
        return () => {
          isDragging[axis] = false;
        };
      }
    } else {
      if (isDragging.x || isDragging.y) {
        return null;
      } else {
        isDragging.x = isDragging.y = true;
        return () => {
          isDragging.x = isDragging.y = false;
        };
      }
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/events/event-info.mjs
  function extractEventInfo(event) {
    return {
      point: {
        x: event.pageX,
        y: event.pageY
      }
    };
  }
  var addPointerInfo = (handler) => {
    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));
  };

  // packages/components/node_modules/framer-motion/dist/es/events/add-dom-event.mjs
  function addDomEvent(target, eventName, handler, options2 = { passive: true }) {
    target.addEventListener(eventName, handler, options2);
    return () => target.removeEventListener(eventName, handler);
  }

  // packages/components/node_modules/framer-motion/dist/es/events/add-pointer-event.mjs
  function addPointerEvent(target, eventName, handler, options2) {
    return addDomEvent(target, eventName, addPointerInfo(handler), options2);
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/distance.mjs
  var distance = (a3, b3) => Math.abs(a3 - b3);
  function distance2D(a3, b3) {
    const xDelta = distance(a3.x, b3.x);
    const yDelta = distance(a3.y, b3.y);
    return Math.sqrt(xDelta ** 2 + yDelta ** 2);
  }

  // packages/components/node_modules/framer-motion/dist/es/gestures/pan/PanSession.mjs
  var PanSession = class {
    constructor(event, handlers, { transformPagePoint, contextWindow, dragSnapToOrigin = false } = {}) {
      this.startEvent = null;
      this.lastMoveEvent = null;
      this.lastMoveEventInfo = null;
      this.handlers = {};
      this.contextWindow = window;
      this.updatePoint = () => {
        if (!(this.lastMoveEvent && this.lastMoveEventInfo))
          return;
        const info2 = getPanInfo(this.lastMoveEventInfo, this.history);
        const isPanStarted = this.startEvent !== null;
        const isDistancePastThreshold = distance2D(info2.offset, { x: 0, y: 0 }) >= 3;
        if (!isPanStarted && !isDistancePastThreshold)
          return;
        const { point: point2 } = info2;
        const { timestamp: timestamp2 } = frameData;
        this.history.push({ ...point2, timestamp: timestamp2 });
        const { onStart, onMove } = this.handlers;
        if (!isPanStarted) {
          onStart && onStart(this.lastMoveEvent, info2);
          this.startEvent = this.lastMoveEvent;
        }
        onMove && onMove(this.lastMoveEvent, info2);
      };
      this.handlePointerMove = (event2, info2) => {
        this.lastMoveEvent = event2;
        this.lastMoveEventInfo = transformPoint(info2, this.transformPagePoint);
        frame.update(this.updatePoint, true);
      };
      this.handlePointerUp = (event2, info2) => {
        this.end();
        const { onEnd, onSessionEnd, resumeAnimation } = this.handlers;
        if (this.dragSnapToOrigin)
          resumeAnimation && resumeAnimation();
        if (!(this.lastMoveEvent && this.lastMoveEventInfo))
          return;
        const panInfo = getPanInfo(event2.type === "pointercancel" ? this.lastMoveEventInfo : transformPoint(info2, this.transformPagePoint), this.history);
        if (this.startEvent && onEnd) {
          onEnd(event2, panInfo);
        }
        onSessionEnd && onSessionEnd(event2, panInfo);
      };
      if (!isPrimaryPointer(event))
        return;
      this.dragSnapToOrigin = dragSnapToOrigin;
      this.handlers = handlers;
      this.transformPagePoint = transformPagePoint;
      this.contextWindow = contextWindow || window;
      const info = extractEventInfo(event);
      const initialInfo = transformPoint(info, this.transformPagePoint);
      const { point } = initialInfo;
      const { timestamp } = frameData;
      this.history = [{ ...point, timestamp }];
      const { onSessionStart } = handlers;
      onSessionStart && onSessionStart(event, getPanInfo(initialInfo, this.history));
      this.removeListeners = pipe(addPointerEvent(this.contextWindow, "pointermove", this.handlePointerMove), addPointerEvent(this.contextWindow, "pointerup", this.handlePointerUp), addPointerEvent(this.contextWindow, "pointercancel", this.handlePointerUp));
    }
    updateHandlers(handlers) {
      this.handlers = handlers;
    }
    end() {
      this.removeListeners && this.removeListeners();
      cancelFrame(this.updatePoint);
    }
  };
  function transformPoint(info, transformPagePoint) {
    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;
  }
  function subtractPoint(a3, b3) {
    return { x: a3.x - b3.x, y: a3.y - b3.y };
  }
  function getPanInfo({ point }, history) {
    return {
      point,
      delta: subtractPoint(point, lastDevicePoint(history)),
      offset: subtractPoint(point, startDevicePoint(history)),
      velocity: getVelocity(history, 0.1)
    };
  }
  function startDevicePoint(history) {
    return history[0];
  }
  function lastDevicePoint(history) {
    return history[history.length - 1];
  }
  function getVelocity(history, timeDelta) {
    if (history.length < 2) {
      return { x: 0, y: 0 };
    }
    let i3 = history.length - 1;
    let timestampedPoint = null;
    const lastPoint = lastDevicePoint(history);
    while (i3 >= 0) {
      timestampedPoint = history[i3];
      if (lastPoint.timestamp - timestampedPoint.timestamp > secondsToMilliseconds(timeDelta)) {
        break;
      }
      i3--;
    }
    if (!timestampedPoint) {
      return { x: 0, y: 0 };
    }
    const time2 = millisecondsToSeconds(lastPoint.timestamp - timestampedPoint.timestamp);
    if (time2 === 0) {
      return { x: 0, y: 0 };
    }
    const currentVelocity = {
      x: (lastPoint.x - timestampedPoint.x) / time2,
      y: (lastPoint.y - timestampedPoint.y) / time2
    };
    if (currentVelocity.x === Infinity) {
      currentVelocity.x = 0;
    }
    if (currentVelocity.y === Infinity) {
      currentVelocity.y = 0;
    }
    return currentVelocity;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/is-ref-object.mjs
  function isRefObject(ref) {
    return ref && typeof ref === "object" && Object.prototype.hasOwnProperty.call(ref, "current");
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs
  var SCALE_PRECISION = 1e-4;
  var SCALE_MIN = 1 - SCALE_PRECISION;
  var SCALE_MAX = 1 + SCALE_PRECISION;
  var TRANSLATE_PRECISION = 0.01;
  var TRANSLATE_MIN = 0 - TRANSLATE_PRECISION;
  var TRANSLATE_MAX = 0 + TRANSLATE_PRECISION;
  function calcLength(axis) {
    return axis.max - axis.min;
  }
  function isNear(value, target, maxDistance) {
    return Math.abs(value - target) <= maxDistance;
  }
  function calcAxisDelta(delta, source, target, origin = 0.5) {
    delta.origin = origin;
    delta.originPoint = mixNumber(source.min, source.max, delta.origin);
    delta.scale = calcLength(target) / calcLength(source);
    delta.translate = mixNumber(target.min, target.max, delta.origin) - delta.originPoint;
    if (delta.scale >= SCALE_MIN && delta.scale <= SCALE_MAX || isNaN(delta.scale)) {
      delta.scale = 1;
    }
    if (delta.translate >= TRANSLATE_MIN && delta.translate <= TRANSLATE_MAX || isNaN(delta.translate)) {
      delta.translate = 0;
    }
  }
  function calcBoxDelta(delta, source, target, origin) {
    calcAxisDelta(delta.x, source.x, target.x, origin ? origin.originX : void 0);
    calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : void 0);
  }
  function calcRelativeAxis(target, relative, parent) {
    target.min = parent.min + relative.min;
    target.max = target.min + calcLength(relative);
  }
  function calcRelativeBox(target, relative, parent) {
    calcRelativeAxis(target.x, relative.x, parent.x);
    calcRelativeAxis(target.y, relative.y, parent.y);
  }
  function calcRelativeAxisPosition(target, layout2, parent) {
    target.min = layout2.min - parent.min;
    target.max = target.min + calcLength(layout2);
  }
  function calcRelativePosition(target, layout2, parent) {
    calcRelativeAxisPosition(target.x, layout2.x, parent.x);
    calcRelativeAxisPosition(target.y, layout2.y, parent.y);
  }

  // packages/components/node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs
  function applyConstraints(point, { min: min3, max: max3 }, elastic) {
    if (min3 !== void 0 && point < min3) {
      point = elastic ? mixNumber(min3, point, elastic.min) : Math.max(point, min3);
    } else if (max3 !== void 0 && point > max3) {
      point = elastic ? mixNumber(max3, point, elastic.max) : Math.min(point, max3);
    }
    return point;
  }
  function calcRelativeAxisConstraints(axis, min3, max3) {
    return {
      min: min3 !== void 0 ? axis.min + min3 : void 0,
      max: max3 !== void 0 ? axis.max + max3 - (axis.max - axis.min) : void 0
    };
  }
  function calcRelativeConstraints(layoutBox, { top, left, bottom, right }) {
    return {
      x: calcRelativeAxisConstraints(layoutBox.x, left, right),
      y: calcRelativeAxisConstraints(layoutBox.y, top, bottom)
    };
  }
  function calcViewportAxisConstraints(layoutAxis, constraintsAxis) {
    let min3 = constraintsAxis.min - layoutAxis.min;
    let max3 = constraintsAxis.max - layoutAxis.max;
    if (constraintsAxis.max - constraintsAxis.min < layoutAxis.max - layoutAxis.min) {
      [min3, max3] = [max3, min3];
    }
    return { min: min3, max: max3 };
  }
  function calcViewportConstraints(layoutBox, constraintsBox) {
    return {
      x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),
      y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y)
    };
  }
  function calcOrigin(source, target) {
    let origin = 0.5;
    const sourceLength = calcLength(source);
    const targetLength = calcLength(target);
    if (targetLength > sourceLength) {
      origin = progress(target.min, target.max - sourceLength, source.min);
    } else if (sourceLength > targetLength) {
      origin = progress(source.min, source.max - targetLength, target.min);
    }
    return clamp2(0, 1, origin);
  }
  function rebaseAxisConstraints(layout2, constraints) {
    const relativeConstraints = {};
    if (constraints.min !== void 0) {
      relativeConstraints.min = constraints.min - layout2.min;
    }
    if (constraints.max !== void 0) {
      relativeConstraints.max = constraints.max - layout2.min;
    }
    return relativeConstraints;
  }
  var defaultElastic = 0.35;
  function resolveDragElastic(dragElastic = defaultElastic) {
    if (dragElastic === false) {
      dragElastic = 0;
    } else if (dragElastic === true) {
      dragElastic = defaultElastic;
    }
    return {
      x: resolveAxisElastic(dragElastic, "left", "right"),
      y: resolveAxisElastic(dragElastic, "top", "bottom")
    };
  }
  function resolveAxisElastic(dragElastic, minLabel, maxLabel) {
    return {
      min: resolvePointElastic(dragElastic, minLabel),
      max: resolvePointElastic(dragElastic, maxLabel)
    };
  }
  function resolvePointElastic(dragElastic, label) {
    return typeof dragElastic === "number" ? dragElastic : dragElastic[label] || 0;
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/geometry/models.mjs
  var createAxisDelta = () => ({
    translate: 0,
    scale: 1,
    origin: 0,
    originPoint: 0
  });
  var createDelta = () => ({
    x: createAxisDelta(),
    y: createAxisDelta()
  });
  var createAxis = () => ({ min: 0, max: 0 });
  var createBox = () => ({
    x: createAxis(),
    y: createAxis()
  });

  // packages/components/node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs
  function eachAxis(callback) {
    return [callback("x"), callback("y")];
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs
  function convertBoundingBoxToBox({ top, left, right, bottom }) {
    return {
      x: { min: left, max: right },
      y: { min: top, max: bottom }
    };
  }
  function convertBoxToBoundingBox({ x: x2, y: y3 }) {
    return { top: y3.min, right: x2.max, bottom: y3.max, left: x2.min };
  }
  function transformBoxPoints(point, transformPoint2) {
    if (!transformPoint2)
      return point;
    const topLeft = transformPoint2({ x: point.left, y: point.top });
    const bottomRight = transformPoint2({ x: point.right, y: point.bottom });
    return {
      top: topLeft.y,
      left: topLeft.x,
      bottom: bottomRight.y,
      right: bottomRight.x
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs
  function isIdentityScale(scale2) {
    return scale2 === void 0 || scale2 === 1;
  }
  function hasScale({ scale: scale2, scaleX, scaleY }) {
    return !isIdentityScale(scale2) || !isIdentityScale(scaleX) || !isIdentityScale(scaleY);
  }
  function hasTransform(values) {
    return hasScale(values) || has2DTranslate(values) || values.z || values.rotate || values.rotateX || values.rotateY || values.skewX || values.skewY;
  }
  function has2DTranslate(values) {
    return is2DTranslate(values.x) || is2DTranslate(values.y);
  }
  function is2DTranslate(value) {
    return value && value !== "0%";
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs
  function scalePoint(point, scale2, originPoint) {
    const distanceFromOrigin = point - originPoint;
    const scaled = scale2 * distanceFromOrigin;
    return originPoint + scaled;
  }
  function applyPointDelta(point, translate, scale2, originPoint, boxScale) {
    if (boxScale !== void 0) {
      point = scalePoint(point, boxScale, originPoint);
    }
    return scalePoint(point, scale2, originPoint) + translate;
  }
  function applyAxisDelta(axis, translate = 0, scale2 = 1, originPoint, boxScale) {
    axis.min = applyPointDelta(axis.min, translate, scale2, originPoint, boxScale);
    axis.max = applyPointDelta(axis.max, translate, scale2, originPoint, boxScale);
  }
  function applyBoxDelta(box, { x: x2, y: y3 }) {
    applyAxisDelta(box.x, x2.translate, x2.scale, x2.originPoint);
    applyAxisDelta(box.y, y3.translate, y3.scale, y3.originPoint);
  }
  var TREE_SCALE_SNAP_MIN = 0.999999999999;
  var TREE_SCALE_SNAP_MAX = 1.0000000000001;
  function applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {
    const treeLength = treePath.length;
    if (!treeLength)
      return;
    treeScale.x = treeScale.y = 1;
    let node2;
    let delta;
    for (let i3 = 0; i3 < treeLength; i3++) {
      node2 = treePath[i3];
      delta = node2.projectionDelta;
      const { visualElement } = node2.options;
      if (visualElement && visualElement.props.style && visualElement.props.style.display === "contents") {
        continue;
      }
      if (isSharedTransition && node2.options.layoutScroll && node2.scroll && node2 !== node2.root) {
        transformBox(box, {
          x: -node2.scroll.offset.x,
          y: -node2.scroll.offset.y
        });
      }
      if (delta) {
        treeScale.x *= delta.x.scale;
        treeScale.y *= delta.y.scale;
        applyBoxDelta(box, delta);
      }
      if (isSharedTransition && hasTransform(node2.latestValues)) {
        transformBox(box, node2.latestValues);
      }
    }
    if (treeScale.x < TREE_SCALE_SNAP_MAX && treeScale.x > TREE_SCALE_SNAP_MIN) {
      treeScale.x = 1;
    }
    if (treeScale.y < TREE_SCALE_SNAP_MAX && treeScale.y > TREE_SCALE_SNAP_MIN) {
      treeScale.y = 1;
    }
  }
  function translateAxis(axis, distance2) {
    axis.min = axis.min + distance2;
    axis.max = axis.max + distance2;
  }
  function transformAxis(axis, axisTranslate, axisScale, boxScale, axisOrigin = 0.5) {
    const originPoint = mixNumber(axis.min, axis.max, axisOrigin);
    applyAxisDelta(axis, axisTranslate, axisScale, originPoint, boxScale);
  }
  function transformBox(box, transform) {
    transformAxis(box.x, transform.x, transform.scaleX, transform.scale, transform.originX);
    transformAxis(box.y, transform.y, transform.scaleY, transform.scale, transform.originY);
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/utils/measure.mjs
  function measureViewportBox(instance, transformPoint2) {
    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint2));
  }
  function measurePageBox(element, rootProjectionNode2, transformPagePoint) {
    const viewportBox = measureViewportBox(element, transformPagePoint);
    const { scroll } = rootProjectionNode2;
    if (scroll) {
      translateAxis(viewportBox.x, scroll.offset.x);
      translateAxis(viewportBox.y, scroll.offset.y);
    }
    return viewportBox;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/get-context-window.mjs
  var getContextWindow = ({ current }) => {
    return current ? current.ownerDocument.defaultView : null;
  };

  // packages/components/node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs
  var elementDragControls = /* @__PURE__ */ new WeakMap();
  var VisualElementDragControls = class {
    constructor(visualElement) {
      this.openDragLock = null;
      this.isDragging = false;
      this.currentDirection = null;
      this.originPoint = { x: 0, y: 0 };
      this.constraints = false;
      this.hasMutatedConstraints = false;
      this.elastic = createBox();
      this.visualElement = visualElement;
    }
    start(originEvent, { snapToCursor = false } = {}) {
      const { presenceContext } = this.visualElement;
      if (presenceContext && presenceContext.isPresent === false)
        return;
      const onSessionStart = (event) => {
        const { dragSnapToOrigin: dragSnapToOrigin2 } = this.getProps();
        dragSnapToOrigin2 ? this.pauseAnimation() : this.stopAnimation();
        if (snapToCursor) {
          this.snapToCursor(extractEventInfo(event).point);
        }
      };
      const onStart = (event, info) => {
        const { drag: drag2, dragPropagation, onDragStart } = this.getProps();
        if (drag2 && !dragPropagation) {
          if (this.openDragLock)
            this.openDragLock();
          this.openDragLock = setDragLock(drag2);
          if (!this.openDragLock)
            return;
        }
        this.isDragging = true;
        this.currentDirection = null;
        this.resolveConstraints();
        if (this.visualElement.projection) {
          this.visualElement.projection.isAnimationBlocked = true;
          this.visualElement.projection.target = void 0;
        }
        eachAxis((axis) => {
          let current = this.getAxisMotionValue(axis).get() || 0;
          if (percent.test(current)) {
            const { projection } = this.visualElement;
            if (projection && projection.layout) {
              const measuredAxis = projection.layout.layoutBox[axis];
              if (measuredAxis) {
                const length2 = calcLength(measuredAxis);
                current = length2 * (parseFloat(current) / 100);
              }
            }
          }
          this.originPoint[axis] = current;
        });
        if (onDragStart) {
          frame.postRender(() => onDragStart(event, info));
        }
        addValueToWillChange(this.visualElement, "transform");
        const { animationState } = this.visualElement;
        animationState && animationState.setActive("whileDrag", true);
      };
      const onMove = (event, info) => {
        const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag } = this.getProps();
        if (!dragPropagation && !this.openDragLock)
          return;
        const { offset: offset4 } = info;
        if (dragDirectionLock && this.currentDirection === null) {
          this.currentDirection = getCurrentDirection(offset4);
          if (this.currentDirection !== null) {
            onDirectionLock && onDirectionLock(this.currentDirection);
          }
          return;
        }
        this.updateAxis("x", info.point, offset4);
        this.updateAxis("y", info.point, offset4);
        this.visualElement.render();
        onDrag && onDrag(event, info);
      };
      const onSessionEnd = (event, info) => this.stop(event, info);
      const resumeAnimation = () => eachAxis((axis) => {
        var _a;
        return this.getAnimationState(axis) === "paused" && ((_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.play());
      });
      const { dragSnapToOrigin } = this.getProps();
      this.panSession = new PanSession(originEvent, {
        onSessionStart,
        onStart,
        onMove,
        onSessionEnd,
        resumeAnimation
      }, {
        transformPagePoint: this.visualElement.getTransformPagePoint(),
        dragSnapToOrigin,
        contextWindow: getContextWindow(this.visualElement)
      });
    }
    stop(event, info) {
      const isDragging2 = this.isDragging;
      this.cancel();
      if (!isDragging2)
        return;
      const { velocity } = info;
      this.startAnimation(velocity);
      const { onDragEnd } = this.getProps();
      if (onDragEnd) {
        frame.postRender(() => onDragEnd(event, info));
      }
    }
    cancel() {
      this.isDragging = false;
      const { projection, animationState } = this.visualElement;
      if (projection) {
        projection.isAnimationBlocked = false;
      }
      this.panSession && this.panSession.end();
      this.panSession = void 0;
      const { dragPropagation } = this.getProps();
      if (!dragPropagation && this.openDragLock) {
        this.openDragLock();
        this.openDragLock = null;
      }
      animationState && animationState.setActive("whileDrag", false);
    }
    updateAxis(axis, _point, offset4) {
      const { drag: drag2 } = this.getProps();
      if (!offset4 || !shouldDrag(axis, drag2, this.currentDirection))
        return;
      const axisValue = this.getAxisMotionValue(axis);
      let next2 = this.originPoint[axis] + offset4[axis];
      if (this.constraints && this.constraints[axis]) {
        next2 = applyConstraints(next2, this.constraints[axis], this.elastic[axis]);
      }
      axisValue.set(next2);
    }
    resolveConstraints() {
      var _a;
      const { dragConstraints, dragElastic } = this.getProps();
      const layout2 = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(false) : (_a = this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout;
      const prevConstraints = this.constraints;
      if (dragConstraints && isRefObject(dragConstraints)) {
        if (!this.constraints) {
          this.constraints = this.resolveRefConstraints();
        }
      } else {
        if (dragConstraints && layout2) {
          this.constraints = calcRelativeConstraints(layout2.layoutBox, dragConstraints);
        } else {
          this.constraints = false;
        }
      }
      this.elastic = resolveDragElastic(dragElastic);
      if (prevConstraints !== this.constraints && layout2 && this.constraints && !this.hasMutatedConstraints) {
        eachAxis((axis) => {
          if (this.constraints !== false && this.getAxisMotionValue(axis)) {
            this.constraints[axis] = rebaseAxisConstraints(layout2.layoutBox[axis], this.constraints[axis]);
          }
        });
      }
    }
    resolveRefConstraints() {
      const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();
      if (!constraints || !isRefObject(constraints))
        return false;
      const constraintsElement = constraints.current;
      invariant2(constraintsElement !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.");
      const { projection } = this.visualElement;
      if (!projection || !projection.layout)
        return false;
      const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());
      let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, constraintsBox);
      if (onMeasureDragConstraints) {
        const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));
        this.hasMutatedConstraints = !!userConstraints;
        if (userConstraints) {
          measuredConstraints = convertBoundingBoxToBox(userConstraints);
        }
      }
      return measuredConstraints;
    }
    startAnimation(velocity) {
      const { drag: drag2, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd } = this.getProps();
      const constraints = this.constraints || {};
      const momentumAnimations = eachAxis((axis) => {
        if (!shouldDrag(axis, drag2, this.currentDirection)) {
          return;
        }
        let transition = constraints && constraints[axis] || {};
        if (dragSnapToOrigin)
          transition = { min: 0, max: 0 };
        const bounceStiffness = dragElastic ? 200 : 1e6;
        const bounceDamping = dragElastic ? 40 : 1e7;
        const inertia2 = {
          type: "inertia",
          velocity: dragMomentum ? velocity[axis] : 0,
          bounceStiffness,
          bounceDamping,
          timeConstant: 750,
          restDelta: 1,
          restSpeed: 10,
          ...dragTransition,
          ...transition
        };
        return this.startAxisValueAnimation(axis, inertia2);
      });
      return Promise.all(momentumAnimations).then(onDragTransitionEnd);
    }
    startAxisValueAnimation(axis, transition) {
      const axisValue = this.getAxisMotionValue(axis);
      addValueToWillChange(this.visualElement, axis);
      return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement, false));
    }
    stopAnimation() {
      eachAxis((axis) => this.getAxisMotionValue(axis).stop());
    }
    pauseAnimation() {
      eachAxis((axis) => {
        var _a;
        return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.pause();
      });
    }
    getAnimationState(axis) {
      var _a;
      return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.state;
    }
    /**
     * Drag works differently depending on which props are provided.
     *
     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
     * - Otherwise, we apply the delta to the x/y motion values.
     */
    getAxisMotionValue(axis) {
      const dragKey = `_drag${axis.toUpperCase()}`;
      const props = this.visualElement.getProps();
      const externalMotionValue = props[dragKey];
      return externalMotionValue ? externalMotionValue : this.visualElement.getValue(axis, (props.initial ? props.initial[axis] : void 0) || 0);
    }
    snapToCursor(point) {
      eachAxis((axis) => {
        const { drag: drag2 } = this.getProps();
        if (!shouldDrag(axis, drag2, this.currentDirection))
          return;
        const { projection } = this.visualElement;
        const axisValue = this.getAxisMotionValue(axis);
        if (projection && projection.layout) {
          const { min: min3, max: max3 } = projection.layout.layoutBox[axis];
          axisValue.set(point[axis] - mixNumber(min3, max3, 0.5));
        }
      });
    }
    /**
     * When the viewport resizes we want to check if the measured constraints
     * have changed and, if so, reposition the element within those new constraints
     * relative to where it was before the resize.
     */
    scalePositionWithinConstraints() {
      if (!this.visualElement.current)
        return;
      const { drag: drag2, dragConstraints } = this.getProps();
      const { projection } = this.visualElement;
      if (!isRefObject(dragConstraints) || !projection || !this.constraints)
        return;
      this.stopAnimation();
      const boxProgress = { x: 0, y: 0 };
      eachAxis((axis) => {
        const axisValue = this.getAxisMotionValue(axis);
        if (axisValue && this.constraints !== false) {
          const latest = axisValue.get();
          boxProgress[axis] = calcOrigin({ min: latest, max: latest }, this.constraints[axis]);
        }
      });
      const { transformTemplate } = this.visualElement.getProps();
      this.visualElement.current.style.transform = transformTemplate ? transformTemplate({}, "") : "none";
      projection.root && projection.root.updateScroll();
      projection.updateLayout();
      this.resolveConstraints();
      eachAxis((axis) => {
        if (!shouldDrag(axis, drag2, null))
          return;
        const axisValue = this.getAxisMotionValue(axis);
        const { min: min3, max: max3 } = this.constraints[axis];
        axisValue.set(mixNumber(min3, max3, boxProgress[axis]));
      });
    }
    addListeners() {
      if (!this.visualElement.current)
        return;
      elementDragControls.set(this.visualElement, this);
      const element = this.visualElement.current;
      const stopPointerListener = addPointerEvent(element, "pointerdown", (event) => {
        const { drag: drag2, dragListener = true } = this.getProps();
        drag2 && dragListener && this.start(event);
      });
      const measureDragConstraints = () => {
        const { dragConstraints } = this.getProps();
        if (isRefObject(dragConstraints) && dragConstraints.current) {
          this.constraints = this.resolveRefConstraints();
        }
      };
      const { projection } = this.visualElement;
      const stopMeasureLayoutListener = projection.addEventListener("measure", measureDragConstraints);
      if (projection && !projection.layout) {
        projection.root && projection.root.updateScroll();
        projection.updateLayout();
      }
      frame.read(measureDragConstraints);
      const stopResizeListener = addDomEvent(window, "resize", () => this.scalePositionWithinConstraints());
      const stopLayoutUpdateListener = projection.addEventListener("didUpdate", (({ delta, hasLayoutChanged }) => {
        if (this.isDragging && hasLayoutChanged) {
          eachAxis((axis) => {
            const motionValue2 = this.getAxisMotionValue(axis);
            if (!motionValue2)
              return;
            this.originPoint[axis] += delta[axis].translate;
            motionValue2.set(motionValue2.get() + delta[axis].translate);
          });
          this.visualElement.render();
        }
      }));
      return () => {
        stopResizeListener();
        stopPointerListener();
        stopMeasureLayoutListener();
        stopLayoutUpdateListener && stopLayoutUpdateListener();
      };
    }
    getProps() {
      const props = this.visualElement.getProps();
      const { drag: drag2 = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true } = props;
      return {
        ...props,
        drag: drag2,
        dragDirectionLock,
        dragPropagation,
        dragConstraints,
        dragElastic,
        dragMomentum
      };
    }
  };
  function shouldDrag(direction, drag2, currentDirection) {
    return (drag2 === true || drag2 === direction) && (currentDirection === null || currentDirection === direction);
  }
  function getCurrentDirection(offset4, lockThreshold = 10) {
    let direction = null;
    if (Math.abs(offset4.y) > lockThreshold) {
      direction = "y";
    } else if (Math.abs(offset4.x) > lockThreshold) {
      direction = "x";
    }
    return direction;
  }

  // packages/components/node_modules/framer-motion/dist/es/gestures/drag/index.mjs
  var DragGesture = class extends Feature {
    constructor(node2) {
      super(node2);
      this.removeGroupControls = noop2;
      this.removeListeners = noop2;
      this.controls = new VisualElementDragControls(node2);
    }
    mount() {
      const { dragControls } = this.node.getProps();
      if (dragControls) {
        this.removeGroupControls = dragControls.subscribe(this.controls);
      }
      this.removeListeners = this.controls.addListeners() || noop2;
    }
    unmount() {
      this.removeGroupControls();
      this.removeListeners();
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/gestures/pan/index.mjs
  var asyncHandler = (handler) => (event, info) => {
    if (handler) {
      frame.postRender(() => handler(event, info));
    }
  };
  var PanGesture = class extends Feature {
    constructor() {
      super(...arguments);
      this.removePointerDownListener = noop2;
    }
    onPointerDown(pointerDownEvent) {
      this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), {
        transformPagePoint: this.node.getTransformPagePoint(),
        contextWindow: getContextWindow(this.node)
      });
    }
    createPanHandlers() {
      const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();
      return {
        onSessionStart: asyncHandler(onPanSessionStart),
        onStart: asyncHandler(onPanStart),
        onMove: onPan,
        onEnd: (event, info) => {
          delete this.session;
          if (onPanEnd) {
            frame.postRender(() => onPanEnd(event, info));
          }
        }
      };
    }
    mount() {
      this.removePointerDownListener = addPointerEvent(this.node.current, "pointerdown", (event) => this.onPointerDown(event));
    }
    update() {
      this.session && this.session.updateHandlers(this.createPanHandlers());
    }
    unmount() {
      this.removePointerDownListener();
      this.session && this.session.end();
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs
  var import_jsx_runtime39 = __toESM(require_jsx_runtime(), 1);
  var import_react59 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs
  var import_react56 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/context/PresenceContext.mjs
  var import_react55 = __toESM(require_react(), 1);
  var PresenceContext = (0, import_react55.createContext)(null);

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs
  function usePresence() {
    const context = (0, import_react56.useContext)(PresenceContext);
    if (context === null)
      return [true, null];
    const { isPresent, onExitComplete, register } = context;
    const id3 = (0, import_react56.useId)();
    (0, import_react56.useEffect)(() => register(id3), []);
    const safeToRemove = (0, import_react56.useCallback)(() => onExitComplete && onExitComplete(id3), [id3, onExitComplete]);
    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];
  }

  // packages/components/node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs
  var import_react57 = __toESM(require_react(), 1);
  var LayoutGroupContext = (0, import_react57.createContext)({});

  // packages/components/node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs
  var import_react58 = __toESM(require_react(), 1);
  var SwitchLayoutGroupContext = (0, import_react58.createContext)({});

  // packages/components/node_modules/framer-motion/dist/es/projection/node/state.mjs
  var globalProjectionState = {
    /**
     * Global flag as to whether the tree has animated since the last time
     * we resized the window
     */
    hasAnimatedSinceResize: true,
    /**
     * We set this to true once, on the first update. Any nodes added to the tree beyond that
     * update will be given a `data-projection-id` attribute.
     */
    hasEverUpdated: false
  };

  // packages/components/node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs
  function pixelsToPercent(pixels, axis) {
    if (axis.max === axis.min)
      return 0;
    return pixels / (axis.max - axis.min) * 100;
  }
  var correctBorderRadius = {
    correct: (latest, node2) => {
      if (!node2.target)
        return latest;
      if (typeof latest === "string") {
        if (px.test(latest)) {
          latest = parseFloat(latest);
        } else {
          return latest;
        }
      }
      const x2 = pixelsToPercent(latest, node2.target.x);
      const y3 = pixelsToPercent(latest, node2.target.y);
      return `${x2}% ${y3}%`;
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs
  var correctBoxShadow = {
    correct: (latest, { treeScale, projectionDelta }) => {
      const original = latest;
      const shadow = complex.parse(latest);
      if (shadow.length > 5)
        return original;
      const template = complex.createTransformer(latest);
      const offset4 = typeof shadow[0] !== "number" ? 1 : 0;
      const xScale = projectionDelta.x.scale * treeScale.x;
      const yScale = projectionDelta.y.scale * treeScale.y;
      shadow[0 + offset4] /= xScale;
      shadow[1 + offset4] /= yScale;
      const averageScale = mixNumber(xScale, yScale, 0.5);
      if (typeof shadow[2 + offset4] === "number")
        shadow[2 + offset4] /= averageScale;
      if (typeof shadow[3 + offset4] === "number")
        shadow[3 + offset4] /= averageScale;
      return template(shadow);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs
  var scaleCorrectors = {};
  function addScaleCorrector(correctors) {
    Object.assign(scaleCorrectors, correctors);
  }

  // packages/components/node_modules/framer-motion/dist/es/frameloop/microtask.mjs
  var { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);

  // packages/components/node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs
  var MeasureLayoutWithContext = class extends import_react59.Component {
    /**
     * This only mounts projection nodes for components that
     * need measuring, we might want to do it for all components
     * in order to incorporate transforms
     */
    componentDidMount() {
      const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;
      const { projection } = visualElement;
      addScaleCorrector(defaultScaleCorrectors);
      if (projection) {
        if (layoutGroup.group)
          layoutGroup.group.add(projection);
        if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {
          switchLayoutGroup.register(projection);
        }
        projection.root.didUpdate();
        projection.addEventListener("animationComplete", () => {
          this.safeToRemove();
        });
        projection.setOptions({
          ...projection.options,
          onExitComplete: () => this.safeToRemove()
        });
      }
      globalProjectionState.hasEverUpdated = true;
    }
    getSnapshotBeforeUpdate(prevProps) {
      const { layoutDependency, visualElement, drag: drag2, isPresent } = this.props;
      const projection = visualElement.projection;
      if (!projection)
        return null;
      projection.isPresent = isPresent;
      if (drag2 || prevProps.layoutDependency !== layoutDependency || layoutDependency === void 0) {
        projection.willUpdate();
      } else {
        this.safeToRemove();
      }
      if (prevProps.isPresent !== isPresent) {
        if (isPresent) {
          projection.promote();
        } else if (!projection.relegate()) {
          frame.postRender(() => {
            const stack = projection.getStack();
            if (!stack || !stack.members.length) {
              this.safeToRemove();
            }
          });
        }
      }
      return null;
    }
    componentDidUpdate() {
      const { projection } = this.props.visualElement;
      if (projection) {
        projection.root.didUpdate();
        microtask.postRender(() => {
          if (!projection.currentAnimation && projection.isLead()) {
            this.safeToRemove();
          }
        });
      }
    }
    componentWillUnmount() {
      const { visualElement, layoutGroup, switchLayoutGroup: promoteContext } = this.props;
      const { projection } = visualElement;
      if (projection) {
        projection.scheduleCheckAfterUnmount();
        if (layoutGroup && layoutGroup.group)
          layoutGroup.group.remove(projection);
        if (promoteContext && promoteContext.deregister)
          promoteContext.deregister(projection);
      }
    }
    safeToRemove() {
      const { safeToRemove } = this.props;
      safeToRemove && safeToRemove();
    }
    render() {
      return null;
    }
  };
  function MeasureLayout(props) {
    const [isPresent, safeToRemove] = usePresence();
    const layoutGroup = (0, import_react59.useContext)(LayoutGroupContext);
    return (0, import_jsx_runtime39.jsx)(MeasureLayoutWithContext, { ...props, layoutGroup, switchLayoutGroup: (0, import_react59.useContext)(SwitchLayoutGroupContext), isPresent, safeToRemove });
  }
  var defaultScaleCorrectors = {
    borderRadius: {
      ...correctBorderRadius,
      applyTo: [
        "borderTopLeftRadius",
        "borderTopRightRadius",
        "borderBottomLeftRadius",
        "borderBottomRightRadius"
      ]
    },
    borderTopLeftRadius: correctBorderRadius,
    borderTopRightRadius: correctBorderRadius,
    borderBottomLeftRadius: correctBorderRadius,
    borderBottomRightRadius: correctBorderRadius,
    boxShadow: correctBoxShadow
  };

  // packages/components/node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs
  var borders = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"];
  var numBorders = borders.length;
  var asNumber = (value) => typeof value === "string" ? parseFloat(value) : value;
  var isPx = (value) => typeof value === "number" || px.test(value);
  function mixValues(target, follow, lead, progress2, shouldCrossfadeOpacity, isOnlyMember) {
    if (shouldCrossfadeOpacity) {
      target.opacity = mixNumber(
        0,
        // TODO Reinstate this if only child
        lead.opacity !== void 0 ? lead.opacity : 1,
        easeCrossfadeIn(progress2)
      );
      target.opacityExit = mixNumber(follow.opacity !== void 0 ? follow.opacity : 1, 0, easeCrossfadeOut(progress2));
    } else if (isOnlyMember) {
      target.opacity = mixNumber(follow.opacity !== void 0 ? follow.opacity : 1, lead.opacity !== void 0 ? lead.opacity : 1, progress2);
    }
    for (let i3 = 0; i3 < numBorders; i3++) {
      const borderLabel = `border${borders[i3]}Radius`;
      let followRadius = getRadius(follow, borderLabel);
      let leadRadius = getRadius(lead, borderLabel);
      if (followRadius === void 0 && leadRadius === void 0)
        continue;
      followRadius || (followRadius = 0);
      leadRadius || (leadRadius = 0);
      const canMix = followRadius === 0 || leadRadius === 0 || isPx(followRadius) === isPx(leadRadius);
      if (canMix) {
        target[borderLabel] = Math.max(mixNumber(asNumber(followRadius), asNumber(leadRadius), progress2), 0);
        if (percent.test(leadRadius) || percent.test(followRadius)) {
          target[borderLabel] += "%";
        }
      } else {
        target[borderLabel] = leadRadius;
      }
    }
    if (follow.rotate || lead.rotate) {
      target.rotate = mixNumber(follow.rotate || 0, lead.rotate || 0, progress2);
    }
  }
  function getRadius(values, radiusName) {
    return values[radiusName] !== void 0 ? values[radiusName] : values.borderRadius;
  }
  var easeCrossfadeIn = /* @__PURE__ */ compress(0, 0.5, circOut);
  var easeCrossfadeOut = /* @__PURE__ */ compress(0.5, 0.95, noop2);
  function compress(min3, max3, easing) {
    return (p3) => {
      if (p3 < min3)
        return 0;
      if (p3 > max3)
        return 1;
      return easing(progress(min3, max3, p3));
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/geometry/copy.mjs
  function copyAxisInto(axis, originAxis) {
    axis.min = originAxis.min;
    axis.max = originAxis.max;
  }
  function copyBoxInto(box, originBox) {
    copyAxisInto(box.x, originBox.x);
    copyAxisInto(box.y, originBox.y);
  }
  function copyAxisDeltaInto(delta, originDelta) {
    delta.translate = originDelta.translate;
    delta.scale = originDelta.scale;
    delta.originPoint = originDelta.originPoint;
    delta.origin = originDelta.origin;
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs
  function removePointDelta(point, translate, scale2, originPoint, boxScale) {
    point -= translate;
    point = scalePoint(point, 1 / scale2, originPoint);
    if (boxScale !== void 0) {
      point = scalePoint(point, 1 / boxScale, originPoint);
    }
    return point;
  }
  function removeAxisDelta(axis, translate = 0, scale2 = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {
    if (percent.test(translate)) {
      translate = parseFloat(translate);
      const relativeProgress = mixNumber(sourceAxis.min, sourceAxis.max, translate / 100);
      translate = relativeProgress - sourceAxis.min;
    }
    if (typeof translate !== "number")
      return;
    let originPoint = mixNumber(originAxis.min, originAxis.max, origin);
    if (axis === originAxis)
      originPoint -= translate;
    axis.min = removePointDelta(axis.min, translate, scale2, originPoint, boxScale);
    axis.max = removePointDelta(axis.max, translate, scale2, originPoint, boxScale);
  }
  function removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {
    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);
  }
  var xKeys = ["x", "scaleX", "originX"];
  var yKeys = ["y", "scaleY", "originY"];
  function removeBoxTransforms(box, transforms, originBox, sourceBox) {
    removeAxisTransforms(box.x, transforms, xKeys, originBox ? originBox.x : void 0, sourceBox ? sourceBox.x : void 0);
    removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : void 0, sourceBox ? sourceBox.y : void 0);
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/geometry/utils.mjs
  function isAxisDeltaZero(delta) {
    return delta.translate === 0 && delta.scale === 1;
  }
  function isDeltaZero(delta) {
    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);
  }
  function axisEquals(a3, b3) {
    return a3.min === b3.min && a3.max === b3.max;
  }
  function boxEquals(a3, b3) {
    return axisEquals(a3.x, b3.x) && axisEquals(a3.y, b3.y);
  }
  function axisEqualsRounded(a3, b3) {
    return Math.round(a3.min) === Math.round(b3.min) && Math.round(a3.max) === Math.round(b3.max);
  }
  function boxEqualsRounded(a3, b3) {
    return axisEqualsRounded(a3.x, b3.x) && axisEqualsRounded(a3.y, b3.y);
  }
  function aspectRatio(box) {
    return calcLength(box.x) / calcLength(box.y);
  }
  function axisDeltaEquals(a3, b3) {
    return a3.translate === b3.translate && a3.scale === b3.scale && a3.originPoint === b3.originPoint;
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/shared/stack.mjs
  var NodeStack = class {
    constructor() {
      this.members = [];
    }
    add(node2) {
      addUniqueItem(this.members, node2);
      node2.scheduleRender();
    }
    remove(node2) {
      removeItem(this.members, node2);
      if (node2 === this.prevLead) {
        this.prevLead = void 0;
      }
      if (node2 === this.lead) {
        const prevLead = this.members[this.members.length - 1];
        if (prevLead) {
          this.promote(prevLead);
        }
      }
    }
    relegate(node2) {
      const indexOfNode = this.members.findIndex((member) => node2 === member);
      if (indexOfNode === 0)
        return false;
      let prevLead;
      for (let i3 = indexOfNode; i3 >= 0; i3--) {
        const member = this.members[i3];
        if (member.isPresent !== false) {
          prevLead = member;
          break;
        }
      }
      if (prevLead) {
        this.promote(prevLead);
        return true;
      } else {
        return false;
      }
    }
    promote(node2, preserveFollowOpacity) {
      const prevLead = this.lead;
      if (node2 === prevLead)
        return;
      this.prevLead = prevLead;
      this.lead = node2;
      node2.show();
      if (prevLead) {
        prevLead.instance && prevLead.scheduleRender();
        node2.scheduleRender();
        node2.resumeFrom = prevLead;
        if (preserveFollowOpacity) {
          node2.resumeFrom.preserveOpacity = true;
        }
        if (prevLead.snapshot) {
          node2.snapshot = prevLead.snapshot;
          node2.snapshot.latestValues = prevLead.animationValues || prevLead.latestValues;
        }
        if (node2.root && node2.root.isUpdating) {
          node2.isLayoutDirty = true;
        }
        const { crossfade } = node2.options;
        if (crossfade === false) {
          prevLead.hide();
        }
      }
    }
    exitAnimationComplete() {
      this.members.forEach((node2) => {
        const { options: options2, resumingFrom } = node2;
        options2.onExitComplete && options2.onExitComplete();
        if (resumingFrom) {
          resumingFrom.options.onExitComplete && resumingFrom.options.onExitComplete();
        }
      });
    }
    scheduleRender() {
      this.members.forEach((node2) => {
        node2.instance && node2.scheduleRender(false);
      });
    }
    /**
     * Clear any leads that have been removed this render to prevent them from being
     * used in future animations and to prevent memory leaks
     */
    removeLeadSnapshot() {
      if (this.lead && this.lead.snapshot) {
        this.lead.snapshot = void 0;
      }
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/projection/styles/transform.mjs
  function buildProjectionTransform(delta, treeScale, latestTransform) {
    let transform = "";
    const xTranslate = delta.x.translate / treeScale.x;
    const yTranslate = delta.y.translate / treeScale.y;
    const zTranslate = (latestTransform === null || latestTransform === void 0 ? void 0 : latestTransform.z) || 0;
    if (xTranslate || yTranslate || zTranslate) {
      transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;
    }
    if (treeScale.x !== 1 || treeScale.y !== 1) {
      transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
    }
    if (latestTransform) {
      const { transformPerspective, rotate, rotateX, rotateY, skewX, skewY } = latestTransform;
      if (transformPerspective)
        transform = `perspective(${transformPerspective}px) ${transform}`;
      if (rotate)
        transform += `rotate(${rotate}deg) `;
      if (rotateX)
        transform += `rotateX(${rotateX}deg) `;
      if (rotateY)
        transform += `rotateY(${rotateY}deg) `;
      if (skewX)
        transform += `skewX(${skewX}deg) `;
      if (skewY)
        transform += `skewY(${skewY}deg) `;
    }
    const elementScaleX = delta.x.scale * treeScale.x;
    const elementScaleY = delta.y.scale * treeScale.y;
    if (elementScaleX !== 1 || elementScaleY !== 1) {
      transform += `scale(${elementScaleX}, ${elementScaleY})`;
    }
    return transform || "none";
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs
  var compareByDepth = (a3, b3) => a3.depth - b3.depth;

  // packages/components/node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs
  var FlatTree = class {
    constructor() {
      this.children = [];
      this.isDirty = false;
    }
    add(child) {
      addUniqueItem(this.children, child);
      this.isDirty = true;
    }
    remove(child) {
      removeItem(this.children, child);
      this.isDirty = true;
    }
    forEach(callback) {
      this.isDirty && this.children.sort(compareByDepth);
      this.isDirty = false;
      this.children.forEach(callback);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs
  function resolveMotionValue(value) {
    const unwrappedValue = isMotionValue(value) ? value.get() : value;
    return isCustomValue(unwrappedValue) ? unwrappedValue.toValue() : unwrappedValue;
  }

  // packages/components/node_modules/framer-motion/dist/es/utils/delay.mjs
  function delay(callback, timeout) {
    const start = time.now();
    const checkElapsed = ({ timestamp }) => {
      const elapsed = timestamp - start;
      if (elapsed >= timeout) {
        cancelFrame(checkElapsed);
        callback(elapsed - timeout);
      }
    };
    frame.read(checkElapsed, true);
    return () => cancelFrame(checkElapsed);
  }

  // packages/components/node_modules/framer-motion/dist/es/render/dom/utils/is-svg-element.mjs
  function isSVGElement(element) {
    return element instanceof SVGElement && element.tagName !== "svg";
  }

  // packages/components/node_modules/framer-motion/dist/es/animation/animate/single-value.mjs
  function animateSingleValue(value, keyframes4, options2) {
    const motionValue$1 = isMotionValue(value) ? value : motionValue(value);
    motionValue$1.start(animateMotionValue("", motionValue$1, keyframes4, options2));
    return motionValue$1.animation;
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs
  var metrics = {
    type: "projectionFrame",
    totalNodes: 0,
    resolvedTargetDeltas: 0,
    recalculatedProjection: 0
  };
  var isDebug = typeof window !== "undefined" && window.MotionDebug !== void 0;
  var transformAxes = ["", "X", "Y", "Z"];
  var hiddenVisibility = { visibility: "hidden" };
  var animationTarget = 1e3;
  var id2 = 0;
  function resetDistortingTransform(key, visualElement, values, sharedAnimationValues) {
    const { latestValues } = visualElement;
    if (latestValues[key]) {
      values[key] = latestValues[key];
      visualElement.setStaticValue(key, 0);
      if (sharedAnimationValues) {
        sharedAnimationValues[key] = 0;
      }
    }
  }
  function cancelTreeOptimisedTransformAnimations(projectionNode) {
    projectionNode.hasCheckedOptimisedAppear = true;
    if (projectionNode.root === projectionNode)
      return;
    const { visualElement } = projectionNode.options;
    if (!visualElement)
      return;
    const appearId = getOptimisedAppearId(visualElement);
    if (window.MotionHasOptimisedAnimation(appearId, "transform")) {
      const { layout: layout2, layoutId } = projectionNode.options;
      window.MotionCancelOptimisedAnimation(appearId, "transform", frame, !(layout2 || layoutId));
    }
    const { parent } = projectionNode;
    if (parent && !parent.hasCheckedOptimisedAppear) {
      cancelTreeOptimisedTransformAnimations(parent);
    }
  }
  function createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform }) {
    return class ProjectionNode {
      constructor(latestValues = {}, parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent()) {
        this.id = id2++;
        this.animationId = 0;
        this.children = /* @__PURE__ */ new Set();
        this.options = {};
        this.isTreeAnimating = false;
        this.isAnimationBlocked = false;
        this.isLayoutDirty = false;
        this.isProjectionDirty = false;
        this.isSharedProjectionDirty = false;
        this.isTransformDirty = false;
        this.updateManuallyBlocked = false;
        this.updateBlockedByResize = false;
        this.isUpdating = false;
        this.isSVG = false;
        this.needsReset = false;
        this.shouldResetTransform = false;
        this.hasCheckedOptimisedAppear = false;
        this.treeScale = { x: 1, y: 1 };
        this.eventHandlers = /* @__PURE__ */ new Map();
        this.hasTreeAnimated = false;
        this.updateScheduled = false;
        this.scheduleUpdate = () => this.update();
        this.projectionUpdateScheduled = false;
        this.checkUpdateFailed = () => {
          if (this.isUpdating) {
            this.isUpdating = false;
            this.clearAllSnapshots();
          }
        };
        this.updateProjection = () => {
          this.projectionUpdateScheduled = false;
          if (isDebug) {
            metrics.totalNodes = metrics.resolvedTargetDeltas = metrics.recalculatedProjection = 0;
          }
          this.nodes.forEach(propagateDirtyNodes);
          this.nodes.forEach(resolveTargetDelta);
          this.nodes.forEach(calcProjection);
          this.nodes.forEach(cleanDirtyNodes);
          if (isDebug) {
            window.MotionDebug.record(metrics);
          }
        };
        this.resolvedRelativeTargetAt = 0;
        this.hasProjected = false;
        this.isVisible = true;
        this.animationProgress = 0;
        this.sharedNodes = /* @__PURE__ */ new Map();
        this.latestValues = latestValues;
        this.root = parent ? parent.root || parent : this;
        this.path = parent ? [...parent.path, parent] : [];
        this.parent = parent;
        this.depth = parent ? parent.depth + 1 : 0;
        for (let i3 = 0; i3 < this.path.length; i3++) {
          this.path[i3].shouldResetTransform = true;
        }
        if (this.root === this)
          this.nodes = new FlatTree();
      }
      addEventListener(name, handler) {
        if (!this.eventHandlers.has(name)) {
          this.eventHandlers.set(name, new SubscriptionManager());
        }
        return this.eventHandlers.get(name).add(handler);
      }
      notifyListeners(name, ...args) {
        const subscriptionManager = this.eventHandlers.get(name);
        subscriptionManager && subscriptionManager.notify(...args);
      }
      hasListeners(name) {
        return this.eventHandlers.has(name);
      }
      /**
       * Lifecycles
       */
      mount(instance, isLayoutDirty = this.root.hasTreeAnimated) {
        if (this.instance)
          return;
        this.isSVG = isSVGElement(instance);
        this.instance = instance;
        const { layoutId, layout: layout2, visualElement } = this.options;
        if (visualElement && !visualElement.current) {
          visualElement.mount(instance);
        }
        this.root.nodes.add(this);
        this.parent && this.parent.children.add(this);
        if (isLayoutDirty && (layout2 || layoutId)) {
          this.isLayoutDirty = true;
        }
        if (attachResizeListener) {
          let cancelDelay;
          const resizeUnblockUpdate = () => this.root.updateBlockedByResize = false;
          attachResizeListener(instance, () => {
            this.root.updateBlockedByResize = true;
            cancelDelay && cancelDelay();
            cancelDelay = delay(resizeUnblockUpdate, 250);
            if (globalProjectionState.hasAnimatedSinceResize) {
              globalProjectionState.hasAnimatedSinceResize = false;
              this.nodes.forEach(finishAnimation);
            }
          });
        }
        if (layoutId) {
          this.root.registerSharedNode(layoutId, this);
        }
        if (this.options.animate !== false && visualElement && (layoutId || layout2)) {
          this.addEventListener("didUpdate", ({ delta, hasLayoutChanged, hasRelativeTargetChanged, layout: newLayout }) => {
            if (this.isTreeAnimationBlocked()) {
              this.target = void 0;
              this.relativeTarget = void 0;
              return;
            }
            const layoutTransition = this.options.transition || visualElement.getDefaultTransition() || defaultLayoutTransition;
            const { onLayoutAnimationStart, onLayoutAnimationComplete } = visualElement.getProps();
            const targetChanged = !this.targetLayout || !boxEqualsRounded(this.targetLayout, newLayout) || hasRelativeTargetChanged;
            const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;
            if (this.options.layoutRoot || this.resumeFrom && this.resumeFrom.instance || hasOnlyRelativeTargetChanged || hasLayoutChanged && (targetChanged || !this.currentAnimation)) {
              if (this.resumeFrom) {
                this.resumingFrom = this.resumeFrom;
                this.resumingFrom.resumingFrom = void 0;
              }
              this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);
              const animationOptions = {
                ...getValueTransition(layoutTransition, "layout"),
                onPlay: onLayoutAnimationStart,
                onComplete: onLayoutAnimationComplete
              };
              if (visualElement.shouldReduceMotion || this.options.layoutRoot) {
                animationOptions.delay = 0;
                animationOptions.type = false;
              }
              this.startAnimation(animationOptions);
            } else {
              if (!hasLayoutChanged) {
                finishAnimation(this);
              }
              if (this.isLead() && this.options.onExitComplete) {
                this.options.onExitComplete();
              }
            }
            this.targetLayout = newLayout;
          });
        }
      }
      unmount() {
        this.options.layoutId && this.willUpdate();
        this.root.nodes.remove(this);
        const stack = this.getStack();
        stack && stack.remove(this);
        this.parent && this.parent.children.delete(this);
        this.instance = void 0;
        cancelFrame(this.updateProjection);
      }
      // only on the root
      blockUpdate() {
        this.updateManuallyBlocked = true;
      }
      unblockUpdate() {
        this.updateManuallyBlocked = false;
      }
      isUpdateBlocked() {
        return this.updateManuallyBlocked || this.updateBlockedByResize;
      }
      isTreeAnimationBlocked() {
        return this.isAnimationBlocked || this.parent && this.parent.isTreeAnimationBlocked() || false;
      }
      // Note: currently only running on root node
      startUpdate() {
        if (this.isUpdateBlocked())
          return;
        this.isUpdating = true;
        this.nodes && this.nodes.forEach(resetSkewAndRotation);
        this.animationId++;
      }
      getTransformTemplate() {
        const { visualElement } = this.options;
        return visualElement && visualElement.getProps().transformTemplate;
      }
      willUpdate(shouldNotifyListeners = true) {
        this.root.hasTreeAnimated = true;
        if (this.root.isUpdateBlocked()) {
          this.options.onExitComplete && this.options.onExitComplete();
          return;
        }
        if (window.MotionCancelOptimisedAnimation && !this.hasCheckedOptimisedAppear) {
          cancelTreeOptimisedTransformAnimations(this);
        }
        !this.root.isUpdating && this.root.startUpdate();
        if (this.isLayoutDirty)
          return;
        this.isLayoutDirty = true;
        for (let i3 = 0; i3 < this.path.length; i3++) {
          const node2 = this.path[i3];
          node2.shouldResetTransform = true;
          node2.updateScroll("snapshot");
          if (node2.options.layoutRoot) {
            node2.willUpdate(false);
          }
        }
        const { layoutId, layout: layout2 } = this.options;
        if (layoutId === void 0 && !layout2)
          return;
        const transformTemplate = this.getTransformTemplate();
        this.prevTransformTemplateValue = transformTemplate ? transformTemplate(this.latestValues, "") : void 0;
        this.updateSnapshot();
        shouldNotifyListeners && this.notifyListeners("willUpdate");
      }
      update() {
        this.updateScheduled = false;
        const updateWasBlocked = this.isUpdateBlocked();
        if (updateWasBlocked) {
          this.unblockUpdate();
          this.clearAllSnapshots();
          this.nodes.forEach(clearMeasurements);
          return;
        }
        if (!this.isUpdating) {
          this.nodes.forEach(clearIsLayoutDirty);
        }
        this.isUpdating = false;
        this.nodes.forEach(resetTransformStyle);
        this.nodes.forEach(updateLayout);
        this.nodes.forEach(notifyLayoutUpdate);
        this.clearAllSnapshots();
        const now2 = time.now();
        frameData.delta = clamp2(0, 1e3 / 60, now2 - frameData.timestamp);
        frameData.timestamp = now2;
        frameData.isProcessing = true;
        frameSteps.update.process(frameData);
        frameSteps.preRender.process(frameData);
        frameSteps.render.process(frameData);
        frameData.isProcessing = false;
      }
      didUpdate() {
        if (!this.updateScheduled) {
          this.updateScheduled = true;
          microtask.read(this.scheduleUpdate);
        }
      }
      clearAllSnapshots() {
        this.nodes.forEach(clearSnapshot);
        this.sharedNodes.forEach(removeLeadSnapshots);
      }
      scheduleUpdateProjection() {
        if (!this.projectionUpdateScheduled) {
          this.projectionUpdateScheduled = true;
          frame.preRender(this.updateProjection, false, true);
        }
      }
      scheduleCheckAfterUnmount() {
        frame.postRender(() => {
          if (this.isLayoutDirty) {
            this.root.didUpdate();
          } else {
            this.root.checkUpdateFailed();
          }
        });
      }
      /**
       * Update measurements
       */
      updateSnapshot() {
        if (this.snapshot || !this.instance)
          return;
        this.snapshot = this.measure();
      }
      updateLayout() {
        if (!this.instance)
          return;
        this.updateScroll();
        if (!(this.options.alwaysMeasureLayout && this.isLead()) && !this.isLayoutDirty) {
          return;
        }
        if (this.resumeFrom && !this.resumeFrom.instance) {
          for (let i3 = 0; i3 < this.path.length; i3++) {
            const node2 = this.path[i3];
            node2.updateScroll();
          }
        }
        const prevLayout = this.layout;
        this.layout = this.measure(false);
        this.layoutCorrected = createBox();
        this.isLayoutDirty = false;
        this.projectionDelta = void 0;
        this.notifyListeners("measure", this.layout.layoutBox);
        const { visualElement } = this.options;
        visualElement && visualElement.notify("LayoutMeasure", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : void 0);
      }
      updateScroll(phase = "measure") {
        let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);
        if (this.scroll && this.scroll.animationId === this.root.animationId && this.scroll.phase === phase) {
          needsMeasurement = false;
        }
        if (needsMeasurement) {
          const isRoot = checkIsScrollRoot(this.instance);
          this.scroll = {
            animationId: this.root.animationId,
            phase,
            isRoot,
            offset: measureScroll(this.instance),
            wasRoot: this.scroll ? this.scroll.isRoot : isRoot
          };
        }
      }
      resetTransform() {
        if (!resetTransform)
          return;
        const isResetRequested = this.isLayoutDirty || this.shouldResetTransform || this.options.alwaysMeasureLayout;
        const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);
        const transformTemplate = this.getTransformTemplate();
        const transformTemplateValue = transformTemplate ? transformTemplate(this.latestValues, "") : void 0;
        const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;
        if (isResetRequested && (hasProjection || hasTransform(this.latestValues) || transformTemplateHasChanged)) {
          resetTransform(this.instance, transformTemplateValue);
          this.shouldResetTransform = false;
          this.scheduleRender();
        }
      }
      measure(removeTransform = true) {
        const pageBox = this.measurePageBox();
        let layoutBox = this.removeElementScroll(pageBox);
        if (removeTransform) {
          layoutBox = this.removeTransform(layoutBox);
        }
        roundBox(layoutBox);
        return {
          animationId: this.root.animationId,
          measuredBox: pageBox,
          layoutBox,
          latestValues: {},
          source: this.id
        };
      }
      measurePageBox() {
        var _a;
        const { visualElement } = this.options;
        if (!visualElement)
          return createBox();
        const box = visualElement.measureViewportBox();
        const wasInScrollRoot = ((_a = this.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot) || this.path.some(checkNodeWasScrollRoot);
        if (!wasInScrollRoot) {
          const { scroll } = this.root;
          if (scroll) {
            translateAxis(box.x, scroll.offset.x);
            translateAxis(box.y, scroll.offset.y);
          }
        }
        return box;
      }
      removeElementScroll(box) {
        var _a;
        const boxWithoutScroll = createBox();
        copyBoxInto(boxWithoutScroll, box);
        if ((_a = this.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot) {
          return boxWithoutScroll;
        }
        for (let i3 = 0; i3 < this.path.length; i3++) {
          const node2 = this.path[i3];
          const { scroll, options: options2 } = node2;
          if (node2 !== this.root && scroll && options2.layoutScroll) {
            if (scroll.wasRoot) {
              copyBoxInto(boxWithoutScroll, box);
            }
            translateAxis(boxWithoutScroll.x, scroll.offset.x);
            translateAxis(boxWithoutScroll.y, scroll.offset.y);
          }
        }
        return boxWithoutScroll;
      }
      applyTransform(box, transformOnly = false) {
        const withTransforms = createBox();
        copyBoxInto(withTransforms, box);
        for (let i3 = 0; i3 < this.path.length; i3++) {
          const node2 = this.path[i3];
          if (!transformOnly && node2.options.layoutScroll && node2.scroll && node2 !== node2.root) {
            transformBox(withTransforms, {
              x: -node2.scroll.offset.x,
              y: -node2.scroll.offset.y
            });
          }
          if (!hasTransform(node2.latestValues))
            continue;
          transformBox(withTransforms, node2.latestValues);
        }
        if (hasTransform(this.latestValues)) {
          transformBox(withTransforms, this.latestValues);
        }
        return withTransforms;
      }
      removeTransform(box) {
        const boxWithoutTransform = createBox();
        copyBoxInto(boxWithoutTransform, box);
        for (let i3 = 0; i3 < this.path.length; i3++) {
          const node2 = this.path[i3];
          if (!node2.instance)
            continue;
          if (!hasTransform(node2.latestValues))
            continue;
          hasScale(node2.latestValues) && node2.updateSnapshot();
          const sourceBox = createBox();
          const nodeBox = node2.measurePageBox();
          copyBoxInto(sourceBox, nodeBox);
          removeBoxTransforms(boxWithoutTransform, node2.latestValues, node2.snapshot ? node2.snapshot.layoutBox : void 0, sourceBox);
        }
        if (hasTransform(this.latestValues)) {
          removeBoxTransforms(boxWithoutTransform, this.latestValues);
        }
        return boxWithoutTransform;
      }
      setTargetDelta(delta) {
        this.targetDelta = delta;
        this.root.scheduleUpdateProjection();
        this.isProjectionDirty = true;
      }
      setOptions(options2) {
        this.options = {
          ...this.options,
          ...options2,
          crossfade: options2.crossfade !== void 0 ? options2.crossfade : true
        };
      }
      clearMeasurements() {
        this.scroll = void 0;
        this.layout = void 0;
        this.snapshot = void 0;
        this.prevTransformTemplateValue = void 0;
        this.targetDelta = void 0;
        this.target = void 0;
        this.isLayoutDirty = false;
      }
      forceRelativeParentToResolveTarget() {
        if (!this.relativeParent)
          return;
        if (this.relativeParent.resolvedRelativeTargetAt !== frameData.timestamp) {
          this.relativeParent.resolveTargetDelta(true);
        }
      }
      resolveTargetDelta(forceRecalculation = false) {
        var _a;
        const lead = this.getLead();
        this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);
        this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);
        this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);
        const isShared = Boolean(this.resumingFrom) || this !== lead;
        const canSkip = !(forceRecalculation || isShared && this.isSharedProjectionDirty || this.isProjectionDirty || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty) || this.attemptToResolveRelativeTarget || this.root.updateBlockedByResize);
        if (canSkip)
          return;
        const { layout: layout2, layoutId } = this.options;
        if (!this.layout || !(layout2 || layoutId))
          return;
        this.resolvedRelativeTargetAt = frameData.timestamp;
        if (!this.targetDelta && !this.relativeTarget) {
          const relativeParent = this.getClosestProjectingParent();
          if (relativeParent && relativeParent.layout && this.animationProgress !== 1) {
            this.relativeParent = relativeParent;
            this.forceRelativeParentToResolveTarget();
            this.relativeTarget = createBox();
            this.relativeTargetOrigin = createBox();
            calcRelativePosition(this.relativeTargetOrigin, this.layout.layoutBox, relativeParent.layout.layoutBox);
            copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);
          } else {
            this.relativeParent = this.relativeTarget = void 0;
          }
        }
        if (!this.relativeTarget && !this.targetDelta)
          return;
        if (!this.target) {
          this.target = createBox();
          this.targetWithTransforms = createBox();
        }
        if (this.relativeTarget && this.relativeTargetOrigin && this.relativeParent && this.relativeParent.target) {
          this.forceRelativeParentToResolveTarget();
          calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);
        } else if (this.targetDelta) {
          if (Boolean(this.resumingFrom)) {
            this.target = this.applyTransform(this.layout.layoutBox);
          } else {
            copyBoxInto(this.target, this.layout.layoutBox);
          }
          applyBoxDelta(this.target, this.targetDelta);
        } else {
          copyBoxInto(this.target, this.layout.layoutBox);
        }
        if (this.attemptToResolveRelativeTarget) {
          this.attemptToResolveRelativeTarget = false;
          const relativeParent = this.getClosestProjectingParent();
          if (relativeParent && Boolean(relativeParent.resumingFrom) === Boolean(this.resumingFrom) && !relativeParent.options.layoutScroll && relativeParent.target && this.animationProgress !== 1) {
            this.relativeParent = relativeParent;
            this.forceRelativeParentToResolveTarget();
            this.relativeTarget = createBox();
            this.relativeTargetOrigin = createBox();
            calcRelativePosition(this.relativeTargetOrigin, this.target, relativeParent.target);
            copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);
          } else {
            this.relativeParent = this.relativeTarget = void 0;
          }
        }
        if (isDebug) {
          metrics.resolvedTargetDeltas++;
        }
      }
      getClosestProjectingParent() {
        if (!this.parent || hasScale(this.parent.latestValues) || has2DTranslate(this.parent.latestValues)) {
          return void 0;
        }
        if (this.parent.isProjecting()) {
          return this.parent;
        } else {
          return this.parent.getClosestProjectingParent();
        }
      }
      isProjecting() {
        return Boolean((this.relativeTarget || this.targetDelta || this.options.layoutRoot) && this.layout);
      }
      calcProjection() {
        var _a;
        const lead = this.getLead();
        const isShared = Boolean(this.resumingFrom) || this !== lead;
        let canSkip = true;
        if (this.isProjectionDirty || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty)) {
          canSkip = false;
        }
        if (isShared && (this.isSharedProjectionDirty || this.isTransformDirty)) {
          canSkip = false;
        }
        if (this.resolvedRelativeTargetAt === frameData.timestamp) {
          canSkip = false;
        }
        if (canSkip)
          return;
        const { layout: layout2, layoutId } = this.options;
        this.isTreeAnimating = Boolean(this.parent && this.parent.isTreeAnimating || this.currentAnimation || this.pendingAnimation);
        if (!this.isTreeAnimating) {
          this.targetDelta = this.relativeTarget = void 0;
        }
        if (!this.layout || !(layout2 || layoutId))
          return;
        copyBoxInto(this.layoutCorrected, this.layout.layoutBox);
        const prevTreeScaleX = this.treeScale.x;
        const prevTreeScaleY = this.treeScale.y;
        applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);
        if (lead.layout && !lead.target && (this.treeScale.x !== 1 || this.treeScale.y !== 1)) {
          lead.target = lead.layout.layoutBox;
          lead.targetWithTransforms = createBox();
        }
        const { target } = lead;
        if (!target) {
          if (this.prevProjectionDelta) {
            this.createProjectionDeltas();
            this.scheduleRender();
          }
          return;
        }
        if (!this.projectionDelta || !this.prevProjectionDelta) {
          this.createProjectionDeltas();
        } else {
          copyAxisDeltaInto(this.prevProjectionDelta.x, this.projectionDelta.x);
          copyAxisDeltaInto(this.prevProjectionDelta.y, this.projectionDelta.y);
        }
        calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);
        if (this.treeScale.x !== prevTreeScaleX || this.treeScale.y !== prevTreeScaleY || !axisDeltaEquals(this.projectionDelta.x, this.prevProjectionDelta.x) || !axisDeltaEquals(this.projectionDelta.y, this.prevProjectionDelta.y)) {
          this.hasProjected = true;
          this.scheduleRender();
          this.notifyListeners("projectionUpdate", target);
        }
        if (isDebug) {
          metrics.recalculatedProjection++;
        }
      }
      hide() {
        this.isVisible = false;
      }
      show() {
        this.isVisible = true;
      }
      scheduleRender(notifyAll = true) {
        var _a;
        (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.scheduleRender();
        if (notifyAll) {
          const stack = this.getStack();
          stack && stack.scheduleRender();
        }
        if (this.resumingFrom && !this.resumingFrom.instance) {
          this.resumingFrom = void 0;
        }
      }
      createProjectionDeltas() {
        this.prevProjectionDelta = createDelta();
        this.projectionDelta = createDelta();
        this.projectionDeltaWithTransform = createDelta();
      }
      setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {
        const snapshot = this.snapshot;
        const snapshotLatestValues = snapshot ? snapshot.latestValues : {};
        const mixedValues = { ...this.latestValues };
        const targetDelta = createDelta();
        if (!this.relativeParent || !this.relativeParent.options.layoutRoot) {
          this.relativeTarget = this.relativeTargetOrigin = void 0;
        }
        this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;
        const relativeLayout = createBox();
        const snapshotSource = snapshot ? snapshot.source : void 0;
        const layoutSource = this.layout ? this.layout.source : void 0;
        const isSharedLayoutAnimation = snapshotSource !== layoutSource;
        const stack = this.getStack();
        const isOnlyMember = !stack || stack.members.length <= 1;
        const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation && !isOnlyMember && this.options.crossfade === true && !this.path.some(hasOpacityCrossfade));
        this.animationProgress = 0;
        let prevRelativeTarget;
        this.mixTargetDelta = (latest) => {
          const progress2 = latest / 1e3;
          mixAxisDelta(targetDelta.x, delta.x, progress2);
          mixAxisDelta(targetDelta.y, delta.y, progress2);
          this.setTargetDelta(targetDelta);
          if (this.relativeTarget && this.relativeTargetOrigin && this.layout && this.relativeParent && this.relativeParent.layout) {
            calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);
            mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress2);
            if (prevRelativeTarget && boxEquals(this.relativeTarget, prevRelativeTarget)) {
              this.isProjectionDirty = false;
            }
            if (!prevRelativeTarget)
              prevRelativeTarget = createBox();
            copyBoxInto(prevRelativeTarget, this.relativeTarget);
          }
          if (isSharedLayoutAnimation) {
            this.animationValues = mixedValues;
            mixValues(mixedValues, snapshotLatestValues, this.latestValues, progress2, shouldCrossfadeOpacity, isOnlyMember);
          }
          this.root.scheduleUpdateProjection();
          this.scheduleRender();
          this.animationProgress = progress2;
        };
        this.mixTargetDelta(this.options.layoutRoot ? 1e3 : 0);
      }
      startAnimation(options2) {
        this.notifyListeners("animationStart");
        this.currentAnimation && this.currentAnimation.stop();
        if (this.resumingFrom && this.resumingFrom.currentAnimation) {
          this.resumingFrom.currentAnimation.stop();
        }
        if (this.pendingAnimation) {
          cancelFrame(this.pendingAnimation);
          this.pendingAnimation = void 0;
        }
        this.pendingAnimation = frame.update(() => {
          globalProjectionState.hasAnimatedSinceResize = true;
          this.currentAnimation = animateSingleValue(0, animationTarget, {
            ...options2,
            onUpdate: (latest) => {
              this.mixTargetDelta(latest);
              options2.onUpdate && options2.onUpdate(latest);
            },
            onComplete: () => {
              options2.onComplete && options2.onComplete();
              this.completeAnimation();
            }
          });
          if (this.resumingFrom) {
            this.resumingFrom.currentAnimation = this.currentAnimation;
          }
          this.pendingAnimation = void 0;
        });
      }
      completeAnimation() {
        if (this.resumingFrom) {
          this.resumingFrom.currentAnimation = void 0;
          this.resumingFrom.preserveOpacity = void 0;
        }
        const stack = this.getStack();
        stack && stack.exitAnimationComplete();
        this.resumingFrom = this.currentAnimation = this.animationValues = void 0;
        this.notifyListeners("animationComplete");
      }
      finishAnimation() {
        if (this.currentAnimation) {
          this.mixTargetDelta && this.mixTargetDelta(animationTarget);
          this.currentAnimation.stop();
        }
        this.completeAnimation();
      }
      applyTransformsToTarget() {
        const lead = this.getLead();
        let { targetWithTransforms, target, layout: layout2, latestValues } = lead;
        if (!targetWithTransforms || !target || !layout2)
          return;
        if (this !== lead && this.layout && layout2 && shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout2.layoutBox)) {
          target = this.target || createBox();
          const xLength = calcLength(this.layout.layoutBox.x);
          target.x.min = lead.target.x.min;
          target.x.max = target.x.min + xLength;
          const yLength = calcLength(this.layout.layoutBox.y);
          target.y.min = lead.target.y.min;
          target.y.max = target.y.min + yLength;
        }
        copyBoxInto(targetWithTransforms, target);
        transformBox(targetWithTransforms, latestValues);
        calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);
      }
      registerSharedNode(layoutId, node2) {
        if (!this.sharedNodes.has(layoutId)) {
          this.sharedNodes.set(layoutId, new NodeStack());
        }
        const stack = this.sharedNodes.get(layoutId);
        stack.add(node2);
        const config = node2.options.initialPromotionConfig;
        node2.promote({
          transition: config ? config.transition : void 0,
          preserveFollowOpacity: config && config.shouldPreserveFollowOpacity ? config.shouldPreserveFollowOpacity(node2) : void 0
        });
      }
      isLead() {
        const stack = this.getStack();
        return stack ? stack.lead === this : true;
      }
      getLead() {
        var _a;
        const { layoutId } = this.options;
        return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;
      }
      getPrevLead() {
        var _a;
        const { layoutId } = this.options;
        return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : void 0;
      }
      getStack() {
        const { layoutId } = this.options;
        if (layoutId)
          return this.root.sharedNodes.get(layoutId);
      }
      promote({ needsReset, transition, preserveFollowOpacity } = {}) {
        const stack = this.getStack();
        if (stack)
          stack.promote(this, preserveFollowOpacity);
        if (needsReset) {
          this.projectionDelta = void 0;
          this.needsReset = true;
        }
        if (transition)
          this.setOptions({ transition });
      }
      relegate() {
        const stack = this.getStack();
        if (stack) {
          return stack.relegate(this);
        } else {
          return false;
        }
      }
      resetSkewAndRotation() {
        const { visualElement } = this.options;
        if (!visualElement)
          return;
        let hasDistortingTransform = false;
        const { latestValues } = visualElement;
        if (latestValues.z || latestValues.rotate || latestValues.rotateX || latestValues.rotateY || latestValues.rotateZ || latestValues.skewX || latestValues.skewY) {
          hasDistortingTransform = true;
        }
        if (!hasDistortingTransform)
          return;
        const resetValues = {};
        if (latestValues.z) {
          resetDistortingTransform("z", visualElement, resetValues, this.animationValues);
        }
        for (let i3 = 0; i3 < transformAxes.length; i3++) {
          resetDistortingTransform(`rotate${transformAxes[i3]}`, visualElement, resetValues, this.animationValues);
          resetDistortingTransform(`skew${transformAxes[i3]}`, visualElement, resetValues, this.animationValues);
        }
        visualElement.render();
        for (const key in resetValues) {
          visualElement.setStaticValue(key, resetValues[key]);
          if (this.animationValues) {
            this.animationValues[key] = resetValues[key];
          }
        }
        visualElement.scheduleRender();
      }
      getProjectionStyles(styleProp) {
        var _a, _b;
        if (!this.instance || this.isSVG)
          return void 0;
        if (!this.isVisible) {
          return hiddenVisibility;
        }
        const styles3 = {
          visibility: ""
        };
        const transformTemplate = this.getTransformTemplate();
        if (this.needsReset) {
          this.needsReset = false;
          styles3.opacity = "";
          styles3.pointerEvents = resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || "";
          styles3.transform = transformTemplate ? transformTemplate(this.latestValues, "") : "none";
          return styles3;
        }
        const lead = this.getLead();
        if (!this.projectionDelta || !this.layout || !lead.target) {
          const emptyStyles = {};
          if (this.options.layoutId) {
            emptyStyles.opacity = this.latestValues.opacity !== void 0 ? this.latestValues.opacity : 1;
            emptyStyles.pointerEvents = resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || "";
          }
          if (this.hasProjected && !hasTransform(this.latestValues)) {
            emptyStyles.transform = transformTemplate ? transformTemplate({}, "") : "none";
            this.hasProjected = false;
          }
          return emptyStyles;
        }
        const valuesToRender = lead.animationValues || lead.latestValues;
        this.applyTransformsToTarget();
        styles3.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);
        if (transformTemplate) {
          styles3.transform = transformTemplate(valuesToRender, styles3.transform);
        }
        const { x: x2, y: y3 } = this.projectionDelta;
        styles3.transformOrigin = `${x2.origin * 100}% ${y3.origin * 100}% 0`;
        if (lead.animationValues) {
          styles3.opacity = lead === this ? (_b = (_a = valuesToRender.opacity) !== null && _a !== void 0 ? _a : this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1 : this.preserveOpacity ? this.latestValues.opacity : valuesToRender.opacityExit;
        } else {
          styles3.opacity = lead === this ? valuesToRender.opacity !== void 0 ? valuesToRender.opacity : "" : valuesToRender.opacityExit !== void 0 ? valuesToRender.opacityExit : 0;
        }
        for (const key in scaleCorrectors) {
          if (valuesToRender[key] === void 0)
            continue;
          const { correct, applyTo } = scaleCorrectors[key];
          const corrected = styles3.transform === "none" ? valuesToRender[key] : correct(valuesToRender[key], lead);
          if (applyTo) {
            const num = applyTo.length;
            for (let i3 = 0; i3 < num; i3++) {
              styles3[applyTo[i3]] = corrected;
            }
          } else {
            styles3[key] = corrected;
          }
        }
        if (this.options.layoutId) {
          styles3.pointerEvents = lead === this ? resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || "" : "none";
        }
        return styles3;
      }
      clearSnapshot() {
        this.resumeFrom = this.snapshot = void 0;
      }
      // Only run on root
      resetTree() {
        this.root.nodes.forEach((node2) => {
          var _a;
          return (_a = node2.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();
        });
        this.root.nodes.forEach(clearMeasurements);
        this.root.sharedNodes.clear();
      }
    };
  }
  function updateLayout(node2) {
    node2.updateLayout();
  }
  function notifyLayoutUpdate(node2) {
    var _a;
    const snapshot = ((_a = node2.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) || node2.snapshot;
    if (node2.isLead() && node2.layout && snapshot && node2.hasListeners("didUpdate")) {
      const { layoutBox: layout2, measuredBox: measuredLayout } = node2.layout;
      const { animationType } = node2.options;
      const isShared = snapshot.source !== node2.layout.source;
      if (animationType === "size") {
        eachAxis((axis) => {
          const axisSnapshot = isShared ? snapshot.measuredBox[axis] : snapshot.layoutBox[axis];
          const length2 = calcLength(axisSnapshot);
          axisSnapshot.min = layout2[axis].min;
          axisSnapshot.max = axisSnapshot.min + length2;
        });
      } else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout2)) {
        eachAxis((axis) => {
          const axisSnapshot = isShared ? snapshot.measuredBox[axis] : snapshot.layoutBox[axis];
          const length2 = calcLength(layout2[axis]);
          axisSnapshot.max = axisSnapshot.min + length2;
          if (node2.relativeTarget && !node2.currentAnimation) {
            node2.isProjectionDirty = true;
            node2.relativeTarget[axis].max = node2.relativeTarget[axis].min + length2;
          }
        });
      }
      const layoutDelta = createDelta();
      calcBoxDelta(layoutDelta, layout2, snapshot.layoutBox);
      const visualDelta = createDelta();
      if (isShared) {
        calcBoxDelta(visualDelta, node2.applyTransform(measuredLayout, true), snapshot.measuredBox);
      } else {
        calcBoxDelta(visualDelta, layout2, snapshot.layoutBox);
      }
      const hasLayoutChanged = !isDeltaZero(layoutDelta);
      let hasRelativeTargetChanged = false;
      if (!node2.resumeFrom) {
        const relativeParent = node2.getClosestProjectingParent();
        if (relativeParent && !relativeParent.resumeFrom) {
          const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;
          if (parentSnapshot && parentLayout) {
            const relativeSnapshot = createBox();
            calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox);
            const relativeLayout = createBox();
            calcRelativePosition(relativeLayout, layout2, parentLayout.layoutBox);
            if (!boxEqualsRounded(relativeSnapshot, relativeLayout)) {
              hasRelativeTargetChanged = true;
            }
            if (relativeParent.options.layoutRoot) {
              node2.relativeTarget = relativeLayout;
              node2.relativeTargetOrigin = relativeSnapshot;
              node2.relativeParent = relativeParent;
            }
          }
        }
      }
      node2.notifyListeners("didUpdate", {
        layout: layout2,
        snapshot,
        delta: visualDelta,
        layoutDelta,
        hasLayoutChanged,
        hasRelativeTargetChanged
      });
    } else if (node2.isLead()) {
      const { onExitComplete } = node2.options;
      onExitComplete && onExitComplete();
    }
    node2.options.transition = void 0;
  }
  function propagateDirtyNodes(node2) {
    if (isDebug) {
      metrics.totalNodes++;
    }
    if (!node2.parent)
      return;
    if (!node2.isProjecting()) {
      node2.isProjectionDirty = node2.parent.isProjectionDirty;
    }
    node2.isSharedProjectionDirty || (node2.isSharedProjectionDirty = Boolean(node2.isProjectionDirty || node2.parent.isProjectionDirty || node2.parent.isSharedProjectionDirty));
    node2.isTransformDirty || (node2.isTransformDirty = node2.parent.isTransformDirty);
  }
  function cleanDirtyNodes(node2) {
    node2.isProjectionDirty = node2.isSharedProjectionDirty = node2.isTransformDirty = false;
  }
  function clearSnapshot(node2) {
    node2.clearSnapshot();
  }
  function clearMeasurements(node2) {
    node2.clearMeasurements();
  }
  function clearIsLayoutDirty(node2) {
    node2.isLayoutDirty = false;
  }
  function resetTransformStyle(node2) {
    const { visualElement } = node2.options;
    if (visualElement && visualElement.getProps().onBeforeLayoutMeasure) {
      visualElement.notify("BeforeLayoutMeasure");
    }
    node2.resetTransform();
  }
  function finishAnimation(node2) {
    node2.finishAnimation();
    node2.targetDelta = node2.relativeTarget = node2.target = void 0;
    node2.isProjectionDirty = true;
  }
  function resolveTargetDelta(node2) {
    node2.resolveTargetDelta();
  }
  function calcProjection(node2) {
    node2.calcProjection();
  }
  function resetSkewAndRotation(node2) {
    node2.resetSkewAndRotation();
  }
  function removeLeadSnapshots(stack) {
    stack.removeLeadSnapshot();
  }
  function mixAxisDelta(output, delta, p3) {
    output.translate = mixNumber(delta.translate, 0, p3);
    output.scale = mixNumber(delta.scale, 1, p3);
    output.origin = delta.origin;
    output.originPoint = delta.originPoint;
  }
  function mixAxis(output, from2, to, p3) {
    output.min = mixNumber(from2.min, to.min, p3);
    output.max = mixNumber(from2.max, to.max, p3);
  }
  function mixBox(output, from2, to, p3) {
    mixAxis(output.x, from2.x, to.x, p3);
    mixAxis(output.y, from2.y, to.y, p3);
  }
  function hasOpacityCrossfade(node2) {
    return node2.animationValues && node2.animationValues.opacityExit !== void 0;
  }
  var defaultLayoutTransition = {
    duration: 0.45,
    ease: [0.4, 0, 0.1, 1]
  };
  var userAgentContains = (string) => typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().includes(string);
  var roundPoint = userAgentContains("applewebkit/") && !userAgentContains("chrome/") ? Math.round : noop2;
  function roundAxis(axis) {
    axis.min = roundPoint(axis.min);
    axis.max = roundPoint(axis.max);
  }
  function roundBox(box) {
    roundAxis(box.x);
    roundAxis(box.y);
  }
  function shouldAnimatePositionOnly(animationType, snapshot, layout2) {
    return animationType === "position" || animationType === "preserve-aspect" && !isNear(aspectRatio(snapshot), aspectRatio(layout2), 0.2);
  }
  function checkNodeWasScrollRoot(node2) {
    var _a;
    return node2 !== node2.root && ((_a = node2.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot);
  }

  // packages/components/node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs
  var DocumentProjectionNode = createProjectionNode({
    attachResizeListener: (ref, notify) => addDomEvent(ref, "resize", notify),
    measureScroll: () => ({
      x: document.documentElement.scrollLeft || document.body.scrollLeft,
      y: document.documentElement.scrollTop || document.body.scrollTop
    }),
    checkIsScrollRoot: () => true
  });

  // packages/components/node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs
  var rootProjectionNode = {
    current: void 0
  };
  var HTMLProjectionNode = createProjectionNode({
    measureScroll: (instance) => ({
      x: instance.scrollLeft,
      y: instance.scrollTop
    }),
    defaultParent: () => {
      if (!rootProjectionNode.current) {
        const documentNode = new DocumentProjectionNode({});
        documentNode.mount(window);
        documentNode.setOptions({ layoutScroll: true });
        rootProjectionNode.current = documentNode;
      }
      return rootProjectionNode.current;
    },
    resetTransform: (instance, value) => {
      instance.style.transform = value !== void 0 ? value : "none";
    },
    checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === "fixed")
  });

  // packages/components/node_modules/framer-motion/dist/es/motion/features/drag.mjs
  var drag = {
    pan: {
      Feature: PanGesture
    },
    drag: {
      Feature: DragGesture,
      ProjectionNode: HTMLProjectionNode,
      MeasureLayout
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/gestures/hover.mjs
  function handleHoverEvent(node2, event, lifecycle) {
    const { props } = node2;
    if (node2.animationState && props.whileHover) {
      node2.animationState.setActive("whileHover", lifecycle === "Start");
    }
    const eventName = "onHover" + lifecycle;
    const callback = props[eventName];
    if (callback) {
      frame.postRender(() => callback(event, extractEventInfo(event)));
    }
  }
  var HoverGesture = class extends Feature {
    mount() {
      const { current } = this.node;
      if (!current)
        return;
      this.unmount = hover(current, (startEvent) => {
        handleHoverEvent(this.node, startEvent, "Start");
        return (endEvent) => handleHoverEvent(this.node, endEvent, "End");
      });
    }
    unmount() {
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/gestures/focus.mjs
  var FocusGesture = class extends Feature {
    constructor() {
      super(...arguments);
      this.isActive = false;
    }
    onFocus() {
      let isFocusVisible = false;
      try {
        isFocusVisible = this.node.current.matches(":focus-visible");
      } catch (e3) {
        isFocusVisible = true;
      }
      if (!isFocusVisible || !this.node.animationState)
        return;
      this.node.animationState.setActive("whileFocus", true);
      this.isActive = true;
    }
    onBlur() {
      if (!this.isActive || !this.node.animationState)
        return;
      this.node.animationState.setActive("whileFocus", false);
      this.isActive = false;
    }
    mount() {
      this.unmount = pipe(addDomEvent(this.node.current, "focus", () => this.onFocus()), addDomEvent(this.node.current, "blur", () => this.onBlur()));
    }
    unmount() {
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/gestures/press.mjs
  function handlePressEvent(node2, event, lifecycle) {
    const { props } = node2;
    if (node2.animationState && props.whileTap) {
      node2.animationState.setActive("whileTap", lifecycle === "Start");
    }
    const eventName = "onTap" + (lifecycle === "End" ? "" : lifecycle);
    const callback = props[eventName];
    if (callback) {
      frame.postRender(() => callback(event, extractEventInfo(event)));
    }
  }
  var PressGesture = class extends Feature {
    mount() {
      const { current } = this.node;
      if (!current)
        return;
      this.unmount = press(current, (startEvent) => {
        handlePressEvent(this.node, startEvent, "Start");
        return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? "End" : "Cancel");
      }, { useGlobalTarget: this.node.props.globalTapTarget });
    }
    unmount() {
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs
  var observerCallbacks = /* @__PURE__ */ new WeakMap();
  var observers = /* @__PURE__ */ new WeakMap();
  var fireObserverCallback = (entry) => {
    const callback = observerCallbacks.get(entry.target);
    callback && callback(entry);
  };
  var fireAllObserverCallbacks = (entries) => {
    entries.forEach(fireObserverCallback);
  };
  function initIntersectionObserver({ root, ...options2 }) {
    const lookupRoot = root || document;
    if (!observers.has(lookupRoot)) {
      observers.set(lookupRoot, {});
    }
    const rootObservers = observers.get(lookupRoot);
    const key = JSON.stringify(options2);
    if (!rootObservers[key]) {
      rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options2 });
    }
    return rootObservers[key];
  }
  function observeIntersection(element, options2, callback) {
    const rootInteresectionObserver = initIntersectionObserver(options2);
    observerCallbacks.set(element, callback);
    rootInteresectionObserver.observe(element);
    return () => {
      observerCallbacks.delete(element);
      rootInteresectionObserver.unobserve(element);
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs
  var thresholdNames = {
    some: 0,
    all: 1
  };
  var InViewFeature = class extends Feature {
    constructor() {
      super(...arguments);
      this.hasEnteredView = false;
      this.isInView = false;
    }
    startObserver() {
      this.unmount();
      const { viewport = {} } = this.node.getProps();
      const { root, margin: rootMargin, amount = "some", once } = viewport;
      const options2 = {
        root: root ? root.current : void 0,
        rootMargin,
        threshold: typeof amount === "number" ? amount : thresholdNames[amount]
      };
      const onIntersectionUpdate = (entry) => {
        const { isIntersecting } = entry;
        if (this.isInView === isIntersecting)
          return;
        this.isInView = isIntersecting;
        if (once && !isIntersecting && this.hasEnteredView) {
          return;
        } else if (isIntersecting) {
          this.hasEnteredView = true;
        }
        if (this.node.animationState) {
          this.node.animationState.setActive("whileInView", isIntersecting);
        }
        const { onViewportEnter, onViewportLeave } = this.node.getProps();
        const callback = isIntersecting ? onViewportEnter : onViewportLeave;
        callback && callback(entry);
      };
      return observeIntersection(this.node.current, options2, onIntersectionUpdate);
    }
    mount() {
      this.startObserver();
    }
    update() {
      if (typeof IntersectionObserver === "undefined")
        return;
      const { props, prevProps } = this.node;
      const hasOptionsChanged = ["amount", "margin", "root"].some(hasViewportOptionChanged(props, prevProps));
      if (hasOptionsChanged) {
        this.startObserver();
      }
    }
    unmount() {
    }
  };
  function hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {
    return (name) => viewport[name] !== prevViewport[name];
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/features/gestures.mjs
  var gestureAnimations = {
    inView: {
      Feature: InViewFeature
    },
    tap: {
      Feature: PressGesture
    },
    focus: {
      Feature: FocusGesture
    },
    hover: {
      Feature: HoverGesture
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/motion/features/layout.mjs
  var layout = {
    layout: {
      ProjectionNode: HTMLProjectionNode,
      MeasureLayout
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/motion/index.mjs
  var import_jsx_runtime40 = __toESM(require_jsx_runtime(), 1);
  var import_react67 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs
  var import_react60 = __toESM(require_react(), 1);
  var MotionConfigContext = (0, import_react60.createContext)({
    transformPagePoint: (p3) => p3,
    isStatic: false,
    reducedMotion: "never"
  });

  // packages/components/node_modules/framer-motion/dist/es/context/MotionContext/index.mjs
  var import_react61 = __toESM(require_react(), 1);
  var MotionContext = (0, import_react61.createContext)({});

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs
  var import_react64 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs
  var import_react62 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/utils/is-browser.mjs
  var isBrowser = typeof window !== "undefined";

  // packages/components/node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs
  var useIsomorphicLayoutEffect = isBrowser ? import_react62.useLayoutEffect : import_react62.useEffect;

  // packages/components/node_modules/framer-motion/dist/es/context/LazyContext.mjs
  var import_react63 = __toESM(require_react(), 1);
  var LazyContext = (0, import_react63.createContext)({ strict: false });

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs
  function useVisualElement(Component7, visualState, props, createVisualElement, ProjectionNodeConstructor) {
    var _a, _b;
    const { visualElement: parent } = (0, import_react64.useContext)(MotionContext);
    const lazyContext = (0, import_react64.useContext)(LazyContext);
    const presenceContext = (0, import_react64.useContext)(PresenceContext);
    const reducedMotionConfig = (0, import_react64.useContext)(MotionConfigContext).reducedMotion;
    const visualElementRef = (0, import_react64.useRef)(null);
    createVisualElement = createVisualElement || lazyContext.renderer;
    if (!visualElementRef.current && createVisualElement) {
      visualElementRef.current = createVisualElement(Component7, {
        visualState,
        parent,
        props,
        presenceContext,
        blockInitialAnimation: presenceContext ? presenceContext.initial === false : false,
        reducedMotionConfig
      });
    }
    const visualElement = visualElementRef.current;
    const initialLayoutGroupConfig = (0, import_react64.useContext)(SwitchLayoutGroupContext);
    if (visualElement && !visualElement.projection && ProjectionNodeConstructor && (visualElement.type === "html" || visualElement.type === "svg")) {
      createProjectionNode2(visualElementRef.current, props, ProjectionNodeConstructor, initialLayoutGroupConfig);
    }
    const isMounted = (0, import_react64.useRef)(false);
    (0, import_react64.useInsertionEffect)(() => {
      if (visualElement && isMounted.current) {
        visualElement.update(props, presenceContext);
      }
    });
    const optimisedAppearId = props[optimizedAppearDataAttribute];
    const wantsHandoff = (0, import_react64.useRef)(Boolean(optimisedAppearId) && !((_a = window.MotionHandoffIsComplete) === null || _a === void 0 ? void 0 : _a.call(window, optimisedAppearId)) && ((_b = window.MotionHasOptimisedAnimation) === null || _b === void 0 ? void 0 : _b.call(window, optimisedAppearId)));
    useIsomorphicLayoutEffect(() => {
      if (!visualElement)
        return;
      isMounted.current = true;
      window.MotionIsMounted = true;
      visualElement.updateFeatures();
      microtask.render(visualElement.render);
      if (wantsHandoff.current && visualElement.animationState) {
        visualElement.animationState.animateChanges();
      }
    });
    (0, import_react64.useEffect)(() => {
      if (!visualElement)
        return;
      if (!wantsHandoff.current && visualElement.animationState) {
        visualElement.animationState.animateChanges();
      }
      if (wantsHandoff.current) {
        queueMicrotask(() => {
          var _a2;
          (_a2 = window.MotionHandoffMarkAsComplete) === null || _a2 === void 0 ? void 0 : _a2.call(window, optimisedAppearId);
        });
        wantsHandoff.current = false;
      }
    });
    return visualElement;
  }
  function createProjectionNode2(visualElement, props, ProjectionNodeConstructor, initialPromotionConfig) {
    const { layoutId, layout: layout2, drag: drag2, dragConstraints, layoutScroll, layoutRoot } = props;
    visualElement.projection = new ProjectionNodeConstructor(visualElement.latestValues, props["data-framer-portal-id"] ? void 0 : getClosestProjectingNode(visualElement.parent));
    visualElement.projection.setOptions({
      layoutId,
      layout: layout2,
      alwaysMeasureLayout: Boolean(drag2) || dragConstraints && isRefObject(dragConstraints),
      visualElement,
      /**
       * TODO: Update options in an effect. This could be tricky as it'll be too late
       * to update by the time layout animations run.
       * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
       * ensuring it gets called if there's no potential layout animations.
       *
       */
      animationType: typeof layout2 === "string" ? layout2 : "both",
      initialPromotionConfig,
      layoutScroll,
      layoutRoot
    });
  }
  function getClosestProjectingNode(visualElement) {
    if (!visualElement)
      return void 0;
    return visualElement.options.allowProjection !== false ? visualElement.projection : getClosestProjectingNode(visualElement.parent);
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs
  var import_react65 = __toESM(require_react(), 1);
  function useMotionRef(visualState, visualElement, externalRef) {
    return (0, import_react65.useCallback)(
      (instance) => {
        instance && visualState.mount && visualState.mount(instance);
        if (visualElement) {
          if (instance) {
            visualElement.mount(instance);
          } else {
            visualElement.unmount();
          }
        }
        if (externalRef) {
          if (typeof externalRef === "function") {
            externalRef(instance);
          } else if (isRefObject(externalRef)) {
            externalRef.current = instance;
          }
        }
      },
      /**
       * Only pass a new ref callback to React if we've received a visual element
       * factory. Otherwise we'll be mounting/remounting every time externalRef
       * or other dependencies change.
       */
      [visualElement]
    );
  }

  // packages/components/node_modules/framer-motion/dist/es/context/MotionContext/create.mjs
  var import_react66 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.mjs
  function isControllingVariants(props) {
    return isAnimationControls(props.animate) || variantProps.some((name) => isVariantLabel(props[name]));
  }
  function isVariantNode(props) {
    return Boolean(isControllingVariants(props) || props.variants);
  }

  // packages/components/node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs
  function getCurrentTreeVariants(props, context) {
    if (isControllingVariants(props)) {
      const { initial, animate } = props;
      return {
        initial: initial === false || isVariantLabel(initial) ? initial : void 0,
        animate: isVariantLabel(animate) ? animate : void 0
      };
    }
    return props.inherit !== false ? context : {};
  }

  // packages/components/node_modules/framer-motion/dist/es/context/MotionContext/create.mjs
  function useCreateMotionContext(props) {
    const { initial, animate } = getCurrentTreeVariants(props, (0, import_react66.useContext)(MotionContext));
    return (0, import_react66.useMemo)(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
  }
  function variantLabelsAsDependency(prop) {
    return Array.isArray(prop) ? prop.join(" ") : prop;
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/features/definitions.mjs
  var featureProps = {
    animation: [
      "animate",
      "variants",
      "whileHover",
      "whileTap",
      "exit",
      "whileInView",
      "whileFocus",
      "whileDrag"
    ],
    exit: ["exit"],
    drag: ["drag", "dragControls"],
    focus: ["whileFocus"],
    hover: ["whileHover", "onHoverStart", "onHoverEnd"],
    tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
    pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
    inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
    layout: ["layout", "layoutId"]
  };
  var featureDefinitions = {};
  for (const key in featureProps) {
    featureDefinitions[key] = {
      isEnabled: (props) => featureProps[key].some((name) => !!props[name])
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/features/load-features.mjs
  function loadFeatures(features) {
    for (const key in features) {
      featureDefinitions[key] = {
        ...featureDefinitions[key],
        ...features[key]
      };
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/symbol.mjs
  var motionComponentSymbol = /* @__PURE__ */ Symbol.for("motionComponentSymbol");

  // packages/components/node_modules/framer-motion/dist/es/motion/index.mjs
  function createRendererMotionComponent({ preloadedFeatures, createVisualElement, useRender, useVisualState, Component: Component7 }) {
    preloadedFeatures && loadFeatures(preloadedFeatures);
    function MotionComponent(props, externalRef) {
      let MeasureLayout2;
      const configAndProps = {
        ...(0, import_react67.useContext)(MotionConfigContext),
        ...props,
        layoutId: useLayoutId(props)
      };
      const { isStatic } = configAndProps;
      const context = useCreateMotionContext(props);
      const visualState = useVisualState(props, isStatic);
      if (!isStatic && isBrowser) {
        useStrictMode(configAndProps, preloadedFeatures);
        const layoutProjection = getProjectionFunctionality(configAndProps);
        MeasureLayout2 = layoutProjection.MeasureLayout;
        context.visualElement = useVisualElement(Component7, visualState, configAndProps, createVisualElement, layoutProjection.ProjectionNode);
      }
      return (0, import_jsx_runtime40.jsxs)(MotionContext.Provider, { value: context, children: [MeasureLayout2 && context.visualElement ? (0, import_jsx_runtime40.jsx)(MeasureLayout2, { visualElement: context.visualElement, ...configAndProps }) : null, useRender(Component7, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, context.visualElement)] });
    }
    const ForwardRefMotionComponent = (0, import_react67.forwardRef)(MotionComponent);
    ForwardRefMotionComponent[motionComponentSymbol] = Component7;
    return ForwardRefMotionComponent;
  }
  function useLayoutId({ layoutId }) {
    const layoutGroupId = (0, import_react67.useContext)(LayoutGroupContext).id;
    return layoutGroupId && layoutId !== void 0 ? layoutGroupId + "-" + layoutId : layoutId;
  }
  function useStrictMode(configAndProps, preloadedFeatures) {
    const isStrict = (0, import_react67.useContext)(LazyContext).strict;
    if (preloadedFeatures && isStrict) {
      const strictMessage = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
      configAndProps.ignoreStrict ? warning(false, strictMessage) : invariant2(false, strictMessage);
    }
  }
  function getProjectionFunctionality(props) {
    const { drag: drag2, layout: layout2 } = featureDefinitions;
    if (!drag2 && !layout2)
      return {};
    const combined = { ...drag2, ...layout2 };
    return {
      MeasureLayout: (drag2 === null || drag2 === void 0 ? void 0 : drag2.isEnabled(props)) || (layout2 === null || layout2 === void 0 ? void 0 : layout2.isEnabled(props)) ? combined.MeasureLayout : void 0,
      ProjectionNode: combined.ProjectionNode
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs
  var lowercaseSVGElements = [
    "animate",
    "circle",
    "defs",
    "desc",
    "ellipse",
    "g",
    "image",
    "line",
    "filter",
    "marker",
    "mask",
    "metadata",
    "path",
    "pattern",
    "polygon",
    "polyline",
    "rect",
    "stop",
    "switch",
    "symbol",
    "svg",
    "text",
    "tspan",
    "use",
    "view"
  ];

  // packages/components/node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs
  function isSVGComponent(Component7) {
    if (
      /**
       * If it's not a string, it's a custom React component. Currently we only support
       * HTML custom React components.
       */
      typeof Component7 !== "string" || /**
       * If it contains a dash, the element is a custom HTML webcomponent.
       */
      Component7.includes("-")
    ) {
      return false;
    } else if (
      /**
       * If it's in our list of lowercase SVG tags, it's an SVG component
       */
      lowercaseSVGElements.indexOf(Component7) > -1 || /**
       * If it contains a capital letter, it's an SVG component
       */
      /[A-Z]/u.test(Component7)
    ) {
      return true;
    }
    return false;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/html/utils/render.mjs
  function renderHTML(element, { style: style2, vars }, styleProp, projection) {
    Object.assign(element.style, style2, projection && projection.getProjectionStyles(styleProp));
    for (const key in vars) {
      element.style.setProperty(key, vars[key]);
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs
  var camelCaseAttributes = /* @__PURE__ */ new Set([
    "baseFrequency",
    "diffuseConstant",
    "kernelMatrix",
    "kernelUnitLength",
    "keySplines",
    "keyTimes",
    "limitingConeAngle",
    "markerHeight",
    "markerWidth",
    "numOctaves",
    "targetX",
    "targetY",
    "surfaceScale",
    "specularConstant",
    "specularExponent",
    "stdDeviation",
    "tableValues",
    "viewBox",
    "gradientTransform",
    "pathLength",
    "startOffset",
    "textLength",
    "lengthAdjust"
  ]);

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/render.mjs
  function renderSVG(element, renderState, _styleProp, projection) {
    renderHTML(element, renderState, void 0, projection);
    for (const key in renderState.attrs) {
      element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs
  function isForcedMotionValue(key, { layout: layout2, layoutId }) {
    return transformProps.has(key) || key.startsWith("origin") || (layout2 || layoutId !== void 0) && (!!scaleCorrectors[key] || key === "opacity");
  }

  // packages/components/node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs
  function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
    var _a;
    const { style: style2 } = props;
    const newValues = {};
    for (const key in style2) {
      if (isMotionValue(style2[key]) || prevProps.style && isMotionValue(prevProps.style[key]) || isForcedMotionValue(key, props) || ((_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.liveStyle) !== void 0) {
        newValues[key] = style2[key];
      }
    }
    return newValues;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs
  function scrapeMotionValuesFromProps2(props, prevProps, visualElement) {
    const newValues = scrapeMotionValuesFromProps(props, prevProps, visualElement);
    for (const key in props) {
      if (isMotionValue(props[key]) || isMotionValue(prevProps[key])) {
        const targetKey = transformPropOrder.indexOf(key) !== -1 ? "attr" + key.charAt(0).toUpperCase() + key.substring(1) : key;
        newValues[targetKey] = props[key];
      }
    }
    return newValues;
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs
  var import_react69 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/utils/use-constant.mjs
  var import_react68 = __toESM(require_react(), 1);
  function useConstant(init2) {
    const ref = (0, import_react68.useRef)(null);
    if (ref.current === null) {
      ref.current = init2();
    }
    return ref.current;
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs
  function makeState({ scrapeMotionValuesFromProps: scrapeMotionValuesFromProps3, createRenderState, onMount }, props, context, presenceContext) {
    const state = {
      latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps3),
      renderState: createRenderState()
    };
    if (onMount) {
      state.mount = (instance) => onMount(props, instance, state);
    }
    return state;
  }
  var makeUseVisualState = (config) => (props, isStatic) => {
    const context = (0, import_react69.useContext)(MotionContext);
    const presenceContext = (0, import_react69.useContext)(PresenceContext);
    const make = () => makeState(config, props, context, presenceContext);
    return isStatic ? make() : useConstant(make);
  };
  function makeLatestValues(props, context, presenceContext, scrapeMotionValues) {
    const values = {};
    const motionValues = scrapeMotionValues(props, {});
    for (const key in motionValues) {
      values[key] = resolveMotionValue(motionValues[key]);
    }
    let { initial, animate } = props;
    const isControllingVariants$1 = isControllingVariants(props);
    const isVariantNode$1 = isVariantNode(props);
    if (context && isVariantNode$1 && !isControllingVariants$1 && props.inherit !== false) {
      if (initial === void 0)
        initial = context.initial;
      if (animate === void 0)
        animate = context.animate;
    }
    let isInitialAnimationBlocked = presenceContext ? presenceContext.initial === false : false;
    isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;
    const variantToSet = isInitialAnimationBlocked ? animate : initial;
    if (variantToSet && typeof variantToSet !== "boolean" && !isAnimationControls(variantToSet)) {
      const list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];
      for (let i3 = 0; i3 < list.length; i3++) {
        const resolved = resolveVariantFromProps(props, list[i3]);
        if (resolved) {
          const { transitionEnd, transition, ...target } = resolved;
          for (const key in target) {
            let valueTarget = target[key];
            if (Array.isArray(valueTarget)) {
              const index2 = isInitialAnimationBlocked ? valueTarget.length - 1 : 0;
              valueTarget = valueTarget[index2];
            }
            if (valueTarget !== null) {
              values[key] = valueTarget;
            }
          }
          for (const key in transitionEnd) {
            values[key] = transitionEnd[key];
          }
        }
      }
    }
    return values;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs
  var createHtmlRenderState = () => ({
    style: {},
    transform: {},
    transformOrigin: {},
    vars: {}
  });

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs
  var createSvgRenderState = () => ({
    ...createHtmlRenderState(),
    attrs: {}
  });

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs
  var getValueAsType = (value, type) => {
    return type && typeof value === "number" ? type.transform(value) : value;
  };

  // packages/components/node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs
  var translateAlias = {
    x: "translateX",
    y: "translateY",
    z: "translateZ",
    transformPerspective: "perspective"
  };
  var numTransforms = transformPropOrder.length;
  function buildTransform(latestValues, transform, transformTemplate) {
    let transformString = "";
    let transformIsDefault = true;
    for (let i3 = 0; i3 < numTransforms; i3++) {
      const key = transformPropOrder[i3];
      const value = latestValues[key];
      if (value === void 0)
        continue;
      let valueIsDefault = true;
      if (typeof value === "number") {
        valueIsDefault = value === (key.startsWith("scale") ? 1 : 0);
      } else {
        valueIsDefault = parseFloat(value) === 0;
      }
      if (!valueIsDefault || transformTemplate) {
        const valueAsType = getValueAsType(value, numberValueTypes[key]);
        if (!valueIsDefault) {
          transformIsDefault = false;
          const transformName = translateAlias[key] || key;
          transformString += `${transformName}(${valueAsType}) `;
        }
        if (transformTemplate) {
          transform[key] = valueAsType;
        }
      }
    }
    transformString = transformString.trim();
    if (transformTemplate) {
      transformString = transformTemplate(transform, transformIsDefault ? "" : transformString);
    } else if (transformIsDefault) {
      transformString = "none";
    }
    return transformString;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs
  function buildHTMLStyles(state, latestValues, transformTemplate) {
    const { style: style2, vars, transformOrigin } = state;
    let hasTransform2 = false;
    let hasTransformOrigin = false;
    for (const key in latestValues) {
      const value = latestValues[key];
      if (transformProps.has(key)) {
        hasTransform2 = true;
        continue;
      } else if (isCSSVariableName(key)) {
        vars[key] = value;
        continue;
      } else {
        const valueAsType = getValueAsType(value, numberValueTypes[key]);
        if (key.startsWith("origin")) {
          hasTransformOrigin = true;
          transformOrigin[key] = valueAsType;
        } else {
          style2[key] = valueAsType;
        }
      }
    }
    if (!latestValues.transform) {
      if (hasTransform2 || transformTemplate) {
        style2.transform = buildTransform(latestValues, state.transform, transformTemplate);
      } else if (style2.transform) {
        style2.transform = "none";
      }
    }
    if (hasTransformOrigin) {
      const { originX = "50%", originY = "50%", originZ = 0 } = transformOrigin;
      style2.transformOrigin = `${originX} ${originY} ${originZ}`;
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs
  function calcOrigin2(origin, offset4, size4) {
    return typeof origin === "string" ? origin : px.transform(offset4 + size4 * origin);
  }
  function calcSVGTransformOrigin(dimensions, originX, originY) {
    const pxOriginX = calcOrigin2(originX, dimensions.x, dimensions.width);
    const pxOriginY = calcOrigin2(originY, dimensions.y, dimensions.height);
    return `${pxOriginX} ${pxOriginY}`;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/path.mjs
  var dashKeys = {
    offset: "stroke-dashoffset",
    array: "stroke-dasharray"
  };
  var camelKeys = {
    offset: "strokeDashoffset",
    array: "strokeDasharray"
  };
  function buildSVGPath(attrs, length2, spacing = 1, offset4 = 0, useDashCase = true) {
    attrs.pathLength = 1;
    const keys = useDashCase ? dashKeys : camelKeys;
    attrs[keys.offset] = px.transform(-offset4);
    const pathLength = px.transform(length2);
    const pathSpacing = px.transform(spacing);
    attrs[keys.array] = `${pathLength} ${pathSpacing}`;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs
  function buildSVGAttrs(state, {
    attrX,
    attrY,
    attrScale,
    originX,
    originY,
    pathLength,
    pathSpacing = 1,
    pathOffset = 0,
    // This is object creation, which we try to avoid per-frame.
    ...latest
  }, isSVGTag2, transformTemplate) {
    buildHTMLStyles(state, latest, transformTemplate);
    if (isSVGTag2) {
      if (state.style.viewBox) {
        state.attrs.viewBox = state.style.viewBox;
      }
      return;
    }
    state.attrs = state.style;
    state.style = {};
    const { attrs, style: style2, dimensions } = state;
    if (attrs.transform) {
      if (dimensions)
        style2.transform = attrs.transform;
      delete attrs.transform;
    }
    if (dimensions && (originX !== void 0 || originY !== void 0 || style2.transform)) {
      style2.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== void 0 ? originX : 0.5, originY !== void 0 ? originY : 0.5);
    }
    if (attrX !== void 0)
      attrs.x = attrX;
    if (attrY !== void 0)
      attrs.y = attrY;
    if (attrScale !== void 0)
      attrs.scale = attrScale;
    if (pathLength !== void 0) {
      buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.mjs
  var isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";

  // packages/components/node_modules/framer-motion/dist/es/render/svg/config-motion.mjs
  var svgMotionConfig = {
    useVisualState: makeUseVisualState({
      scrapeMotionValuesFromProps: scrapeMotionValuesFromProps2,
      createRenderState: createSvgRenderState,
      onMount: (props, instance, { renderState, latestValues }) => {
        frame.read(() => {
          try {
            renderState.dimensions = typeof instance.getBBox === "function" ? instance.getBBox() : instance.getBoundingClientRect();
          } catch (e3) {
            renderState.dimensions = {
              x: 0,
              y: 0,
              width: 0,
              height: 0
            };
          }
        });
        frame.render(() => {
          buildSVGAttrs(renderState, latestValues, isSVGTag(instance.tagName), props.transformTemplate);
          renderSVG(instance, renderState);
        });
      }
    })
  };

  // packages/components/node_modules/framer-motion/dist/es/render/html/config-motion.mjs
  var htmlMotionConfig = {
    useVisualState: makeUseVisualState({
      scrapeMotionValuesFromProps,
      createRenderState: createHtmlRenderState
    })
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/use-render.mjs
  var import_react72 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/render/html/use-props.mjs
  var import_react70 = __toESM(require_react(), 1);
  function copyRawValuesOnly(target, source, props) {
    for (const key in source) {
      if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {
        target[key] = source[key];
      }
    }
  }
  function useInitialMotionValues({ transformTemplate }, visualState) {
    return (0, import_react70.useMemo)(() => {
      const state = createHtmlRenderState();
      buildHTMLStyles(state, visualState, transformTemplate);
      return Object.assign({}, state.vars, state.style);
    }, [visualState]);
  }
  function useStyle(props, visualState) {
    const styleProp = props.style || {};
    const style2 = {};
    copyRawValuesOnly(style2, styleProp, props);
    Object.assign(style2, useInitialMotionValues(props, visualState));
    return style2;
  }
  function useHTMLProps(props, visualState) {
    const htmlProps = {};
    const style2 = useStyle(props, visualState);
    if (props.drag && props.dragListener !== false) {
      htmlProps.draggable = false;
      style2.userSelect = style2.WebkitUserSelect = style2.WebkitTouchCallout = "none";
      style2.touchAction = props.drag === true ? "none" : `pan-${props.drag === "x" ? "y" : "x"}`;
    }
    if (props.tabIndex === void 0 && (props.onTap || props.onTapStart || props.whileTap)) {
      htmlProps.tabIndex = 0;
    }
    htmlProps.style = style2;
    return htmlProps;
  }

  // packages/components/node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs
  var validMotionProps = /* @__PURE__ */ new Set([
    "animate",
    "exit",
    "variants",
    "initial",
    "style",
    "values",
    "variants",
    "transition",
    "transformTemplate",
    "custom",
    "inherit",
    "onBeforeLayoutMeasure",
    "onAnimationStart",
    "onAnimationComplete",
    "onUpdate",
    "onDragStart",
    "onDrag",
    "onDragEnd",
    "onMeasureDragConstraints",
    "onDirectionLock",
    "onDragTransitionEnd",
    "_dragX",
    "_dragY",
    "onHoverStart",
    "onHoverEnd",
    "onViewportEnter",
    "onViewportLeave",
    "globalTapTarget",
    "ignoreStrict",
    "viewport"
  ]);
  function isValidMotionProp(key) {
    return key.startsWith("while") || key.startsWith("drag") && key !== "draggable" || key.startsWith("layout") || key.startsWith("onTap") || key.startsWith("onPan") || key.startsWith("onLayout") || validMotionProps.has(key);
  }

  // packages/components/node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs
  var shouldForward = (key) => !isValidMotionProp(key);
  function loadExternalIsValidProp(isValidProp) {
    if (!isValidProp)
      return;
    shouldForward = (key) => key.startsWith("on") ? !isValidMotionProp(key) : isValidProp(key);
  }
  try {
    loadExternalIsValidProp((init_emotion_is_prop_valid_esm(), __toCommonJS(emotion_is_prop_valid_esm_exports)).default);
  } catch (_a) {
  }
  function filterProps(props, isDom, forwardMotionProps) {
    const filteredProps = {};
    for (const key in props) {
      if (key === "values" && typeof props.values === "object")
        continue;
      if (shouldForward(key) || forwardMotionProps === true && isValidMotionProp(key) || !isDom && !isValidMotionProp(key) || // If trying to use native HTML drag events, forward drag listeners
      props["draggable"] && key.startsWith("onDrag")) {
        filteredProps[key] = props[key];
      }
    }
    return filteredProps;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/svg/use-props.mjs
  var import_react71 = __toESM(require_react(), 1);
  function useSVGProps(props, visualState, _isStatic, Component7) {
    const visualProps = (0, import_react71.useMemo)(() => {
      const state = createSvgRenderState();
      buildSVGAttrs(state, visualState, isSVGTag(Component7), props.transformTemplate);
      return {
        ...state.attrs,
        style: { ...state.style }
      };
    }, [visualState]);
    if (props.style) {
      const rawStyles = {};
      copyRawValuesOnly(rawStyles, props.style, props);
      visualProps.style = { ...rawStyles, ...visualProps.style };
    }
    return visualProps;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/dom/use-render.mjs
  function createUseRender(forwardMotionProps = false) {
    const useRender = (Component7, props, ref, { latestValues }, isStatic) => {
      const useVisualProps = isSVGComponent(Component7) ? useSVGProps : useHTMLProps;
      const visualProps = useVisualProps(props, latestValues, isStatic, Component7);
      const filteredProps = filterProps(props, typeof Component7 === "string", forwardMotionProps);
      const elementProps = Component7 !== import_react72.Fragment ? { ...filteredProps, ...visualProps, ref } : {};
      const { children } = props;
      const renderedChildren = (0, import_react72.useMemo)(() => isMotionValue(children) ? children.get() : children, [children]);
      return (0, import_react72.createElement)(Component7, {
        ...elementProps,
        children: renderedChildren
      });
    };
    return useRender;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/components/create-factory.mjs
  function createMotionComponentFactory(preloadedFeatures, createVisualElement) {
    return function createMotionComponent2(Component7, { forwardMotionProps } = { forwardMotionProps: false }) {
      const baseConfig = isSVGComponent(Component7) ? svgMotionConfig : htmlMotionConfig;
      const config = {
        ...baseConfig,
        preloadedFeatures,
        useRender: createUseRender(forwardMotionProps),
        createVisualElement,
        Component: Component7
      };
      return createRendererMotionComponent(config);
    };
  }

  // packages/components/node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs
  var import_react73 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs
  var prefersReducedMotion = { current: null };
  var hasReducedMotionListener = { current: false };

  // packages/components/node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs
  function initPrefersReducedMotion() {
    hasReducedMotionListener.current = true;
    if (!isBrowser)
      return;
    if (window.matchMedia) {
      const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
      const setReducedMotionPreferences = () => prefersReducedMotion.current = motionMediaQuery.matches;
      motionMediaQuery.addListener(setReducedMotionPreferences);
      setReducedMotionPreferences();
    } else {
      prefersReducedMotion.current = false;
    }
  }

  // packages/components/node_modules/framer-motion/dist/es/render/utils/motion-values.mjs
  function updateMotionValuesFromProps(element, next2, prev2) {
    for (const key in next2) {
      const nextValue = next2[key];
      const prevValue = prev2[key];
      if (isMotionValue(nextValue)) {
        element.addValue(key, nextValue);
        if (true) {
          warnOnce(nextValue.version === "11.15.0", `Attempting to mix Motion versions ${nextValue.version} with 11.15.0 may not work as expected.`);
        }
      } else if (isMotionValue(prevValue)) {
        element.addValue(key, motionValue(nextValue, { owner: element }));
      } else if (prevValue !== nextValue) {
        if (element.hasValue(key)) {
          const existingValue = element.getValue(key);
          if (existingValue.liveStyle === true) {
            existingValue.jump(nextValue);
          } else if (!existingValue.hasAnimated) {
            existingValue.set(nextValue);
          }
        } else {
          const latestValue = element.getStaticValue(key);
          element.addValue(key, motionValue(latestValue !== void 0 ? latestValue : nextValue, { owner: element }));
        }
      }
    }
    for (const key in prev2) {
      if (next2[key] === void 0)
        element.removeValue(key);
    }
    return next2;
  }

  // packages/components/node_modules/framer-motion/dist/es/render/store.mjs
  var visualElementStore = /* @__PURE__ */ new WeakMap();

  // packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs
  var valueTypes = [...dimensionValueTypes, color, complex];
  var findValueType = (v3) => valueTypes.find(testValueType(v3));

  // packages/components/node_modules/framer-motion/dist/es/render/VisualElement.mjs
  var propEventHandlers = [
    "AnimationStart",
    "AnimationComplete",
    "Update",
    "BeforeLayoutMeasure",
    "LayoutMeasure",
    "LayoutAnimationStart",
    "LayoutAnimationComplete"
  ];
  var VisualElement = class {
    /**
     * This method takes React props and returns found MotionValues. For example, HTML
     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
     *
     * This isn't an abstract method as it needs calling in the constructor, but it is
     * intended to be one.
     */
    scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {
      return {};
    }
    constructor({ parent, props, presenceContext, reducedMotionConfig, blockInitialAnimation, visualState }, options2 = {}) {
      this.current = null;
      this.children = /* @__PURE__ */ new Set();
      this.isVariantNode = false;
      this.isControllingVariants = false;
      this.shouldReduceMotion = null;
      this.values = /* @__PURE__ */ new Map();
      this.KeyframeResolver = KeyframeResolver;
      this.features = {};
      this.valueSubscriptions = /* @__PURE__ */ new Map();
      this.prevMotionValues = {};
      this.events = {};
      this.propEventSubscriptions = {};
      this.notifyUpdate = () => this.notify("Update", this.latestValues);
      this.render = () => {
        if (!this.current)
          return;
        this.triggerBuild();
        this.renderInstance(this.current, this.renderState, this.props.style, this.projection);
      };
      this.renderScheduledAt = 0;
      this.scheduleRender = () => {
        const now2 = time.now();
        if (this.renderScheduledAt < now2) {
          this.renderScheduledAt = now2;
          frame.render(this.render, false, true);
        }
      };
      const { latestValues, renderState } = visualState;
      this.latestValues = latestValues;
      this.baseTarget = { ...latestValues };
      this.initialValues = props.initial ? { ...latestValues } : {};
      this.renderState = renderState;
      this.parent = parent;
      this.props = props;
      this.presenceContext = presenceContext;
      this.depth = parent ? parent.depth + 1 : 0;
      this.reducedMotionConfig = reducedMotionConfig;
      this.options = options2;
      this.blockInitialAnimation = Boolean(blockInitialAnimation);
      this.isControllingVariants = isControllingVariants(props);
      this.isVariantNode = isVariantNode(props);
      if (this.isVariantNode) {
        this.variantChildren = /* @__PURE__ */ new Set();
      }
      this.manuallyAnimateOnMount = Boolean(parent && parent.current);
      const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);
      for (const key in initialMotionValues) {
        const value = initialMotionValues[key];
        if (latestValues[key] !== void 0 && isMotionValue(value)) {
          value.set(latestValues[key], false);
        }
      }
    }
    mount(instance) {
      this.current = instance;
      visualElementStore.set(instance, this);
      if (this.projection && !this.projection.instance) {
        this.projection.mount(instance);
      }
      if (this.parent && this.isVariantNode && !this.isControllingVariants) {
        this.removeFromVariantTree = this.parent.addVariantChild(this);
      }
      this.values.forEach((value, key) => this.bindToMotionValue(key, value));
      if (!hasReducedMotionListener.current) {
        initPrefersReducedMotion();
      }
      this.shouldReduceMotion = this.reducedMotionConfig === "never" ? false : this.reducedMotionConfig === "always" ? true : prefersReducedMotion.current;
      if (true) {
        warnOnce(this.shouldReduceMotion !== true, "You have Reduced Motion enabled on your device. Animations may not appear as expected.");
      }
      if (this.parent)
        this.parent.children.add(this);
      this.update(this.props, this.presenceContext);
    }
    unmount() {
      visualElementStore.delete(this.current);
      this.projection && this.projection.unmount();
      cancelFrame(this.notifyUpdate);
      cancelFrame(this.render);
      this.valueSubscriptions.forEach((remove) => remove());
      this.valueSubscriptions.clear();
      this.removeFromVariantTree && this.removeFromVariantTree();
      this.parent && this.parent.children.delete(this);
      for (const key in this.events) {
        this.events[key].clear();
      }
      for (const key in this.features) {
        const feature = this.features[key];
        if (feature) {
          feature.unmount();
          feature.isMounted = false;
        }
      }
      this.current = null;
    }
    bindToMotionValue(key, value) {
      if (this.valueSubscriptions.has(key)) {
        this.valueSubscriptions.get(key)();
      }
      const valueIsTransform = transformProps.has(key);
      const removeOnChange = value.on("change", (latestValue) => {
        this.latestValues[key] = latestValue;
        this.props.onUpdate && frame.preRender(this.notifyUpdate);
        if (valueIsTransform && this.projection) {
          this.projection.isTransformDirty = true;
        }
      });
      const removeOnRenderRequest = value.on("renderRequest", this.scheduleRender);
      let removeSyncCheck;
      if (window.MotionCheckAppearSync) {
        removeSyncCheck = window.MotionCheckAppearSync(this, key, value);
      }
      this.valueSubscriptions.set(key, () => {
        removeOnChange();
        removeOnRenderRequest();
        if (removeSyncCheck)
          removeSyncCheck();
        if (value.owner)
          value.stop();
      });
    }
    sortNodePosition(other) {
      if (!this.current || !this.sortInstanceNodePosition || this.type !== other.type) {
        return 0;
      }
      return this.sortInstanceNodePosition(this.current, other.current);
    }
    updateFeatures() {
      let key = "animation";
      for (key in featureDefinitions) {
        const featureDefinition = featureDefinitions[key];
        if (!featureDefinition)
          continue;
        const { isEnabled, Feature: FeatureConstructor } = featureDefinition;
        if (!this.features[key] && FeatureConstructor && isEnabled(this.props)) {
          this.features[key] = new FeatureConstructor(this);
        }
        if (this.features[key]) {
          const feature = this.features[key];
          if (feature.isMounted) {
            feature.update();
          } else {
            feature.mount();
            feature.isMounted = true;
          }
        }
      }
    }
    triggerBuild() {
      this.build(this.renderState, this.latestValues, this.props);
    }
    /**
     * Measure the current viewport box with or without transforms.
     * Only measures axis-aligned boxes, rotate and skew must be manually
     * removed with a re-render to work.
     */
    measureViewportBox() {
      return this.current ? this.measureInstanceViewportBox(this.current, this.props) : createBox();
    }
    getStaticValue(key) {
      return this.latestValues[key];
    }
    setStaticValue(key, value) {
      this.latestValues[key] = value;
    }
    /**
     * Update the provided props. Ensure any newly-added motion values are
     * added to our map, old ones removed, and listeners updated.
     */
    update(props, presenceContext) {
      if (props.transformTemplate || this.props.transformTemplate) {
        this.scheduleRender();
      }
      this.prevProps = this.props;
      this.props = props;
      this.prevPresenceContext = this.presenceContext;
      this.presenceContext = presenceContext;
      for (let i3 = 0; i3 < propEventHandlers.length; i3++) {
        const key = propEventHandlers[i3];
        if (this.propEventSubscriptions[key]) {
          this.propEventSubscriptions[key]();
          delete this.propEventSubscriptions[key];
        }
        const listenerName = "on" + key;
        const listener = props[listenerName];
        if (listener) {
          this.propEventSubscriptions[key] = this.on(key, listener);
        }
      }
      this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps, this), this.prevMotionValues);
      if (this.handleChildMotionValue) {
        this.handleChildMotionValue();
      }
    }
    getProps() {
      return this.props;
    }
    /**
     * Returns the variant definition with a given name.
     */
    getVariant(name) {
      return this.props.variants ? this.props.variants[name] : void 0;
    }
    /**
     * Returns the defined default transition on this component.
     */
    getDefaultTransition() {
      return this.props.transition;
    }
    getTransformPagePoint() {
      return this.props.transformPagePoint;
    }
    getClosestVariantNode() {
      return this.isVariantNode ? this : this.parent ? this.parent.getClosestVariantNode() : void 0;
    }
    /**
     * Add a child visual element to our set of children.
     */
    addVariantChild(child) {
      const closestVariantNode = this.getClosestVariantNode();
      if (closestVariantNode) {
        closestVariantNode.variantChildren && closestVariantNode.variantChildren.add(child);
        return () => closestVariantNode.variantChildren.delete(child);
      }
    }
    /**
     * Add a motion value and bind it to this visual element.
     */
    addValue(key, value) {
      const existingValue = this.values.get(key);
      if (value !== existingValue) {
        if (existingValue)
          this.removeValue(key);
        this.bindToMotionValue(key, value);
        this.values.set(key, value);
        this.latestValues[key] = value.get();
      }
    }
    /**
     * Remove a motion value and unbind any active subscriptions.
     */
    removeValue(key) {
      this.values.delete(key);
      const unsubscribe = this.valueSubscriptions.get(key);
      if (unsubscribe) {
        unsubscribe();
        this.valueSubscriptions.delete(key);
      }
      delete this.latestValues[key];
      this.removeValueFromRenderState(key, this.renderState);
    }
    /**
     * Check whether we have a motion value for this key
     */
    hasValue(key) {
      return this.values.has(key);
    }
    getValue(key, defaultValue2) {
      if (this.props.values && this.props.values[key]) {
        return this.props.values[key];
      }
      let value = this.values.get(key);
      if (value === void 0 && defaultValue2 !== void 0) {
        value = motionValue(defaultValue2 === null ? void 0 : defaultValue2, { owner: this });
        this.addValue(key, value);
      }
      return value;
    }
    /**
     * If we're trying to animate to a previously unencountered value,
     * we need to check for it in our state and as a last resort read it
     * directly from the instance (which might have performance implications).
     */
    readValue(key, target) {
      var _a;
      let value = this.latestValues[key] !== void 0 || !this.current ? this.latestValues[key] : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);
      if (value !== void 0 && value !== null) {
        if (typeof value === "string" && (isNumericalString(value) || isZeroValueString(value))) {
          value = parseFloat(value);
        } else if (!findValueType(value) && complex.test(target)) {
          value = getAnimatableNone2(key, target);
        }
        this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);
      }
      return isMotionValue(value) ? value.get() : value;
    }
    /**
     * Set the base target to later animate back to. This is currently
     * only hydrated on creation and when we first read a value.
     */
    setBaseTarget(key, value) {
      this.baseTarget[key] = value;
    }
    /**
     * Find the base target for a value thats been removed from all animation
     * props.
     */
    getBaseTarget(key) {
      var _a;
      const { initial } = this.props;
      let valueFromInitial;
      if (typeof initial === "string" || typeof initial === "object") {
        const variant = resolveVariantFromProps(this.props, initial, (_a = this.presenceContext) === null || _a === void 0 ? void 0 : _a.custom);
        if (variant) {
          valueFromInitial = variant[key];
        }
      }
      if (initial && valueFromInitial !== void 0) {
        return valueFromInitial;
      }
      const target = this.getBaseTargetFromProps(this.props, key);
      if (target !== void 0 && !isMotionValue(target))
        return target;
      return this.initialValues[key] !== void 0 && valueFromInitial === void 0 ? void 0 : this.baseTarget[key];
    }
    on(eventName, callback) {
      if (!this.events[eventName]) {
        this.events[eventName] = new SubscriptionManager();
      }
      return this.events[eventName].add(callback);
    }
    notify(eventName, ...args) {
      if (this.events[eventName]) {
        this.events[eventName].notify(...args);
      }
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs
  var DOMVisualElement = class extends VisualElement {
    constructor() {
      super(...arguments);
      this.KeyframeResolver = DOMKeyframesResolver;
    }
    sortInstanceNodePosition(a3, b3) {
      return a3.compareDocumentPosition(b3) & 2 ? 1 : -1;
    }
    getBaseTargetFromProps(props, key) {
      return props.style ? props.style[key] : void 0;
    }
    removeValueFromRenderState(key, { vars, style: style2 }) {
      delete vars[key];
      delete style2[key];
    }
    handleChildMotionValue() {
      if (this.childSubscription) {
        this.childSubscription();
        delete this.childSubscription;
      }
      const { children } = this.props;
      if (isMotionValue(children)) {
        this.childSubscription = children.on("change", (latest) => {
          if (this.current) {
            this.current.textContent = `${latest}`;
          }
        });
      }
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs
  function getComputedStyle3(element) {
    return window.getComputedStyle(element);
  }
  var HTMLVisualElement = class extends DOMVisualElement {
    constructor() {
      super(...arguments);
      this.type = "html";
      this.renderInstance = renderHTML;
    }
    readValueFromInstance(instance, key) {
      if (transformProps.has(key)) {
        const defaultType = getDefaultValueType(key);
        return defaultType ? defaultType.default || 0 : 0;
      } else {
        const computedStyle = getComputedStyle3(instance);
        const value = (isCSSVariableName(key) ? computedStyle.getPropertyValue(key) : computedStyle[key]) || 0;
        return typeof value === "string" ? value.trim() : value;
      }
    }
    measureInstanceViewportBox(instance, { transformPagePoint }) {
      return measureViewportBox(instance, transformPagePoint);
    }
    build(renderState, latestValues, props) {
      buildHTMLStyles(renderState, latestValues, props.transformTemplate);
    }
    scrapeMotionValuesFromProps(props, prevProps, visualElement) {
      return scrapeMotionValuesFromProps(props, prevProps, visualElement);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs
  var SVGVisualElement = class extends DOMVisualElement {
    constructor() {
      super(...arguments);
      this.type = "svg";
      this.isSVGTag = false;
      this.measureInstanceViewportBox = createBox;
    }
    getBaseTargetFromProps(props, key) {
      return props[key];
    }
    readValueFromInstance(instance, key) {
      if (transformProps.has(key)) {
        const defaultType = getDefaultValueType(key);
        return defaultType ? defaultType.default || 0 : 0;
      }
      key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
      return instance.getAttribute(key);
    }
    scrapeMotionValuesFromProps(props, prevProps, visualElement) {
      return scrapeMotionValuesFromProps2(props, prevProps, visualElement);
    }
    build(renderState, latestValues, props) {
      buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate);
    }
    renderInstance(instance, renderState, styleProp, projection) {
      renderSVG(instance, renderState, styleProp, projection);
    }
    mount(instance) {
      this.isSVGTag = isSVGTag(instance.tagName);
      super.mount(instance);
    }
  };

  // packages/components/node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs
  var createDomVisualElement = (Component7, options2) => {
    return isSVGComponent(Component7) ? new SVGVisualElement(options2) : new HTMLVisualElement(options2, {
      allowProjection: Component7 !== import_react73.Fragment
    });
  };

  // packages/components/node_modules/framer-motion/dist/es/render/components/motion/create.mjs
  var createMotionComponent = /* @__PURE__ */ createMotionComponentFactory({
    ...animations,
    ...gestureAnimations,
    ...drag,
    ...layout
  }, createDomVisualElement);

  // packages/components/node_modules/framer-motion/dist/es/render/components/motion/proxy.mjs
  var motion = /* @__PURE__ */ createDOMMotionComponentProxy(createMotionComponent);

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs
  var import_jsx_runtime43 = __toESM(require_jsx_runtime(), 1);
  var import_react77 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs
  var import_jsx_runtime42 = __toESM(require_jsx_runtime(), 1);
  var React4 = __toESM(require_react(), 1);
  var import_react75 = __toESM(require_react(), 1);

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs
  var import_jsx_runtime41 = __toESM(require_jsx_runtime(), 1);
  var React3 = __toESM(require_react(), 1);
  var import_react74 = __toESM(require_react(), 1);
  var PopChildMeasure = class extends React3.Component {
    getSnapshotBeforeUpdate(prevProps) {
      const element = this.props.childRef.current;
      if (element && prevProps.isPresent && !this.props.isPresent) {
        const size4 = this.props.sizeRef.current;
        size4.height = element.offsetHeight || 0;
        size4.width = element.offsetWidth || 0;
        size4.top = element.offsetTop;
        size4.left = element.offsetLeft;
      }
      return null;
    }
    /**
     * Required with getSnapshotBeforeUpdate to stop React complaining.
     */
    componentDidUpdate() {
    }
    render() {
      return this.props.children;
    }
  };
  function PopChild({ children, isPresent }) {
    const id3 = (0, import_react74.useId)();
    const ref = (0, import_react74.useRef)(null);
    const size4 = (0, import_react74.useRef)({
      width: 0,
      height: 0,
      top: 0,
      left: 0
    });
    const { nonce } = (0, import_react74.useContext)(MotionConfigContext);
    (0, import_react74.useInsertionEffect)(() => {
      const { width, height, top, left } = size4.current;
      if (isPresent || !ref.current || !width || !height)
        return;
      ref.current.dataset.motionPopId = id3;
      const style2 = document.createElement("style");
      if (nonce)
        style2.nonce = nonce;
      document.head.appendChild(style2);
      if (style2.sheet) {
        style2.sheet.insertRule(`
          [data-motion-pop-id="${id3}"] {
            position: absolute !important;
            width: ${width}px !important;
            height: ${height}px !important;
            top: ${top}px !important;
            left: ${left}px !important;
          }
        `);
      }
      return () => {
        document.head.removeChild(style2);
      };
    }, [isPresent]);
    return (0, import_jsx_runtime41.jsx)(PopChildMeasure, { isPresent, childRef: ref, sizeRef: size4, children: React3.cloneElement(children, { ref }) });
  }

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs
  var PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode: mode2 }) => {
    const presenceChildren = useConstant(newChildrenMap);
    const id3 = (0, import_react75.useId)();
    const memoizedOnExitComplete = (0, import_react75.useCallback)((childId) => {
      presenceChildren.set(childId, true);
      for (const isComplete of presenceChildren.values()) {
        if (!isComplete)
          return;
      }
      onExitComplete && onExitComplete();
    }, [presenceChildren, onExitComplete]);
    const context = (0, import_react75.useMemo)(
      () => ({
        id: id3,
        initial,
        isPresent,
        custom,
        onExitComplete: memoizedOnExitComplete,
        register: (childId) => {
          presenceChildren.set(childId, false);
          return () => presenceChildren.delete(childId);
        }
      }),
      /**
       * If the presence of a child affects the layout of the components around it,
       * we want to make a new context value to ensure they get re-rendered
       * so they can detect that layout change.
       */
      presenceAffectsLayout ? [Math.random(), memoizedOnExitComplete] : [isPresent, memoizedOnExitComplete]
    );
    (0, import_react75.useMemo)(() => {
      presenceChildren.forEach((_2, key) => presenceChildren.set(key, false));
    }, [isPresent]);
    React4.useEffect(() => {
      !isPresent && !presenceChildren.size && onExitComplete && onExitComplete();
    }, [isPresent]);
    if (mode2 === "popLayout") {
      children = (0, import_jsx_runtime42.jsx)(PopChild, { isPresent, children });
    }
    return (0, import_jsx_runtime42.jsx)(PresenceContext.Provider, { value: context, children });
  };
  function newChildrenMap() {
    return /* @__PURE__ */ new Map();
  }

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/utils.mjs
  var import_react76 = __toESM(require_react(), 1);
  var getChildKey = (child) => child.key || "";
  function onlyElements(children) {
    const filtered = [];
    import_react76.Children.forEach(children, (child) => {
      if ((0, import_react76.isValidElement)(child))
        filtered.push(child);
    });
    return filtered;
  }

  // packages/components/node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs
  var AnimatePresence = ({ children, exitBeforeEnter, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode: mode2 = "sync" }) => {
    invariant2(!exitBeforeEnter, "Replace exitBeforeEnter with mode='wait'");
    const presentChildren = (0, import_react77.useMemo)(() => onlyElements(children), [children]);
    const presentKeys = presentChildren.map(getChildKey);
    const isInitialRender = (0, import_react77.useRef)(true);
    const pendingPresentChildren = (0, import_react77.useRef)(presentChildren);
    const exitComplete = useConstant(() => /* @__PURE__ */ new Map());
    const [diffedChildren, setDiffedChildren] = (0, import_react77.useState)(presentChildren);
    const [renderedChildren, setRenderedChildren] = (0, import_react77.useState)(presentChildren);
    useIsomorphicLayoutEffect(() => {
      isInitialRender.current = false;
      pendingPresentChildren.current = presentChildren;
      for (let i3 = 0; i3 < renderedChildren.length; i3++) {
        const key = getChildKey(renderedChildren[i3]);
        if (!presentKeys.includes(key)) {
          if (exitComplete.get(key) !== true) {
            exitComplete.set(key, false);
          }
        } else {
          exitComplete.delete(key);
        }
      }
    }, [renderedChildren, presentKeys.length, presentKeys.join("-")]);
    const exitingChildren = [];
    if (presentChildren !== diffedChildren) {
      let nextChildren = [...presentChildren];
      for (let i3 = 0; i3 < renderedChildren.length; i3++) {
        const child = renderedChildren[i3];
        const key = getChildKey(child);
        if (!presentKeys.includes(key)) {
          nextChildren.splice(i3, 0, child);
          exitingChildren.push(child);
        }
      }
      if (mode2 === "wait" && exitingChildren.length) {
        nextChildren = exitingChildren;
      }
      setRenderedChildren(onlyElements(nextChildren));
      setDiffedChildren(presentChildren);
      return;
    }
    if (mode2 === "wait" && renderedChildren.length > 1) {
      console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
    }
    const { forceRender } = (0, import_react77.useContext)(LayoutGroupContext);
    return (0, import_jsx_runtime43.jsx)(import_jsx_runtime43.Fragment, { children: renderedChildren.map((child) => {
      const key = getChildKey(child);
      const isPresent = presentChildren === renderedChildren || presentKeys.includes(key);
      const onExit = () => {
        if (exitComplete.has(key)) {
          exitComplete.set(key, true);
        } else {
          return;
        }
        let isEveryExitComplete = true;
        exitComplete.forEach((isExitComplete) => {
          if (!isExitComplete)
            isEveryExitComplete = false;
        });
        if (isEveryExitComplete) {
          forceRender === null || forceRender === void 0 ? void 0 : forceRender();
          setRenderedChildren(pendingPresentChildren.current);
          onExitComplete && onExitComplete();
        }
      };
      return (0, import_jsx_runtime43.jsx)(PresenceChild, { isPresent, initial: !isInitialRender.current || initial ? void 0 : false, custom: isPresent ? void 0 : custom, presenceAffectsLayout, mode: mode2, onExitComplete: isPresent ? void 0 : onExit, children: child }, key);
    }) });
  };

  // packages/components/build-module/utils/hooks/use-controlled-state.mjs
  var import_element9 = __toESM(require_element(), 1);

  // packages/components/build-module/utils/values.mjs
  function isValueDefined(value) {
    return value !== void 0 && value !== null;
  }
  function isValueEmpty(value) {
    const isEmptyString = value === "";
    return !isValueDefined(value) || isEmptyString;
  }
  function getDefinedValue(values = [], fallbackValue) {
    return values.find(isValueDefined) ?? fallbackValue;
  }
  var stringToNumber = (value) => {
    return parseFloat(value);
  };
  var ensureNumber = (value) => {
    return typeof value === "string" ? stringToNumber(value) : value;
  };

  // packages/components/build-module/utils/hooks/use-controlled-state.mjs
  var defaultOptions = {
    initial: void 0,
    /**
     * Defaults to empty string, as that is preferred for usage with
     * <input />, <textarea />, and <select /> form elements.
     */
    fallback: ""
  };
  function useControlledState(currentState, options2 = defaultOptions) {
    const {
      initial,
      fallback
    } = {
      ...defaultOptions,
      ...options2
    };
    const [internalState, setInternalState] = (0, import_element9.useState)(currentState);
    const hasCurrentState = isValueDefined(currentState);
    (0, import_element9.useEffect)(() => {
      if (hasCurrentState && internalState) {
        setInternalState(void 0);
      }
    }, [hasCurrentState, internalState]);
    const state = getDefinedValue([currentState, internalState, initial], fallback);
    const setState = (0, import_element9.useCallback)((nextState) => {
      if (!hasCurrentState) {
        setInternalState(nextState);
      }
    }, [hasCurrentState]);
    return [state, setState];
  }
  var use_controlled_state_default = useControlledState;

  // packages/components/build-module/utils/hooks/use-update-effect.mjs
  var import_element10 = __toESM(require_element(), 1);
  function useUpdateEffect2(effect, deps) {
    const mountedRef = (0, import_element10.useRef)(false);
    (0, import_element10.useEffect)(() => {
      if (mountedRef.current) {
        return effect();
      }
      mountedRef.current = true;
      return void 0;
    }, deps);
    (0, import_element10.useEffect)(() => () => {
      mountedRef.current = false;
    }, []);
  }
  var use_update_effect_default = useUpdateEffect2;

  // packages/components/build-module/utils/hooks/use-controlled-value.mjs
  var import_element11 = __toESM(require_element(), 1);
  function useControlledValue({
    defaultValue: defaultValue2,
    onChange,
    value: valueProp
  }) {
    const hasValue = typeof valueProp !== "undefined";
    const initialValue2 = hasValue ? valueProp : defaultValue2;
    const [state, setState] = (0, import_element11.useState)(initialValue2);
    const value = hasValue ? valueProp : state;
    const uncontrolledSetValue = (0, import_element11.useCallback)((nextValue, ...args) => {
      setState(nextValue);
      onChange?.(nextValue, ...args);
    }, [onChange]);
    let setValue;
    if (hasValue && typeof onChange === "function") {
      setValue = onChange;
    } else if (!hasValue && typeof onChange === "function") {
      setValue = uncontrolledSetValue;
    } else {
      setValue = setState;
    }
    return [value, setValue];
  }

  // node_modules/@emotion/react/dist/emotion-element-f0de968e.browser.esm.js
  var React6 = __toESM(require_react());
  var import_react78 = __toESM(require_react());

  // node_modules/@emotion/sheet/dist/emotion-sheet.esm.js
  var isDevelopment = false;
  function sheetForTag(tag) {
    if (tag.sheet) {
      return tag.sheet;
    }
    for (var i3 = 0; i3 < document.styleSheets.length; i3++) {
      if (document.styleSheets[i3].ownerNode === tag) {
        return document.styleSheets[i3];
      }
    }
    return void 0;
  }
  function createStyleElement(options2) {
    var tag = document.createElement("style");
    tag.setAttribute("data-emotion", options2.key);
    if (options2.nonce !== void 0) {
      tag.setAttribute("nonce", options2.nonce);
    }
    tag.appendChild(document.createTextNode(""));
    tag.setAttribute("data-s", "");
    return tag;
  }
  var StyleSheet = /* @__PURE__ */ (function() {
    function StyleSheet2(options2) {
      var _this = this;
      this._insertTag = function(tag) {
        var before;
        if (_this.tags.length === 0) {
          if (_this.insertionPoint) {
            before = _this.insertionPoint.nextSibling;
          } else if (_this.prepend) {
            before = _this.container.firstChild;
          } else {
            before = _this.before;
          }
        } else {
          before = _this.tags[_this.tags.length - 1].nextSibling;
        }
        _this.container.insertBefore(tag, before);
        _this.tags.push(tag);
      };
      this.isSpeedy = options2.speedy === void 0 ? !isDevelopment : options2.speedy;
      this.tags = [];
      this.ctr = 0;
      this.nonce = options2.nonce;
      this.key = options2.key;
      this.container = options2.container;
      this.prepend = options2.prepend;
      this.insertionPoint = options2.insertionPoint;
      this.before = null;
    }
    var _proto = StyleSheet2.prototype;
    _proto.hydrate = function hydrate2(nodes) {
      nodes.forEach(this._insertTag);
    };
    _proto.insert = function insert2(rule) {
      if (this.ctr % (this.isSpeedy ? 65e3 : 1) === 0) {
        this._insertTag(createStyleElement(this));
      }
      var tag = this.tags[this.tags.length - 1];
      if (this.isSpeedy) {
        var sheet2 = sheetForTag(tag);
        try {
          sheet2.insertRule(rule, sheet2.cssRules.length);
        } catch (e3) {
        }
      } else {
        tag.appendChild(document.createTextNode(rule));
      }
      this.ctr++;
    };
    _proto.flush = function flush2() {
      this.tags.forEach(function(tag) {
        var _tag$parentNode;
        return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);
      });
      this.tags = [];
      this.ctr = 0;
    };
    return StyleSheet2;
  })();

  // node_modules/stylis/src/Enum.js
  var MS = "-ms-";
  var MOZ = "-moz-";
  var WEBKIT = "-webkit-";
  var COMMENT = "comm";
  var RULESET = "rule";
  var DECLARATION = "decl";
  var IMPORT = "@import";
  var KEYFRAMES = "@keyframes";
  var LAYER = "@layer";

  // node_modules/stylis/src/Utility.js
  var abs = Math.abs;
  var from = String.fromCharCode;
  var assign = Object.assign;
  function hash(value, length2) {
    return charat(value, 0) ^ 45 ? (((length2 << 2 ^ charat(value, 0)) << 2 ^ charat(value, 1)) << 2 ^ charat(value, 2)) << 2 ^ charat(value, 3) : 0;
  }
  function trim(value) {
    return value.trim();
  }
  function match(value, pattern) {
    return (value = pattern.exec(value)) ? value[0] : value;
  }
  function replace(value, pattern, replacement) {
    return value.replace(pattern, replacement);
  }
  function indexof(value, search) {
    return value.indexOf(search);
  }
  function charat(value, index2) {
    return value.charCodeAt(index2) | 0;
  }
  function substr(value, begin, end) {
    return value.slice(begin, end);
  }
  function strlen(value) {
    return value.length;
  }
  function sizeof(value) {
    return value.length;
  }
  function append(value, array) {
    return array.push(value), value;
  }
  function combine(array, callback) {
    return array.map(callback).join("");
  }

  // node_modules/stylis/src/Tokenizer.js
  var line = 1;
  var column = 1;
  var length = 0;
  var position = 0;
  var character = 0;
  var characters = "";
  function node(value, root, parent, type, props, children, length2) {
    return { value, root, parent, type, props, children, line, column, length: length2, return: "" };
  }
  function copy(root, props) {
    return assign(node("", null, null, "", null, null, 0), root, { length: -root.length }, props);
  }
  function char() {
    return character;
  }
  function prev() {
    character = position > 0 ? charat(characters, --position) : 0;
    if (column--, character === 10)
      column = 1, line--;
    return character;
  }
  function next() {
    character = position < length ? charat(characters, position++) : 0;
    if (column++, character === 10)
      column = 1, line++;
    return character;
  }
  function peek() {
    return charat(characters, position);
  }
  function caret() {
    return position;
  }
  function slice(begin, end) {
    return substr(characters, begin, end);
  }
  function token(type) {
    switch (type) {
      // \0 \t \n \r \s whitespace token
      case 0:
      case 9:
      case 10:
      case 13:
      case 32:
        return 5;
      // ! + , / > @ ~ isolate token
      case 33:
      case 43:
      case 44:
      case 47:
      case 62:
      case 64:
      case 126:
      // ; { } breakpoint token
      case 59:
      case 123:
      case 125:
        return 4;
      // : accompanied token
      case 58:
        return 3;
      // " ' ( [ opening delimit token
      case 34:
      case 39:
      case 40:
      case 91:
        return 2;
      // ) ] closing delimit token
      case 41:
      case 93:
        return 1;
    }
    return 0;
  }
  function alloc(value) {
    return line = column = 1, length = strlen(characters = value), position = 0, [];
  }
  function dealloc(value) {
    return characters = "", value;
  }
  function delimit(type) {
    return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)));
  }
  function whitespace(type) {
    while (character = peek())
      if (character < 33)
        next();
      else
        break;
    return token(type) > 2 || token(character) > 3 ? "" : " ";
  }
  function escaping(index2, count) {
    while (--count && next())
      if (character < 48 || character > 102 || character > 57 && character < 65 || character > 70 && character < 97)
        break;
    return slice(index2, caret() + (count < 6 && peek() == 32 && next() == 32));
  }
  function delimiter(type) {
    while (next())
      switch (character) {
        // ] ) " '
        case type:
          return position;
        // " '
        case 34:
        case 39:
          if (type !== 34 && type !== 39)
            delimiter(character);
          break;
        // (
        case 40:
          if (type === 41)
            delimiter(type);
          break;
        // \
        case 92:
          next();
          break;
      }
    return position;
  }
  function commenter(type, index2) {
    while (next())
      if (type + character === 47 + 10)
        break;
      else if (type + character === 42 + 42 && peek() === 47)
        break;
    return "/*" + slice(index2, position - 1) + "*" + from(type === 47 ? type : next());
  }
  function identifier(index2) {
    while (!token(peek()))
      next();
    return slice(index2, position);
  }

  // node_modules/stylis/src/Parser.js
  function compile(value) {
    return dealloc(parse("", null, null, null, [""], value = alloc(value), 0, [0], value));
  }
  function parse(value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
    var index2 = 0;
    var offset4 = 0;
    var length2 = pseudo;
    var atrule = 0;
    var property = 0;
    var previous = 0;
    var variable = 1;
    var scanning = 1;
    var ampersand = 1;
    var character2 = 0;
    var type = "";
    var props = rules;
    var children = rulesets;
    var reference = rule;
    var characters2 = type;
    while (scanning)
      switch (previous = character2, character2 = next()) {
        // (
        case 40:
          if (previous != 108 && charat(characters2, length2 - 1) == 58) {
            if (indexof(characters2 += replace(delimit(character2), "&", "&\f"), "&\f") != -1)
              ampersand = -1;
            break;
          }
        // " ' [
        case 34:
        case 39:
        case 91:
          characters2 += delimit(character2);
          break;
        // \t \n \r \s
        case 9:
        case 10:
        case 13:
        case 32:
          characters2 += whitespace(previous);
          break;
        // \
        case 92:
          characters2 += escaping(caret() - 1, 7);
          continue;
        // /
        case 47:
          switch (peek()) {
            case 42:
            case 47:
              append(comment(commenter(next(), caret()), root, parent), declarations);
              break;
            default:
              characters2 += "/";
          }
          break;
        // {
        case 123 * variable:
          points[index2++] = strlen(characters2) * ampersand;
        // } ; \0
        case 125 * variable:
        case 59:
        case 0:
          switch (character2) {
            // \0 }
            case 0:
            case 125:
              scanning = 0;
            // ;
            case 59 + offset4:
              if (ampersand == -1) characters2 = replace(characters2, /\f/g, "");
              if (property > 0 && strlen(characters2) - length2)
                append(property > 32 ? declaration(characters2 + ";", rule, parent, length2 - 1) : declaration(replace(characters2, " ", "") + ";", rule, parent, length2 - 2), declarations);
              break;
            // @ ;
            case 59:
              characters2 += ";";
            // { rule/at-rule
            default:
              append(reference = ruleset(characters2, root, parent, index2, offset4, rules, points, type, props = [], children = [], length2), rulesets);
              if (character2 === 123)
                if (offset4 === 0)
                  parse(characters2, root, reference, reference, props, rulesets, length2, points, children);
                else
                  switch (atrule === 99 && charat(characters2, 3) === 110 ? 100 : atrule) {
                    // d l m s
                    case 100:
                    case 108:
                    case 109:
                    case 115:
                      parse(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length2), children), rules, children, length2, points, rule ? props : children);
                      break;
                    default:
                      parse(characters2, reference, reference, reference, [""], children, 0, points, children);
                  }
          }
          index2 = offset4 = property = 0, variable = ampersand = 1, type = characters2 = "", length2 = pseudo;
          break;
        // :
        case 58:
          length2 = 1 + strlen(characters2), property = previous;
        default:
          if (variable < 1) {
            if (character2 == 123)
              --variable;
            else if (character2 == 125 && variable++ == 0 && prev() == 125)
              continue;
          }
          switch (characters2 += from(character2), character2 * variable) {
            // &
            case 38:
              ampersand = offset4 > 0 ? 1 : (characters2 += "\f", -1);
              break;
            // ,
            case 44:
              points[index2++] = (strlen(characters2) - 1) * ampersand, ampersand = 1;
              break;
            // @
            case 64:
              if (peek() === 45)
                characters2 += delimit(next());
              atrule = peek(), offset4 = length2 = strlen(type = characters2 += identifier(caret())), character2++;
              break;
            // -
            case 45:
              if (previous === 45 && strlen(characters2) == 2)
                variable = 0;
          }
      }
    return rulesets;
  }
  function ruleset(value, root, parent, index2, offset4, rules, points, type, props, children, length2) {
    var post = offset4 - 1;
    var rule = offset4 === 0 ? rules : [""];
    var size4 = sizeof(rule);
    for (var i3 = 0, j2 = 0, k3 = 0; i3 < index2; ++i3)
      for (var x2 = 0, y3 = substr(value, post + 1, post = abs(j2 = points[i3])), z = value; x2 < size4; ++x2)
        if (z = trim(j2 > 0 ? rule[x2] + " " + y3 : replace(y3, /&\f/g, rule[x2])))
          props[k3++] = z;
    return node(value, root, parent, offset4 === 0 ? RULESET : type, props, children, length2);
  }
  function comment(value, root, parent) {
    return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0);
  }
  function declaration(value, root, parent, length2) {
    return node(value, root, parent, DECLARATION, substr(value, 0, length2), substr(value, length2 + 1, -1), length2);
  }

  // node_modules/stylis/src/Serializer.js
  function serialize(children, callback) {
    var output = "";
    var length2 = sizeof(children);
    for (var i3 = 0; i3 < length2; i3++)
      output += callback(children[i3], i3, children, callback) || "";
    return output;
  }
  function stringify(element, index2, children, callback) {
    switch (element.type) {
      case LAYER:
        if (element.children.length) break;
      case IMPORT:
      case DECLARATION:
        return element.return = element.return || element.value;
      case COMMENT:
        return "";
      case KEYFRAMES:
        return element.return = element.value + "{" + serialize(element.children, callback) + "}";
      case RULESET:
        element.value = element.props.join(",");
    }
    return strlen(children = serialize(element.children, callback)) ? element.return = element.value + "{" + children + "}" : "";
  }

  // node_modules/stylis/src/Middleware.js
  function middleware(collection) {
    var length2 = sizeof(collection);
    return function(element, index2, children, callback) {
      var output = "";
      for (var i3 = 0; i3 < length2; i3++)
        output += collection[i3](element, index2, children, callback) || "";
      return output;
    };
  }
  function rulesheet(callback) {
    return function(element) {
      if (!element.root) {
        if (element = element.return)
          callback(element);
      }
    };
  }

  // node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js
  init_emotion_memoize_esm();
  var identifierWithPointTracking = function identifierWithPointTracking2(begin, points, index2) {
    var previous = 0;
    var character2 = 0;
    while (true) {
      previous = character2;
      character2 = peek();
      if (previous === 38 && character2 === 12) {
        points[index2] = 1;
      }
      if (token(character2)) {
        break;
      }
      next();
    }
    return slice(begin, position);
  };
  var toRules = function toRules2(parsed, points) {
    var index2 = -1;
    var character2 = 44;
    do {
      switch (token(character2)) {
        case 0:
          if (character2 === 38 && peek() === 12) {
            points[index2] = 1;
          }
          parsed[index2] += identifierWithPointTracking(position - 1, points, index2);
          break;
        case 2:
          parsed[index2] += delimit(character2);
          break;
        case 4:
          if (character2 === 44) {
            parsed[++index2] = peek() === 58 ? "&\f" : "";
            points[index2] = parsed[index2].length;
            break;
          }
        // fallthrough
        default:
          parsed[index2] += from(character2);
      }
    } while (character2 = next());
    return parsed;
  };
  var getRules = function getRules2(value, points) {
    return dealloc(toRules(alloc(value), points));
  };
  var fixedElements = /* @__PURE__ */ new WeakMap();
  var compat = function compat2(element) {
    if (element.type !== "rule" || !element.parent || // positive .length indicates that this rule contains pseudo
    // negative .length indicates that this rule has been already prefixed
    element.length < 1) {
      return;
    }
    var value = element.value;
    var parent = element.parent;
    var isImplicitRule = element.column === parent.column && element.line === parent.line;
    while (parent.type !== "rule") {
      parent = parent.parent;
      if (!parent) return;
    }
    if (element.props.length === 1 && value.charCodeAt(0) !== 58 && !fixedElements.get(parent)) {
      return;
    }
    if (isImplicitRule) {
      return;
    }
    fixedElements.set(element, true);
    var points = [];
    var rules = getRules(value, points);
    var parentRules = parent.props;
    for (var i3 = 0, k3 = 0; i3 < rules.length; i3++) {
      for (var j2 = 0; j2 < parentRules.length; j2++, k3++) {
        element.props[k3] = points[i3] ? rules[i3].replace(/&\f/g, parentRules[j2]) : parentRules[j2] + " " + rules[i3];
      }
    }
  };
  var removeLabel = function removeLabel2(element) {
    if (element.type === "decl") {
      var value = element.value;
      if (
        // charcode for l
        value.charCodeAt(0) === 108 && // charcode for b
        value.charCodeAt(2) === 98
      ) {
        element["return"] = "";
        element.value = "";
      }
    }
  };
  function prefix(value, length2) {
    switch (hash(value, length2)) {
      // color-adjust
      case 5103:
        return WEBKIT + "print-" + value + value;
      // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
      case 5737:
      case 4201:
      case 3177:
      case 3433:
      case 1641:
      case 4457:
      case 2921:
      // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
      case 5572:
      case 6356:
      case 5844:
      case 3191:
      case 6645:
      case 3005:
      // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
      case 6391:
      case 5879:
      case 5623:
      case 6135:
      case 4599:
      case 4855:
      // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
      case 4215:
      case 6389:
      case 5109:
      case 5365:
      case 5621:
      case 3829:
        return WEBKIT + value + value;
      // appearance, user-select, transform, hyphens, text-size-adjust
      case 5349:
      case 4246:
      case 4810:
      case 6968:
      case 2756:
        return WEBKIT + value + MOZ + value + MS + value + value;
      // flex, flex-direction
      case 6828:
      case 4268:
        return WEBKIT + value + MS + value + value;
      // order
      case 6165:
        return WEBKIT + value + MS + "flex-" + value + value;
      // align-items
      case 5187:
        return WEBKIT + value + replace(value, /(\w+).+(:[^]+)/, WEBKIT + "box-$1$2" + MS + "flex-$1$2") + value;
      // align-self
      case 5443:
        return WEBKIT + value + MS + "flex-item-" + replace(value, /flex-|-self/, "") + value;
      // align-content
      case 4675:
        return WEBKIT + value + MS + "flex-line-pack" + replace(value, /align-content|flex-|-self/, "") + value;
      // flex-shrink
      case 5548:
        return WEBKIT + value + MS + replace(value, "shrink", "negative") + value;
      // flex-basis
      case 5292:
        return WEBKIT + value + MS + replace(value, "basis", "preferred-size") + value;
      // flex-grow
      case 6060:
        return WEBKIT + "box-" + replace(value, "-grow", "") + WEBKIT + value + MS + replace(value, "grow", "positive") + value;
      // transition
      case 4554:
        return WEBKIT + replace(value, /([^-])(transform)/g, "$1" + WEBKIT + "$2") + value;
      // cursor
      case 6187:
        return replace(replace(replace(value, /(zoom-|grab)/, WEBKIT + "$1"), /(image-set)/, WEBKIT + "$1"), value, "") + value;
      // background, background-image
      case 5495:
      case 3959:
        return replace(value, /(image-set\([^]*)/, WEBKIT + "$1$`$1");
      // justify-content
      case 4968:
        return replace(replace(value, /(.+:)(flex-)?(.*)/, WEBKIT + "box-pack:$3" + MS + "flex-pack:$3"), /s.+-b[^;]+/, "justify") + WEBKIT + value + value;
      // (margin|padding)-inline-(start|end)
      case 4095:
      case 3583:
      case 4068:
      case 2532:
        return replace(value, /(.+)-inline(.+)/, WEBKIT + "$1$2") + value;
      // (min|max)?(width|height|inline-size|block-size)
      case 8116:
      case 7059:
      case 5753:
      case 5535:
      case 5445:
      case 5701:
      case 4933:
      case 4677:
      case 5533:
      case 5789:
      case 5021:
      case 4765:
        if (strlen(value) - 1 - length2 > 6) switch (charat(value, length2 + 1)) {
          // (m)ax-content, (m)in-content
          case 109:
            if (charat(value, length2 + 4) !== 45) break;
          // (f)ill-available, (f)it-content
          case 102:
            return replace(value, /(.+:)(.+)-([^]+)/, "$1" + WEBKIT + "$2-$3$1" + MOZ + (charat(value, length2 + 3) == 108 ? "$3" : "$2-$3")) + value;
          // (s)tretch
          case 115:
            return ~indexof(value, "stretch") ? prefix(replace(value, "stretch", "fill-available"), length2) + value : value;
        }
        break;
      // position: sticky
      case 4949:
        if (charat(value, length2 + 1) !== 115) break;
      // display: (flex|inline-flex)
      case 6444:
        switch (charat(value, strlen(value) - 3 - (~indexof(value, "!important") && 10))) {
          // stic(k)y
          case 107:
            return replace(value, ":", ":" + WEBKIT) + value;
          // (inline-)?fl(e)x
          case 101:
            return replace(value, /(.+:)([^;!]+)(;|!.+)?/, "$1" + WEBKIT + (charat(value, 14) === 45 ? "inline-" : "") + "box$3$1" + WEBKIT + "$2$3$1" + MS + "$2box$3") + value;
        }
        break;
      // writing-mode
      case 5936:
        switch (charat(value, length2 + 11)) {
          // vertical-l(r)
          case 114:
            return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, "tb") + value;
          // vertical-r(l)
          case 108:
            return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, "tb-rl") + value;
          // horizontal(-)tb
          case 45:
            return WEBKIT + value + MS + replace(value, /[svh]\w+-[tblr]{2}/, "lr") + value;
        }
        return WEBKIT + value + MS + value + value;
    }
    return value;
  }
  var prefixer = function prefixer2(element, index2, children, callback) {
    if (element.length > -1) {
      if (!element["return"]) switch (element.type) {
        case DECLARATION:
          element["return"] = prefix(element.value, element.length);
          break;
        case KEYFRAMES:
          return serialize([copy(element, {
            value: replace(element.value, "@", "@" + WEBKIT)
          })], callback);
        case RULESET:
          if (element.length) return combine(element.props, function(value) {
            switch (match(value, /(::plac\w+|:read-\w+)/)) {
              // :read-(only|write)
              case ":read-only":
              case ":read-write":
                return serialize([copy(element, {
                  props: [replace(value, /:(read-\w+)/, ":" + MOZ + "$1")]
                })], callback);
              // :placeholder
              case "::placeholder":
                return serialize([copy(element, {
                  props: [replace(value, /:(plac\w+)/, ":" + WEBKIT + "input-$1")]
                }), copy(element, {
                  props: [replace(value, /:(plac\w+)/, ":" + MOZ + "$1")]
                }), copy(element, {
                  props: [replace(value, /:(plac\w+)/, MS + "input-$1")]
                })], callback);
            }
            return "";
          });
      }
    }
  };
  var defaultStylisPlugins = [prefixer];
  var createCache = function createCache2(options2) {
    var key = options2.key;
    if (key === "css") {
      var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])");
      Array.prototype.forEach.call(ssrStyles, function(node2) {
        var dataEmotionAttribute = node2.getAttribute("data-emotion");
        if (dataEmotionAttribute.indexOf(" ") === -1) {
          return;
        }
        document.head.appendChild(node2);
        node2.setAttribute("data-s", "");
      });
    }
    var stylisPlugins = options2.stylisPlugins || defaultStylisPlugins;
    var inserted = {};
    var container;
    var nodesToHydrate = [];
    {
      container = options2.container || document.head;
      Array.prototype.forEach.call(
        // this means we will ignore elements which don't have a space in them which
        // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
        document.querySelectorAll('style[data-emotion^="' + key + ' "]'),
        function(node2) {
          var attrib = node2.getAttribute("data-emotion").split(" ");
          for (var i3 = 1; i3 < attrib.length; i3++) {
            inserted[attrib[i3]] = true;
          }
          nodesToHydrate.push(node2);
        }
      );
    }
    var _insert;
    var omnipresentPlugins = [compat, removeLabel];
    {
      var currentSheet;
      var finalizingPlugins = [stringify, rulesheet(function(rule) {
        currentSheet.insert(rule);
      })];
      var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
      var stylis = function stylis2(styles3) {
        return serialize(compile(styles3), serializer);
      };
      _insert = function insert2(selector2, serialized, sheet2, shouldCache) {
        currentSheet = sheet2;
        stylis(selector2 ? selector2 + "{" + serialized.styles + "}" : serialized.styles);
        if (shouldCache) {
          cache2.inserted[serialized.name] = true;
        }
      };
    }
    var cache2 = {
      key,
      sheet: new StyleSheet({
        key,
        container,
        nonce: options2.nonce,
        speedy: options2.speedy,
        prepend: options2.prepend,
        insertionPoint: options2.insertionPoint
      }),
      nonce: options2.nonce,
      inserted,
      registered: {},
      insert: _insert
    };
    cache2.sheet.hydrate(nodesToHydrate);
    return cache2;
  };

  // node_modules/@babel/runtime/helpers/esm/extends.js
  function _extends() {
    return _extends = Object.assign ? Object.assign.bind() : function(n3) {
      for (var e3 = 1; e3 < arguments.length; e3++) {
        var t4 = arguments[e3];
        for (var r4 in t4) ({}).hasOwnProperty.call(t4, r4) && (n3[r4] = t4[r4]);
      }
      return n3;
    }, _extends.apply(null, arguments);
  }

  // node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js
  var isBrowser2 = true;
  function getRegisteredStyles(registered, registeredStyles, classNames) {
    var rawClassName = "";
    classNames.split(" ").forEach(function(className2) {
      if (registered[className2] !== void 0) {
        registeredStyles.push(registered[className2] + ";");
      } else if (className2) {
        rawClassName += className2 + " ";
      }
    });
    return rawClassName;
  }
  var registerStyles = function registerStyles2(cache2, serialized, isStringTag) {
    var className2 = cache2.key + "-" + serialized.name;
    if (
      // we only need to add the styles to the registered cache if the
      // class name could be used further down
      // the tree but if it's a string tag, we know it won't
      // so we don't have to add it to registered cache.
      // this improves memory usage since we can avoid storing the whole style string
      (isStringTag === false || // we need to always store it if we're in compat mode and
      // in node since emotion-server relies on whether a style is in
      // the registered cache to know whether a style is global or not
      // also, note that this check will be dead code eliminated in the browser
      isBrowser2 === false) && cache2.registered[className2] === void 0
    ) {
      cache2.registered[className2] = serialized.styles;
    }
  };
  var insertStyles = function insertStyles2(cache2, serialized, isStringTag) {
    registerStyles(cache2, serialized, isStringTag);
    var className2 = cache2.key + "-" + serialized.name;
    if (cache2.inserted[serialized.name] === void 0) {
      var current = serialized;
      do {
        cache2.insert(serialized === current ? "." + className2 : "", current, cache2.sheet, true);
        current = current.next;
      } while (current !== void 0);
    }
  };

  // node_modules/@emotion/hash/dist/emotion-hash.esm.js
  function murmur2(str) {
    var h3 = 0;
    var k3, i3 = 0, len = str.length;
    for (; len >= 4; ++i3, len -= 4) {
      k3 = str.charCodeAt(i3) & 255 | (str.charCodeAt(++i3) & 255) << 8 | (str.charCodeAt(++i3) & 255) << 16 | (str.charCodeAt(++i3) & 255) << 24;
      k3 = /* Math.imul(k, m): */
      (k3 & 65535) * 1540483477 + ((k3 >>> 16) * 59797 << 16);
      k3 ^= /* k >>> r: */
      k3 >>> 24;
      h3 = /* Math.imul(k, m): */
      (k3 & 65535) * 1540483477 + ((k3 >>> 16) * 59797 << 16) ^ /* Math.imul(h, m): */
      (h3 & 65535) * 1540483477 + ((h3 >>> 16) * 59797 << 16);
    }
    switch (len) {
      case 3:
        h3 ^= (str.charCodeAt(i3 + 2) & 255) << 16;
      case 2:
        h3 ^= (str.charCodeAt(i3 + 1) & 255) << 8;
      case 1:
        h3 ^= str.charCodeAt(i3) & 255;
        h3 = /* Math.imul(h, m): */
        (h3 & 65535) * 1540483477 + ((h3 >>> 16) * 59797 << 16);
    }
    h3 ^= h3 >>> 13;
    h3 = /* Math.imul(h, m): */
    (h3 & 65535) * 1540483477 + ((h3 >>> 16) * 59797 << 16);
    return ((h3 ^ h3 >>> 15) >>> 0).toString(36);
  }

  // node_modules/@emotion/unitless/dist/emotion-unitless.esm.js
  var unitlessKeys = {
    animationIterationCount: 1,
    aspectRatio: 1,
    borderImageOutset: 1,
    borderImageSlice: 1,
    borderImageWidth: 1,
    boxFlex: 1,
    boxFlexGroup: 1,
    boxOrdinalGroup: 1,
    columnCount: 1,
    columns: 1,
    flex: 1,
    flexGrow: 1,
    flexPositive: 1,
    flexShrink: 1,
    flexNegative: 1,
    flexOrder: 1,
    gridRow: 1,
    gridRowEnd: 1,
    gridRowSpan: 1,
    gridRowStart: 1,
    gridColumn: 1,
    gridColumnEnd: 1,
    gridColumnSpan: 1,
    gridColumnStart: 1,
    msGridRow: 1,
    msGridRowSpan: 1,
    msGridColumn: 1,
    msGridColumnSpan: 1,
    fontWeight: 1,
    lineHeight: 1,
    opacity: 1,
    order: 1,
    orphans: 1,
    scale: 1,
    tabSize: 1,
    widows: 1,
    zIndex: 1,
    zoom: 1,
    WebkitLineClamp: 1,
    // SVG-related properties
    fillOpacity: 1,
    floodOpacity: 1,
    stopOpacity: 1,
    strokeDasharray: 1,
    strokeDashoffset: 1,
    strokeMiterlimit: 1,
    strokeOpacity: 1,
    strokeWidth: 1
  };

  // node_modules/@emotion/serialize/dist/emotion-serialize.esm.js
  init_emotion_memoize_esm();
  var isDevelopment2 = false;
  var hyphenateRegex = /[A-Z]|^ms/g;
  var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
  var isCustomProperty = function isCustomProperty2(property) {
    return property.charCodeAt(1) === 45;
  };
  var isProcessableValue = function isProcessableValue2(value) {
    return value != null && typeof value !== "boolean";
  };
  var processStyleName = /* @__PURE__ */ memoize(function(styleName) {
    return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, "-$&").toLowerCase();
  });
  var processStyleValue = function processStyleValue2(key, value) {
    switch (key) {
      case "animation":
      case "animationName": {
        if (typeof value === "string") {
          return value.replace(animationRegex, function(match4, p1, p22) {
            cursor = {
              name: p1,
              styles: p22,
              next: cursor
            };
            return p1;
          });
        }
      }
    }
    if (unitlessKeys[key] !== 1 && !isCustomProperty(key) && typeof value === "number" && value !== 0) {
      return value + "px";
    }
    return value;
  };
  var noComponentSelectorMessage = "Component selectors can only be used in conjunction with @emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware compiler transform.";
  function handleInterpolation(mergedProps, registered, interpolation) {
    if (interpolation == null) {
      return "";
    }
    var componentSelector = interpolation;
    if (componentSelector.__emotion_styles !== void 0) {
      return componentSelector;
    }
    switch (typeof interpolation) {
      case "boolean": {
        return "";
      }
      case "object": {
        var keyframes4 = interpolation;
        if (keyframes4.anim === 1) {
          cursor = {
            name: keyframes4.name,
            styles: keyframes4.styles,
            next: cursor
          };
          return keyframes4.name;
        }
        var serializedStyles = interpolation;
        if (serializedStyles.styles !== void 0) {
          var next2 = serializedStyles.next;
          if (next2 !== void 0) {
            while (next2 !== void 0) {
              cursor = {
                name: next2.name,
                styles: next2.styles,
                next: cursor
              };
              next2 = next2.next;
            }
          }
          var styles3 = serializedStyles.styles + ";";
          return styles3;
        }
        return createStringFromObject(mergedProps, registered, interpolation);
      }
      case "function": {
        if (mergedProps !== void 0) {
          var previousCursor = cursor;
          var result = interpolation(mergedProps);
          cursor = previousCursor;
          return handleInterpolation(mergedProps, registered, result);
        }
        break;
      }
    }
    var asString = interpolation;
    if (registered == null) {
      return asString;
    }
    var cached = registered[asString];
    return cached !== void 0 ? cached : asString;
  }
  function createStringFromObject(mergedProps, registered, obj) {
    var string = "";
    if (Array.isArray(obj)) {
      for (var i3 = 0; i3 < obj.length; i3++) {
        string += handleInterpolation(mergedProps, registered, obj[i3]) + ";";
      }
    } else {
      for (var key in obj) {
        var value = obj[key];
        if (typeof value !== "object") {
          var asString = value;
          if (registered != null && registered[asString] !== void 0) {
            string += key + "{" + registered[asString] + "}";
          } else if (isProcessableValue(asString)) {
            string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
          }
        } else {
          if (key === "NO_COMPONENT_SELECTOR" && isDevelopment2) {
            throw new Error(noComponentSelectorMessage);
          }
          if (Array.isArray(value) && typeof value[0] === "string" && (registered == null || registered[value[0]] === void 0)) {
            for (var _i = 0; _i < value.length; _i++) {
              if (isProcessableValue(value[_i])) {
                string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
              }
            }
          } else {
            var interpolated = handleInterpolation(mergedProps, registered, value);
            switch (key) {
              case "animation":
              case "animationName": {
                string += processStyleName(key) + ":" + interpolated + ";";
                break;
              }
              default: {
                string += key + "{" + interpolated + "}";
              }
            }
          }
        }
      }
    }
    return string;
  }
  var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g;
  var cursor;
  function serializeStyles(args, registered, mergedProps) {
    if (args.length === 1 && typeof args[0] === "object" && args[0] !== null && args[0].styles !== void 0) {
      return args[0];
    }
    var stringMode = true;
    var styles3 = "";
    cursor = void 0;
    var strings = args[0];
    if (strings == null || strings.raw === void 0) {
      stringMode = false;
      styles3 += handleInterpolation(mergedProps, registered, strings);
    } else {
      var asTemplateStringsArr = strings;
      styles3 += asTemplateStringsArr[0];
    }
    for (var i3 = 1; i3 < args.length; i3++) {
      styles3 += handleInterpolation(mergedProps, registered, args[i3]);
      if (stringMode) {
        var templateStringsArr = strings;
        styles3 += templateStringsArr[i3];
      }
    }
    labelPattern.lastIndex = 0;
    var identifierName = "";
    var match4;
    while ((match4 = labelPattern.exec(styles3)) !== null) {
      identifierName += "-" + match4[1];
    }
    var name = murmur2(styles3) + identifierName;
    return {
      name,
      styles: styles3,
      next: cursor
    };
  }

  // node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js
  var React5 = __toESM(require_react());
  var syncFallback = function syncFallback2(create2) {
    return create2();
  };
  var useInsertionEffect4 = React5["useInsertionEffect"] ? React5["useInsertionEffect"] : false;
  var useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect4 || syncFallback;

  // node_modules/@emotion/react/dist/emotion-element-f0de968e.browser.esm.js
  var isDevelopment3 = false;
  var EmotionCacheContext = /* @__PURE__ */ React6.createContext(
    // we're doing this to avoid preconstruct's dead code elimination in this one case
    // because this module is primarily intended for the browser and node
    // but it's also required in react native and similar environments sometimes
    // and we could have a special build just for that
    // but this is much easier and the native packages
    // might use a different theme context in the future anyway
    typeof HTMLElement !== "undefined" ? /* @__PURE__ */ createCache({
      key: "css"
    }) : null
  );
  var CacheProvider = EmotionCacheContext.Provider;
  var __unsafe_useEmotionCache = function useEmotionCache() {
    return (0, import_react78.useContext)(EmotionCacheContext);
  };
  var withEmotionCache = function withEmotionCache2(func) {
    return /* @__PURE__ */ (0, import_react78.forwardRef)(function(props, ref) {
      var cache2 = (0, import_react78.useContext)(EmotionCacheContext);
      return func(props, cache2, ref);
    });
  };
  var ThemeContext = /* @__PURE__ */ React6.createContext({});
  var hasOwn = {}.hasOwnProperty;
  var typePropName = "__EMOTION_TYPE_PLEASE_DO_NOT_USE__";
  var createEmotionProps = function createEmotionProps2(type, props) {
    var newProps = {};
    for (var _key in props) {
      if (hasOwn.call(props, _key)) {
        newProps[_key] = props[_key];
      }
    }
    newProps[typePropName] = type;
    return newProps;
  };
  var Insertion = function Insertion2(_ref9) {
    var cache2 = _ref9.cache, serialized = _ref9.serialized, isStringTag = _ref9.isStringTag;
    registerStyles(cache2, serialized, isStringTag);
    useInsertionEffectAlwaysWithSyncFallback(function() {
      return insertStyles(cache2, serialized, isStringTag);
    });
    return null;
  };
  var Emotion = /* @__PURE__ */ withEmotionCache(function(props, cache2, ref) {
    var cssProp = props.css;
    if (typeof cssProp === "string" && cache2.registered[cssProp] !== void 0) {
      cssProp = cache2.registered[cssProp];
    }
    var WrappedComponent = props[typePropName];
    var registeredStyles = [cssProp];
    var className2 = "";
    if (typeof props.className === "string") {
      className2 = getRegisteredStyles(cache2.registered, registeredStyles, props.className);
    } else if (props.className != null) {
      className2 = props.className + " ";
    }
    var serialized = serializeStyles(registeredStyles, void 0, React6.useContext(ThemeContext));
    className2 += cache2.key + "-" + serialized.name;
    var newProps = {};
    for (var _key2 in props) {
      if (hasOwn.call(props, _key2) && _key2 !== "css" && _key2 !== typePropName && !isDevelopment3) {
        newProps[_key2] = props[_key2];
      }
    }
    newProps.className = className2;
    if (ref) {
      newProps.ref = ref;
    }
    return /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(Insertion, {
      cache: cache2,
      serialized,
      isStringTag: typeof WrappedComponent === "string"
    }), /* @__PURE__ */ React6.createElement(WrappedComponent, newProps));
  });
  var Emotion$1 = Emotion;

  // node_modules/@emotion/react/dist/emotion-react.browser.esm.js
  var React7 = __toESM(require_react());
  var import_hoist_non_react_statics = __toESM(require_hoist_non_react_statics_cjs());
  var jsx36 = function jsx37(type, props) {
    var args = arguments;
    if (props == null || !hasOwn.call(props, "css")) {
      return React7.createElement.apply(void 0, args);
    }
    var argsLength = args.length;
    var createElementArgArray = new Array(argsLength);
    createElementArgArray[0] = Emotion$1;
    createElementArgArray[1] = createEmotionProps(type, props);
    for (var i3 = 2; i3 < argsLength; i3++) {
      createElementArgArray[i3] = args[i3];
    }
    return React7.createElement.apply(null, createElementArgArray);
  };
  (function(_jsx262) {
    var JSX;
    /* @__PURE__ */ (function(_JSX) {
    })(JSX || (JSX = _jsx262.JSX || (_jsx262.JSX = {})));
  })(jsx36 || (jsx36 = {}));
  function css() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
    return serializeStyles(args);
  }
  function keyframes2() {
    var insertable = css.apply(void 0, arguments);
    var name = "animation-" + insertable.name;
    return {
      name,
      styles: "@keyframes " + name + "{" + insertable.styles + "}",
      anim: 1,
      toString: function toString() {
        return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
      }
    };
  }

  // packages/components/node_modules/@emotion/css/create-instance/dist/emotion-css-create-instance.esm.js
  function insertWithoutScoping(cache2, serialized) {
    if (cache2.inserted[serialized.name] === void 0) {
      return cache2.insert("", serialized, cache2.sheet, true);
    }
  }
  function merge(registered, css3, className2) {
    var registeredStyles = [];
    var rawClassName = getRegisteredStyles(registered, registeredStyles, className2);
    if (registeredStyles.length < 2) {
      return className2;
    }
    return rawClassName + css3(registeredStyles);
  }
  var createEmotion = function createEmotion2(options2) {
    var cache2 = createCache(options2);
    cache2.sheet.speedy = function(value) {
      this.isSpeedy = value;
    };
    cache2.compat = true;
    var css3 = function css4() {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }
      var serialized = serializeStyles(args, cache2.registered, void 0);
      insertStyles(cache2, serialized, false);
      return cache2.key + "-" + serialized.name;
    };
    var keyframes4 = function keyframes5() {
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }
      var serialized = serializeStyles(args, cache2.registered);
      var animation = "animation-" + serialized.name;
      insertWithoutScoping(cache2, {
        name: serialized.name,
        styles: "@keyframes " + animation + "{" + serialized.styles + "}"
      });
      return animation;
    };
    var injectGlobal2 = function injectGlobal3() {
      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
        args[_key3] = arguments[_key3];
      }
      var serialized = serializeStyles(args, cache2.registered);
      insertWithoutScoping(cache2, serialized);
    };
    var cx2 = function cx3() {
      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
        args[_key4] = arguments[_key4];
      }
      return merge(cache2.registered, css3, classnames(args));
    };
    return {
      css: css3,
      cx: cx2,
      injectGlobal: injectGlobal2,
      keyframes: keyframes4,
      hydrate: function hydrate2(ids) {
        ids.forEach(function(key) {
          cache2.inserted[key] = true;
        });
      },
      flush: function flush2() {
        cache2.registered = {};
        cache2.inserted = {};
        cache2.sheet.flush();
      },
      sheet: cache2.sheet,
      cache: cache2,
      getRegisteredStyles: getRegisteredStyles.bind(null, cache2.registered),
      merge: merge.bind(null, cache2.registered, css3)
    };
  };
  var classnames = function classnames2(args) {
    var cls = "";
    for (var i3 = 0; i3 < args.length; i3++) {
      var arg = args[i3];
      if (arg == null) continue;
      var toAdd = void 0;
      switch (typeof arg) {
        case "boolean":
          break;
        case "object": {
          if (Array.isArray(arg)) {
            toAdd = classnames2(arg);
          } else {
            toAdd = "";
            for (var k3 in arg) {
              if (arg[k3] && k3) {
                toAdd && (toAdd += " ");
                toAdd += k3;
              }
            }
          }
          break;
        }
        default: {
          toAdd = arg;
        }
      }
      if (toAdd) {
        cls && (cls += " ");
        cls += toAdd;
      }
    }
    return cls;
  };

  // packages/components/node_modules/@emotion/css/dist/emotion-css.esm.js
  var _createEmotion = createEmotion({
    key: "css"
  });
  var flush = _createEmotion.flush;
  var hydrate = _createEmotion.hydrate;
  var cx = _createEmotion.cx;
  var merge2 = _createEmotion.merge;
  var getRegisteredStyles2 = _createEmotion.getRegisteredStyles;
  var injectGlobal = _createEmotion.injectGlobal;
  var keyframes3 = _createEmotion.keyframes;
  var css2 = _createEmotion.css;
  var sheet = _createEmotion.sheet;
  var cache = _createEmotion.cache;

  // packages/components/build-module/utils/hooks/use-cx.mjs
  var import_element12 = __toESM(require_element(), 1);
  var isSerializedStyles = (o4) => typeof o4 !== "undefined" && o4 !== null && ["name", "styles"].every((p3) => typeof o4[p3] !== "undefined");
  var useCx = () => {
    const cache2 = __unsafe_useEmotionCache();
    const cx2 = (0, import_element12.useCallback)((...classNames) => {
      if (cache2 === null) {
        throw new Error("The `useCx` hook should be only used within a valid Emotion Cache Context");
      }
      return cx(...classNames.map((arg) => {
        if (isSerializedStyles(arg)) {
          insertStyles(cache2, arg, false);
          return `${cache2.key}-${arg.name}`;
        }
        return arg;
      }));
    }, [cache2]);
    return cx2;
  };

  // packages/components/build-module/utils/box-sizing.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var boxSizingReset = false ? {
    name: "kv6lnz",
    styles: "box-sizing:border-box;*,*::before,*::after{box-sizing:inherit;}"
  } : {
    name: "1pa5nhz-boxSizingReset",
    styles: "box-sizing:border-box;*,*::before,*::after{box-sizing:inherit;};label:boxSizingReset;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1zaXppbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS2lDIiwiZmlsZSI6ImJveC1zaXppbmcudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5cbmV4cG9ydCBjb25zdCBib3hTaXppbmdSZXNldCA9IGNzc2Bcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblxuXHQqLFxuXHQqOjpiZWZvcmUsXG5cdCo6OmFmdGVyIHtcblx0XHRib3gtc2l6aW5nOiBpbmhlcml0O1xuXHR9XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__
  };

  // node_modules/memize/dist/index.js
  function memize(fn, options2) {
    var size4 = 0;
    var head;
    var tail;
    options2 = options2 || {};
    function memoized() {
      var node2 = head, len = arguments.length, args, i3;
      searchCache: while (node2) {
        if (node2.args.length !== arguments.length) {
          node2 = node2.next;
          continue;
        }
        for (i3 = 0; i3 < len; i3++) {
          if (node2.args[i3] !== arguments[i3]) {
            node2 = node2.next;
            continue searchCache;
          }
        }
        if (node2 !== head) {
          if (node2 === tail) {
            tail = node2.prev;
          }
          node2.prev.next = node2.next;
          if (node2.next) {
            node2.next.prev = node2.prev;
          }
          node2.next = head;
          node2.prev = null;
          head.prev = node2;
          head = node2;
        }
        return node2.val;
      }
      args = new Array(len);
      for (i3 = 0; i3 < len; i3++) {
        args[i3] = arguments[i3];
      }
      node2 = {
        args,
        // Generate the result from original function
        val: fn.apply(null, args)
      };
      if (head) {
        head.prev = node2;
        node2.next = head;
      } else {
        tail = node2;
      }
      if (size4 === /** @type {MemizeOptions} */
      options2.maxSize) {
        tail = /** @type {MemizeCacheNode} */
        tail.prev;
        tail.next = null;
      } else {
        size4++;
      }
      head = node2;
      return node2.val;
    }
    memoized.clear = function() {
      head = null;
      tail = null;
      size4 = 0;
    };
    return memoized;
  }

  // node_modules/colord/index.mjs
  var r2 = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) };
  var t = function(r4) {
    return "string" == typeof r4 ? r4.length > 0 : "number" == typeof r4;
  };
  var n = function(r4, t4, n3) {
    return void 0 === t4 && (t4 = 0), void 0 === n3 && (n3 = Math.pow(10, t4)), Math.round(n3 * r4) / n3 + 0;
  };
  var e = function(r4, t4, n3) {
    return void 0 === t4 && (t4 = 0), void 0 === n3 && (n3 = 1), r4 > n3 ? n3 : r4 > t4 ? r4 : t4;
  };
  var u = function(r4) {
    return (r4 = isFinite(r4) ? r4 % 360 : 0) > 0 ? r4 : r4 + 360;
  };
  var a = function(r4) {
    return { r: e(r4.r, 0, 255), g: e(r4.g, 0, 255), b: e(r4.b, 0, 255), a: e(r4.a) };
  };
  var o = function(r4) {
    return { r: n(r4.r), g: n(r4.g), b: n(r4.b), a: n(r4.a, 3) };
  };
  var i = /^#([0-9a-f]{3,8})$/i;
  var s = function(r4) {
    var t4 = r4.toString(16);
    return t4.length < 2 ? "0" + t4 : t4;
  };
  var h = function(r4) {
    var t4 = r4.r, n3 = r4.g, e3 = r4.b, u3 = r4.a, a3 = Math.max(t4, n3, e3), o4 = a3 - Math.min(t4, n3, e3), i3 = o4 ? a3 === t4 ? (n3 - e3) / o4 : a3 === n3 ? 2 + (e3 - t4) / o4 : 4 + (t4 - n3) / o4 : 0;
    return { h: 60 * (i3 < 0 ? i3 + 6 : i3), s: a3 ? o4 / a3 * 100 : 0, v: a3 / 255 * 100, a: u3 };
  };
  var b = function(r4) {
    var t4 = r4.h, n3 = r4.s, e3 = r4.v, u3 = r4.a;
    t4 = t4 / 360 * 6, n3 /= 100, e3 /= 100;
    var a3 = Math.floor(t4), o4 = e3 * (1 - n3), i3 = e3 * (1 - (t4 - a3) * n3), s3 = e3 * (1 - (1 - t4 + a3) * n3), h3 = a3 % 6;
    return { r: 255 * [e3, i3, o4, o4, s3, e3][h3], g: 255 * [s3, e3, e3, i3, o4, o4][h3], b: 255 * [o4, o4, s3, e3, e3, i3][h3], a: u3 };
  };
  var g = function(r4) {
    return { h: u(r4.h), s: e(r4.s, 0, 100), l: e(r4.l, 0, 100), a: e(r4.a) };
  };
  var d = function(r4) {
    return { h: n(r4.h), s: n(r4.s), l: n(r4.l), a: n(r4.a, 3) };
  };
  var f = function(r4) {
    return b((n3 = (t4 = r4).s, { h: t4.h, s: (n3 *= ((e3 = t4.l) < 50 ? e3 : 100 - e3) / 100) > 0 ? 2 * n3 / (e3 + n3) * 100 : 0, v: e3 + n3, a: t4.a }));
    var t4, n3, e3;
  };
  var c = function(r4) {
    return { h: (t4 = h(r4)).h, s: (u3 = (200 - (n3 = t4.s)) * (e3 = t4.v) / 100) > 0 && u3 < 200 ? n3 * e3 / 100 / (u3 <= 100 ? u3 : 200 - u3) * 100 : 0, l: u3 / 2, a: t4.a };
    var t4, n3, e3, u3;
  };
  var l = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
  var p = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
  var v = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
  var m = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i;
  var y = { string: [[function(r4) {
    var t4 = i.exec(r4);
    return t4 ? (r4 = t4[1]).length <= 4 ? { r: parseInt(r4[0] + r4[0], 16), g: parseInt(r4[1] + r4[1], 16), b: parseInt(r4[2] + r4[2], 16), a: 4 === r4.length ? n(parseInt(r4[3] + r4[3], 16) / 255, 2) : 1 } : 6 === r4.length || 8 === r4.length ? { r: parseInt(r4.substr(0, 2), 16), g: parseInt(r4.substr(2, 2), 16), b: parseInt(r4.substr(4, 2), 16), a: 8 === r4.length ? n(parseInt(r4.substr(6, 2), 16) / 255, 2) : 1 } : null : null;
  }, "hex"], [function(r4) {
    var t4 = v.exec(r4) || m.exec(r4);
    return t4 ? t4[2] !== t4[4] || t4[4] !== t4[6] ? null : a({ r: Number(t4[1]) / (t4[2] ? 100 / 255 : 1), g: Number(t4[3]) / (t4[4] ? 100 / 255 : 1), b: Number(t4[5]) / (t4[6] ? 100 / 255 : 1), a: void 0 === t4[7] ? 1 : Number(t4[7]) / (t4[8] ? 100 : 1) }) : null;
  }, "rgb"], [function(t4) {
    var n3 = l.exec(t4) || p.exec(t4);
    if (!n3) return null;
    var e3, u3, a3 = g({ h: (e3 = n3[1], u3 = n3[2], void 0 === u3 && (u3 = "deg"), Number(e3) * (r2[u3] || 1)), s: Number(n3[3]), l: Number(n3[4]), a: void 0 === n3[5] ? 1 : Number(n3[5]) / (n3[6] ? 100 : 1) });
    return f(a3);
  }, "hsl"]], object: [[function(r4) {
    var n3 = r4.r, e3 = r4.g, u3 = r4.b, o4 = r4.a, i3 = void 0 === o4 ? 1 : o4;
    return t(n3) && t(e3) && t(u3) ? a({ r: Number(n3), g: Number(e3), b: Number(u3), a: Number(i3) }) : null;
  }, "rgb"], [function(r4) {
    var n3 = r4.h, e3 = r4.s, u3 = r4.l, a3 = r4.a, o4 = void 0 === a3 ? 1 : a3;
    if (!t(n3) || !t(e3) || !t(u3)) return null;
    var i3 = g({ h: Number(n3), s: Number(e3), l: Number(u3), a: Number(o4) });
    return f(i3);
  }, "hsl"], [function(r4) {
    var n3 = r4.h, a3 = r4.s, o4 = r4.v, i3 = r4.a, s3 = void 0 === i3 ? 1 : i3;
    if (!t(n3) || !t(a3) || !t(o4)) return null;
    var h3 = (function(r5) {
      return { h: u(r5.h), s: e(r5.s, 0, 100), v: e(r5.v, 0, 100), a: e(r5.a) };
    })({ h: Number(n3), s: Number(a3), v: Number(o4), a: Number(s3) });
    return b(h3);
  }, "hsv"]] };
  var N = function(r4, t4) {
    for (var n3 = 0; n3 < t4.length; n3++) {
      var e3 = t4[n3][0](r4);
      if (e3) return [e3, t4[n3][1]];
    }
    return [null, void 0];
  };
  var x = function(r4) {
    return "string" == typeof r4 ? N(r4.trim(), y.string) : "object" == typeof r4 && null !== r4 ? N(r4, y.object) : [null, void 0];
  };
  var I = function(r4) {
    return x(r4)[1];
  };
  var M = function(r4, t4) {
    var n3 = c(r4);
    return { h: n3.h, s: e(n3.s + 100 * t4, 0, 100), l: n3.l, a: n3.a };
  };
  var H = function(r4) {
    return (299 * r4.r + 587 * r4.g + 114 * r4.b) / 1e3 / 255;
  };
  var $ = function(r4, t4) {
    var n3 = c(r4);
    return { h: n3.h, s: n3.s, l: e(n3.l + 100 * t4, 0, 100), a: n3.a };
  };
  var j = (function() {
    function r4(r5) {
      this.parsed = x(r5)[0], this.rgba = this.parsed || { r: 0, g: 0, b: 0, a: 1 };
    }
    return r4.prototype.isValid = function() {
      return null !== this.parsed;
    }, r4.prototype.brightness = function() {
      return n(H(this.rgba), 2);
    }, r4.prototype.isDark = function() {
      return H(this.rgba) < 0.5;
    }, r4.prototype.isLight = function() {
      return H(this.rgba) >= 0.5;
    }, r4.prototype.toHex = function() {
      return r5 = o(this.rgba), t4 = r5.r, e3 = r5.g, u3 = r5.b, i3 = (a3 = r5.a) < 1 ? s(n(255 * a3)) : "", "#" + s(t4) + s(e3) + s(u3) + i3;
      var r5, t4, e3, u3, a3, i3;
    }, r4.prototype.toRgb = function() {
      return o(this.rgba);
    }, r4.prototype.toRgbString = function() {
      return r5 = o(this.rgba), t4 = r5.r, n3 = r5.g, e3 = r5.b, (u3 = r5.a) < 1 ? "rgba(" + t4 + ", " + n3 + ", " + e3 + ", " + u3 + ")" : "rgb(" + t4 + ", " + n3 + ", " + e3 + ")";
      var r5, t4, n3, e3, u3;
    }, r4.prototype.toHsl = function() {
      return d(c(this.rgba));
    }, r4.prototype.toHslString = function() {
      return r5 = d(c(this.rgba)), t4 = r5.h, n3 = r5.s, e3 = r5.l, (u3 = r5.a) < 1 ? "hsla(" + t4 + ", " + n3 + "%, " + e3 + "%, " + u3 + ")" : "hsl(" + t4 + ", " + n3 + "%, " + e3 + "%)";
      var r5, t4, n3, e3, u3;
    }, r4.prototype.toHsv = function() {
      return r5 = h(this.rgba), { h: n(r5.h), s: n(r5.s), v: n(r5.v), a: n(r5.a, 3) };
      var r5;
    }, r4.prototype.invert = function() {
      return w({ r: 255 - (r5 = this.rgba).r, g: 255 - r5.g, b: 255 - r5.b, a: r5.a });
      var r5;
    }, r4.prototype.saturate = function(r5) {
      return void 0 === r5 && (r5 = 0.1), w(M(this.rgba, r5));
    }, r4.prototype.desaturate = function(r5) {
      return void 0 === r5 && (r5 = 0.1), w(M(this.rgba, -r5));
    }, r4.prototype.grayscale = function() {
      return w(M(this.rgba, -1));
    }, r4.prototype.lighten = function(r5) {
      return void 0 === r5 && (r5 = 0.1), w($(this.rgba, r5));
    }, r4.prototype.darken = function(r5) {
      return void 0 === r5 && (r5 = 0.1), w($(this.rgba, -r5));
    }, r4.prototype.rotate = function(r5) {
      return void 0 === r5 && (r5 = 15), this.hue(this.hue() + r5);
    }, r4.prototype.alpha = function(r5) {
      return "number" == typeof r5 ? w({ r: (t4 = this.rgba).r, g: t4.g, b: t4.b, a: r5 }) : n(this.rgba.a, 3);
      var t4;
    }, r4.prototype.hue = function(r5) {
      var t4 = c(this.rgba);
      return "number" == typeof r5 ? w({ h: r5, s: t4.s, l: t4.l, a: t4.a }) : n(t4.h);
    }, r4.prototype.isEqual = function(r5) {
      return this.toHex() === w(r5).toHex();
    }, r4;
  })();
  var w = function(r4) {
    return r4 instanceof j ? r4 : new j(r4);
  };
  var S = [];
  var k = function(r4) {
    r4.forEach(function(r5) {
      S.indexOf(r5) < 0 && (r5(j, y), S.push(r5));
    });
  };

  // node_modules/colord/plugins/names.mjs
  function names_default(e3, f3) {
    var a3 = { white: "#ffffff", bisque: "#ffe4c4", blue: "#0000ff", cadetblue: "#5f9ea0", chartreuse: "#7fff00", chocolate: "#d2691e", coral: "#ff7f50", antiquewhite: "#faebd7", aqua: "#00ffff", azure: "#f0ffff", whitesmoke: "#f5f5f5", papayawhip: "#ffefd5", plum: "#dda0dd", blanchedalmond: "#ffebcd", black: "#000000", gold: "#ffd700", goldenrod: "#daa520", gainsboro: "#dcdcdc", cornsilk: "#fff8dc", cornflowerblue: "#6495ed", burlywood: "#deb887", aquamarine: "#7fffd4", beige: "#f5f5dc", crimson: "#dc143c", cyan: "#00ffff", darkblue: "#00008b", darkcyan: "#008b8b", darkgoldenrod: "#b8860b", darkkhaki: "#bdb76b", darkgray: "#a9a9a9", darkgreen: "#006400", darkgrey: "#a9a9a9", peachpuff: "#ffdab9", darkmagenta: "#8b008b", darkred: "#8b0000", darkorchid: "#9932cc", darkorange: "#ff8c00", darkslateblue: "#483d8b", gray: "#808080", darkslategray: "#2f4f4f", darkslategrey: "#2f4f4f", deeppink: "#ff1493", deepskyblue: "#00bfff", wheat: "#f5deb3", firebrick: "#b22222", floralwhite: "#fffaf0", ghostwhite: "#f8f8ff", darkviolet: "#9400d3", magenta: "#ff00ff", green: "#008000", dodgerblue: "#1e90ff", grey: "#808080", honeydew: "#f0fff0", hotpink: "#ff69b4", blueviolet: "#8a2be2", forestgreen: "#228b22", lawngreen: "#7cfc00", indianred: "#cd5c5c", indigo: "#4b0082", fuchsia: "#ff00ff", brown: "#a52a2a", maroon: "#800000", mediumblue: "#0000cd", lightcoral: "#f08080", darkturquoise: "#00ced1", lightcyan: "#e0ffff", ivory: "#fffff0", lightyellow: "#ffffe0", lightsalmon: "#ffa07a", lightseagreen: "#20b2aa", linen: "#faf0e6", mediumaquamarine: "#66cdaa", lemonchiffon: "#fffacd", lime: "#00ff00", khaki: "#f0e68c", mediumseagreen: "#3cb371", limegreen: "#32cd32", mediumspringgreen: "#00fa9a", lightskyblue: "#87cefa", lightblue: "#add8e6", midnightblue: "#191970", lightpink: "#ffb6c1", mistyrose: "#ffe4e1", moccasin: "#ffe4b5", mintcream: "#f5fffa", lightslategray: "#778899", lightslategrey: "#778899", navajowhite: "#ffdead", navy: "#000080", mediumvioletred: "#c71585", powderblue: "#b0e0e6", palegoldenrod: "#eee8aa", oldlace: "#fdf5e6", paleturquoise: "#afeeee", mediumturquoise: "#48d1cc", mediumorchid: "#ba55d3", rebeccapurple: "#663399", lightsteelblue: "#b0c4de", mediumslateblue: "#7b68ee", thistle: "#d8bfd8", tan: "#d2b48c", orchid: "#da70d6", mediumpurple: "#9370db", purple: "#800080", pink: "#ffc0cb", skyblue: "#87ceeb", springgreen: "#00ff7f", palegreen: "#98fb98", red: "#ff0000", yellow: "#ffff00", slateblue: "#6a5acd", lavenderblush: "#fff0f5", peru: "#cd853f", palevioletred: "#db7093", violet: "#ee82ee", teal: "#008080", slategray: "#708090", slategrey: "#708090", aliceblue: "#f0f8ff", darkseagreen: "#8fbc8f", darkolivegreen: "#556b2f", greenyellow: "#adff2f", seagreen: "#2e8b57", seashell: "#fff5ee", tomato: "#ff6347", silver: "#c0c0c0", sienna: "#a0522d", lavender: "#e6e6fa", lightgreen: "#90ee90", orange: "#ffa500", orangered: "#ff4500", steelblue: "#4682b4", royalblue: "#4169e1", turquoise: "#40e0d0", yellowgreen: "#9acd32", salmon: "#fa8072", saddlebrown: "#8b4513", sandybrown: "#f4a460", rosybrown: "#bc8f8f", darksalmon: "#e9967a", lightgoldenrodyellow: "#fafad2", snow: "#fffafa", lightgrey: "#d3d3d3", lightgray: "#d3d3d3", dimgray: "#696969", dimgrey: "#696969", olivedrab: "#6b8e23", olive: "#808000" }, r4 = {};
    for (var d3 in a3) r4[a3[d3]] = d3;
    var l3 = {};
    e3.prototype.toName = function(f4) {
      if (!(this.rgba.a || this.rgba.r || this.rgba.g || this.rgba.b)) return "transparent";
      var d4, i3, n3 = r4[this.toHex()];
      if (n3) return n3;
      if (null == f4 ? void 0 : f4.closest) {
        var o4 = this.toRgb(), t4 = 1 / 0, b3 = "black";
        if (!l3.length) for (var c3 in a3) l3[c3] = new e3(a3[c3]).toRgb();
        for (var g3 in a3) {
          var u3 = (d4 = o4, i3 = l3[g3], Math.pow(d4.r - i3.r, 2) + Math.pow(d4.g - i3.g, 2) + Math.pow(d4.b - i3.b, 2));
          u3 < t4 && (t4 = u3, b3 = g3);
        }
        return b3;
      }
    };
    f3.string.push([function(f4) {
      var r5 = f4.toLowerCase(), d4 = "transparent" === r5 ? "#0000" : a3[r5];
      return d4 ? new e3(d4).toRgb() : null;
    }, "name"]);
  }

  // packages/components/build-module/utils/colors.mjs
  var colorComputationNode;
  k([names_default]);
  function getColorComputationNode() {
    if (typeof document === "undefined") {
      return;
    }
    if (!colorComputationNode) {
      const el = document.createElement("div");
      el.setAttribute("data-g2-color-computation-node", "");
      document.body.appendChild(el);
      colorComputationNode = el;
    }
    return colorComputationNode;
  }
  function isColor(value) {
    if (typeof value !== "string") {
      return false;
    }
    const test2 = w(value);
    return test2.isValid();
  }
  function _getComputedBackgroundColor(backgroundColor) {
    if (typeof backgroundColor !== "string") {
      return "";
    }
    if (isColor(backgroundColor)) {
      return backgroundColor;
    }
    if (!backgroundColor.includes("var(")) {
      return "";
    }
    if (typeof document === "undefined") {
      return "";
    }
    const el = getColorComputationNode();
    if (!el) {
      return "";
    }
    el.style.background = backgroundColor;
    const computedColor = window?.getComputedStyle(el).background;
    el.style.background = "";
    return computedColor || "";
  }
  var getComputedBackgroundColor = memize(_getComputedBackgroundColor);
  function getOptimalTextColor(backgroundColor) {
    const background = getComputedBackgroundColor(backgroundColor);
    return w(background).isLight() ? "#000000" : "#ffffff";
  }
  function getOptimalTextShade(backgroundColor) {
    const result = getOptimalTextColor(backgroundColor);
    return result === "#000000" ? "dark" : "light";
  }

  // packages/components/build-module/utils/rtl.mjs
  var import_i18n2 = __toESM(require_i18n(), 1);
  var LOWER_LEFT_REGEXP = new RegExp(/-left/g);
  var LOWER_RIGHT_REGEXP = new RegExp(/-right/g);
  var UPPER_LEFT_REGEXP = new RegExp(/Left/g);
  var UPPER_RIGHT_REGEXP = new RegExp(/Right/g);
  function getConvertedKey(key) {
    if (key === "left") {
      return "right";
    }
    if (key === "right") {
      return "left";
    }
    if (LOWER_LEFT_REGEXP.test(key)) {
      return key.replace(LOWER_LEFT_REGEXP, "-right");
    }
    if (LOWER_RIGHT_REGEXP.test(key)) {
      return key.replace(LOWER_RIGHT_REGEXP, "-left");
    }
    if (UPPER_LEFT_REGEXP.test(key)) {
      return key.replace(UPPER_LEFT_REGEXP, "Right");
    }
    if (UPPER_RIGHT_REGEXP.test(key)) {
      return key.replace(UPPER_RIGHT_REGEXP, "Left");
    }
    return key;
  }
  var convertLTRToRTL = (ltrStyles = {}) => {
    return Object.fromEntries(Object.entries(ltrStyles).map(([key, value]) => [getConvertedKey(key), value]));
  };
  function rtl(ltrStyles = {}, rtlStyles) {
    return () => {
      if (rtlStyles) {
        return (0, import_i18n2.isRTL)() ? /* @__PURE__ */ css(rtlStyles, false ? "" : ";label:rtl;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJ0bC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE4RW9CIiwiZmlsZSI6InJ0bC5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBXb3JkUHJlc3MgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGlzUlRMIH0gZnJvbSAnQHdvcmRwcmVzcy9pMThuJztcblxuY29uc3QgTE9XRVJfTEVGVF9SRUdFWFAgPSBuZXcgUmVnRXhwKCAvLWxlZnQvZyApO1xuY29uc3QgTE9XRVJfUklHSFRfUkVHRVhQID0gbmV3IFJlZ0V4cCggLy1yaWdodC9nICk7XG5jb25zdCBVUFBFUl9MRUZUX1JFR0VYUCA9IG5ldyBSZWdFeHAoIC9MZWZ0L2cgKTtcbmNvbnN0IFVQUEVSX1JJR0hUX1JFR0VYUCA9IG5ldyBSZWdFeHAoIC9SaWdodC9nICk7XG5cbi8qKlxuICogRmxpcHMgYSBDU1MgcHJvcGVydHkgZnJvbSBsZWZ0IDwtPiByaWdodC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30ga2V5IFRoZSBDU1MgcHJvcGVydHkgbmFtZS5cbiAqXG4gKiBAcmV0dXJuIHtzdHJpbmd9IFRoZSBmbGlwcGVkIENTUyBwcm9wZXJ0eSBuYW1lLCBpZiBhcHBsaWNhYmxlLlxuICovXG5mdW5jdGlvbiBnZXRDb252ZXJ0ZWRLZXkoIGtleSApIHtcblx0aWYgKCBrZXkgPT09ICdsZWZ0JyApIHtcblx0XHRyZXR1cm4gJ3JpZ2h0Jztcblx0fVxuXG5cdGlmICgga2V5ID09PSAncmlnaHQnICkge1xuXHRcdHJldHVybiAnbGVmdCc7XG5cdH1cblxuXHRpZiAoIExPV0VSX0xFRlRfUkVHRVhQLnRlc3QoIGtleSApICkge1xuXHRcdHJldHVybiBrZXkucmVwbGFjZSggTE9XRVJfTEVGVF9SRUdFWFAsICctcmlnaHQnICk7XG5cdH1cblxuXHRpZiAoIExPV0VSX1JJR0hUX1JFR0VYUC50ZXN0KCBrZXkgKSApIHtcblx0XHRyZXR1cm4ga2V5LnJlcGxhY2UoIExPV0VSX1JJR0hUX1JFR0VYUCwgJy1sZWZ0JyApO1xuXHR9XG5cblx0aWYgKCBVUFBFUl9MRUZUX1JFR0VYUC50ZXN0KCBrZXkgKSApIHtcblx0XHRyZXR1cm4ga2V5LnJlcGxhY2UoIFVQUEVSX0xFRlRfUkVHRVhQLCAnUmlnaHQnICk7XG5cdH1cblxuXHRpZiAoIFVQUEVSX1JJR0hUX1JFR0VYUC50ZXN0KCBrZXkgKSApIHtcblx0XHRyZXR1cm4ga2V5LnJlcGxhY2UoIFVQUEVSX1JJR0hUX1JFR0VYUCwgJ0xlZnQnICk7XG5cdH1cblxuXHRyZXR1cm4ga2V5O1xufVxuXG4vKipcbiAqIEFuIGluY3JlZGlibHkgYmFzaWMgbHRyIC0+IHJ0bCBjb252ZXJ0ZXIgZm9yIHN0eWxlIHByb3BlcnRpZXNcbiAqXG4gKiBAcGFyYW0ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IGx0clN0eWxlc1xuICpcbiAqIEByZXR1cm4ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IENvbnZlcnRlZCBsdHIgLT4gcnRsIHN0eWxlc1xuICovXG5leHBvcnQgY29uc3QgY29udmVydExUUlRvUlRMID0gKCBsdHJTdHlsZXMgPSB7fSApID0+IHtcblx0cmV0dXJuIE9iamVjdC5mcm9tRW50cmllcyhcblx0XHRPYmplY3QuZW50cmllcyggbHRyU3R5bGVzICkubWFwKCAoIFsga2V5LCB2YWx1ZSBdICkgPT4gW1xuXHRcdFx0Z2V0Q29udmVydGVkS2V5KCBrZXkgKSxcblx0XHRcdHZhbHVlLFxuXHRcdF0gKVxuXHQpO1xufTtcblxuLyoqXG4gKiBBIGhpZ2hlci1vcmRlciBmdW5jdGlvbiB0aGF0IGNyZWF0ZSBhbiBpbmNyZWRpYmx5IGJhc2ljIGx0ciAtPiBydGwgc3R5bGUgY29udmVydGVyIGZvciBDU1Mgb2JqZWN0cy5cbiAqXG4gKiBAcGFyYW0ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IGx0clN0eWxlcyAgIEx0ciBzdHlsZXMuIENvbnZlcnRzIGFuZCByZW5kZXJzIGZyb20gbHRyIC0+IHJ0bCBzdHlsZXMsIGlmIGFwcGxpY2FibGUuXG4gKiBAcGFyYW0ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IFtydGxTdHlsZXNdIFJ0bCBzdHlsZXMuIFJlbmRlcnMgaWYgcHJvdmlkZWQuXG4gKlxuICogQHJldHVybiB7KCkgPT4gaW1wb3J0KCdAZW1vdGlvbi9yZWFjdCcpLlNlcmlhbGl6ZWRTdHlsZXN9IEEgZnVuY3Rpb24gdG8gb3V0cHV0IENTUyBzdHlsZXMgZm9yIEVtb3Rpb24ncyByZW5kZXJlclxuICovXG5leHBvcnQgZnVuY3Rpb24gcnRsKCBsdHJTdHlsZXMgPSB7fSwgcnRsU3R5bGVzICkge1xuXHRyZXR1cm4gKCkgPT4ge1xuXHRcdGlmICggcnRsU3R5bGVzICkge1xuXHRcdFx0Ly8gQHRzLWlnbm9yZTogYGNzc2AgdHlwZXMgYXJlIHdyb25nLCBpdCBjYW4gYWNjZXB0IGFuIG9iamVjdDogaHR0cHM6Ly9lbW90aW9uLnNoL2RvY3Mvb2JqZWN0LXN0eWxlcyN3aXRoLWNzc1xuXHRcdFx0cmV0dXJuIGlzUlRMKCkgPyBjc3MoIHJ0bFN0eWxlcyApIDogY3NzKCBsdHJTdHlsZXMgKTtcblx0XHR9XG5cblx0XHQvLyBAdHMtaWdub3JlOiBgY3NzYCB0eXBlcyBhcmUgd3JvbmcsIGl0IGNhbiBhY2NlcHQgYW4gb2JqZWN0OiBodHRwczovL2Vtb3Rpb24uc2gvZG9jcy9vYmplY3Qtc3R5bGVzI3dpdGgtY3NzXG5cdFx0cmV0dXJuIGlzUlRMKCkgPyBjc3MoIGNvbnZlcnRMVFJUb1JUTCggbHRyU3R5bGVzICkgKSA6IGNzcyggbHRyU3R5bGVzICk7XG5cdH07XG59XG5cbi8qKlxuICogQ2FsbCB0aGlzIGluIHRoZSBgdXNlTWVtb2AgZGVwZW5kZW5jeSBhcnJheSB0byBlbnN1cmUgdGhhdCBzdWJzZXF1ZW50IHJlbmRlcnMgd2lsbFxuICogY2F1c2UgcnRsIHN0eWxlcyB0byB1cGRhdGUgYmFzZWQgb24gdGhlIGBpc1JUTGAgcmV0dXJuIHZhbHVlIGV2ZW4gaWYgYWxsIG90aGVyIGRlcGVuZGVuY2llc1xuICogcmVtYWluIHRoZSBzYW1lLlxuICpcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBzdHlsZXMgPSB1c2VNZW1vKCAoKSA9PiB7XG4gKiAgIHJldHVybiBjc3NgXG4gKiAgICAgJHsgcnRsKCB7IG1hcmdpblJpZ2h0OiAnMTBweCcgfSApIH1cbiAqICAgYDtcbiAqIH0sIFsgcnRsLndhdGNoKCkgXSApO1xuICovXG5ydGwud2F0Y2ggPSAoKSA9PiBpc1JUTCgpO1xuIl19 */") : /* @__PURE__ */ css(ltrStyles, false ? "" : ";label:rtl;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
      }
      return (0, import_i18n2.isRTL)() ? /* @__PURE__ */ css(convertLTRToRTL(ltrStyles), false ? "" : ";label:rtl;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJ0bC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFrRm1CIiwiZmlsZSI6InJ0bC5qcyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBXb3JkUHJlc3MgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGlzUlRMIH0gZnJvbSAnQHdvcmRwcmVzcy9pMThuJztcblxuY29uc3QgTE9XRVJfTEVGVF9SRUdFWFAgPSBuZXcgUmVnRXhwKCAvLWxlZnQvZyApO1xuY29uc3QgTE9XRVJfUklHSFRfUkVHRVhQID0gbmV3IFJlZ0V4cCggLy1yaWdodC9nICk7XG5jb25zdCBVUFBFUl9MRUZUX1JFR0VYUCA9IG5ldyBSZWdFeHAoIC9MZWZ0L2cgKTtcbmNvbnN0IFVQUEVSX1JJR0hUX1JFR0VYUCA9IG5ldyBSZWdFeHAoIC9SaWdodC9nICk7XG5cbi8qKlxuICogRmxpcHMgYSBDU1MgcHJvcGVydHkgZnJvbSBsZWZ0IDwtPiByaWdodC5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30ga2V5IFRoZSBDU1MgcHJvcGVydHkgbmFtZS5cbiAqXG4gKiBAcmV0dXJuIHtzdHJpbmd9IFRoZSBmbGlwcGVkIENTUyBwcm9wZXJ0eSBuYW1lLCBpZiBhcHBsaWNhYmxlLlxuICovXG5mdW5jdGlvbiBnZXRDb252ZXJ0ZWRLZXkoIGtleSApIHtcblx0aWYgKCBrZXkgPT09ICdsZWZ0JyApIHtcblx0XHRyZXR1cm4gJ3JpZ2h0Jztcblx0fVxuXG5cdGlmICgga2V5ID09PSAncmlnaHQnICkge1xuXHRcdHJldHVybiAnbGVmdCc7XG5cdH1cblxuXHRpZiAoIExPV0VSX0xFRlRfUkVHRVhQLnRlc3QoIGtleSApICkge1xuXHRcdHJldHVybiBrZXkucmVwbGFjZSggTE9XRVJfTEVGVF9SRUdFWFAsICctcmlnaHQnICk7XG5cdH1cblxuXHRpZiAoIExPV0VSX1JJR0hUX1JFR0VYUC50ZXN0KCBrZXkgKSApIHtcblx0XHRyZXR1cm4ga2V5LnJlcGxhY2UoIExPV0VSX1JJR0hUX1JFR0VYUCwgJy1sZWZ0JyApO1xuXHR9XG5cblx0aWYgKCBVUFBFUl9MRUZUX1JFR0VYUC50ZXN0KCBrZXkgKSApIHtcblx0XHRyZXR1cm4ga2V5LnJlcGxhY2UoIFVQUEVSX0xFRlRfUkVHRVhQLCAnUmlnaHQnICk7XG5cdH1cblxuXHRpZiAoIFVQUEVSX1JJR0hUX1JFR0VYUC50ZXN0KCBrZXkgKSApIHtcblx0XHRyZXR1cm4ga2V5LnJlcGxhY2UoIFVQUEVSX1JJR0hUX1JFR0VYUCwgJ0xlZnQnICk7XG5cdH1cblxuXHRyZXR1cm4ga2V5O1xufVxuXG4vKipcbiAqIEFuIGluY3JlZGlibHkgYmFzaWMgbHRyIC0+IHJ0bCBjb252ZXJ0ZXIgZm9yIHN0eWxlIHByb3BlcnRpZXNcbiAqXG4gKiBAcGFyYW0ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IGx0clN0eWxlc1xuICpcbiAqIEByZXR1cm4ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IENvbnZlcnRlZCBsdHIgLT4gcnRsIHN0eWxlc1xuICovXG5leHBvcnQgY29uc3QgY29udmVydExUUlRvUlRMID0gKCBsdHJTdHlsZXMgPSB7fSApID0+IHtcblx0cmV0dXJuIE9iamVjdC5mcm9tRW50cmllcyhcblx0XHRPYmplY3QuZW50cmllcyggbHRyU3R5bGVzICkubWFwKCAoIFsga2V5LCB2YWx1ZSBdICkgPT4gW1xuXHRcdFx0Z2V0Q29udmVydGVkS2V5KCBrZXkgKSxcblx0XHRcdHZhbHVlLFxuXHRcdF0gKVxuXHQpO1xufTtcblxuLyoqXG4gKiBBIGhpZ2hlci1vcmRlciBmdW5jdGlvbiB0aGF0IGNyZWF0ZSBhbiBpbmNyZWRpYmx5IGJhc2ljIGx0ciAtPiBydGwgc3R5bGUgY29udmVydGVyIGZvciBDU1Mgb2JqZWN0cy5cbiAqXG4gKiBAcGFyYW0ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IGx0clN0eWxlcyAgIEx0ciBzdHlsZXMuIENvbnZlcnRzIGFuZCByZW5kZXJzIGZyb20gbHRyIC0+IHJ0bCBzdHlsZXMsIGlmIGFwcGxpY2FibGUuXG4gKiBAcGFyYW0ge1JlYWN0LkNTU1Byb3BlcnRpZXN9IFtydGxTdHlsZXNdIFJ0bCBzdHlsZXMuIFJlbmRlcnMgaWYgcHJvdmlkZWQuXG4gKlxuICogQHJldHVybiB7KCkgPT4gaW1wb3J0KCdAZW1vdGlvbi9yZWFjdCcpLlNlcmlhbGl6ZWRTdHlsZXN9IEEgZnVuY3Rpb24gdG8gb3V0cHV0IENTUyBzdHlsZXMgZm9yIEVtb3Rpb24ncyByZW5kZXJlclxuICovXG5leHBvcnQgZnVuY3Rpb24gcnRsKCBsdHJTdHlsZXMgPSB7fSwgcnRsU3R5bGVzICkge1xuXHRyZXR1cm4gKCkgPT4ge1xuXHRcdGlmICggcnRsU3R5bGVzICkge1xuXHRcdFx0Ly8gQHRzLWlnbm9yZTogYGNzc2AgdHlwZXMgYXJlIHdyb25nLCBpdCBjYW4gYWNjZXB0IGFuIG9iamVjdDogaHR0cHM6Ly9lbW90aW9uLnNoL2RvY3Mvb2JqZWN0LXN0eWxlcyN3aXRoLWNzc1xuXHRcdFx0cmV0dXJuIGlzUlRMKCkgPyBjc3MoIHJ0bFN0eWxlcyApIDogY3NzKCBsdHJTdHlsZXMgKTtcblx0XHR9XG5cblx0XHQvLyBAdHMtaWdub3JlOiBgY3NzYCB0eXBlcyBhcmUgd3JvbmcsIGl0IGNhbiBhY2NlcHQgYW4gb2JqZWN0OiBodHRwczovL2Vtb3Rpb24uc2gvZG9jcy9vYmplY3Qtc3R5bGVzI3dpdGgtY3NzXG5cdFx0cmV0dXJuIGlzUlRMKCkgPyBjc3MoIGNvbnZlcnRMVFJUb1JUTCggbHRyU3R5bGVzICkgKSA6IGNzcyggbHRyU3R5bGVzICk7XG5cdH07XG59XG5cbi8qKlxuICogQ2FsbCB0aGlzIGluIHRoZSBgdXNlTWVtb2AgZGVwZW5kZW5jeSBhcnJheSB0byBlbnN1cmUgdGhhdCBzdWJzZXF1ZW50IHJlbmRlcnMgd2lsbFxuICogY2F1c2UgcnRsIHN0eWxlcyB0byB1cGRhdGUgYmFzZWQgb24gdGhlIGBpc1JUTGAgcmV0dXJuIHZhbHVlIGV2ZW4gaWYgYWxsIG90aGVyIGRlcGVuZGVuY2llc1xuICogcmVtYWluIHRoZSBzYW1lLlxuICpcbiAqIEBleGFtcGxlXG4gKiBjb25zdCBzdHlsZXMgPSB1c2VNZW1vKCAoKSA9PiB7XG4gKiAgIHJldHVybiBjc3NgXG4gKiAgICAgJHsgcnRsKCB7IG1hcmdpblJpZ2h0OiAnMTBweCcgfSApIH1cbiAqICAgYDtcbiAqIH0sIFsgcnRsLndhdGNoKCkgXSApO1xuICovXG5ydGwud2F0Y2ggPSAoKSA9PiBpc1JUTCgpO1xuIl19 */") : /* @__PURE__ */ css(ltrStyles, false ? "" : ";label:rtl;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
    };
  }
  rtl.watch = () => (0, import_i18n2.isRTL)();

  // packages/components/build-module/utils/font-values.mjs
  var font_values_default = {
    "default.fontFamily": "-apple-system, system-ui, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif",
    "default.fontSize": "13px",
    "helpText.fontSize": "12px",
    mobileTextMinFontSize: "16px"
  };

  // packages/components/build-module/utils/font.mjs
  function font(value) {
    return font_values_default[value] ?? "";
  }

  // packages/components/build-module/utils/breakpoint-values.mjs
  var breakpoint_values_default = {
    huge: "1440px",
    wide: "1280px",
    "x-large": "1080px",
    large: "960px",
    // admin sidebar auto folds
    medium: "782px",
    // Adminbar goes big.
    small: "600px",
    mobile: "480px",
    "zoomed-in": "280px"
  };

  // packages/components/build-module/utils/breakpoint.mjs
  var breakpoint = (point) => `@media (min-width: ${breakpoint_values_default[point]})`;

  // packages/components/build-module/utils/colors-values.mjs
  var white = "#fff";
  var GRAY = {
    900: "#1e1e1e",
    800: "#2f2f2f",
    /** Meets 4.6:1 text contrast against white. */
    700: "#757575",
    /** Meets 3:1 UI or large text contrast against white. */
    600: "#949494",
    400: "#ccc",
    /** Used for most borders. */
    300: "#ddd",
    /** Used sparingly for light borders. */
    200: "#e0e0e0",
    /** Used for light gray backgrounds. */
    100: "#f0f0f0"
  };
  var ALERT = {
    yellow: "#f0b849",
    red: "#d94f4f",
    green: "#4ab866"
  };
  var THEME = {
    accent: `var(--wp-components-color-accent, var(--wp-admin-theme-color, #3858e9))`,
    accentDarker10: `var(--wp-components-color-accent-darker-10, var(--wp-admin-theme-color-darker-10, #2145e6))`,
    accentDarker20: `var(--wp-components-color-accent-darker-20, var(--wp-admin-theme-color-darker-20, #183ad6))`,
    /** Used when placing text on the accent color. */
    accentInverted: `var(--wp-components-color-accent-inverted, var(--wpds-color-foreground-interactive-brand-strong, #fff))`,
    background: `var(--wp-components-color-background, var(--wpds-color-background-surface-neutral-strong, #fff))`,
    foreground: `var(--wp-components-color-foreground, var(--wpds-color-foreground-content-neutral, #1e1e1e))`,
    /** Used when placing text on the foreground color. */
    foregroundInverted: `var(--wp-components-color-foreground-inverted, var(--wpds-color-background-surface-neutral, #fcfcfc))`,
    gray: {
      /** @deprecated Use `COLORS.theme.foreground` instead. */
      900: `var(--wp-components-color-foreground, var(--wpds-color-foreground-content-neutral, #1e1e1e))`,
      800: `var(--wp-components-color-gray-800, var(--wpds-color-foreground-content-neutral, #1e1e1e))`,
      700: `var(--wp-components-color-gray-700, var(--wpds-color-foreground-content-neutral-weak, #707070))`,
      600: `var(--wp-components-color-gray-600, var(--wpds-color-stroke-interactive-neutral, #8d8d8d))`,
      400: `var(--wp-components-color-gray-400, var(--wpds-color-stroke-interactive-neutral, #8d8d8d))`,
      300: `var(--wp-components-color-gray-300, var(--wpds-color-stroke-surface-neutral, #dbdbdb))`,
      200: `var(--wp-components-color-gray-200, var(--wpds-color-stroke-surface-neutral, #dbdbdb))`,
      100: `var(--wp-components-color-gray-100, var(--wpds-color-background-surface-neutral, #fcfcfc))`
    }
  };
  var UI = {
    background: THEME.background,
    backgroundDisabled: THEME.gray[100],
    border: THEME.gray[600],
    borderHover: THEME.gray[700],
    borderFocus: THEME.accent,
    borderDisabled: THEME.gray[400],
    textDisabled: THEME.gray[600],
    // Matches @wordpress/base-styles
    darkGrayPlaceholder: `color-mix(in srgb, ${THEME.foreground}, transparent 38%)`,
    lightGrayPlaceholder: `color-mix(in srgb, ${THEME.background}, transparent 35%)`
  };
  var COLORS = Object.freeze({
    /**
     * The main gray color object.
     *
     * @deprecated Use semantic aliases in `COLORS.ui` or theme-ready variables in `COLORS.theme.gray`.
     */
    gray: GRAY,
    // TODO: Stop exporting this when everything is migrated to `theme` or `ui`
    /**
     * @deprecated Prefer theme-ready variables in `COLORS.theme`.
     */
    white,
    alert: ALERT,
    /**
     * Theme-ready variables with fallbacks.
     *
     * Prefer semantic aliases in `COLORS.ui` when applicable.
     */
    theme: THEME,
    /**
     * Semantic aliases (prefer these over raw variables when applicable).
     */
    ui: UI
  });

  // packages/components/build-module/utils/config-values.mjs
  var CONTROL_HEIGHT = "36px";
  var CONTROL_PROPS = {
    // These values should be shared with TextControl.
    controlPaddingX: 12,
    controlPaddingXSmall: 8,
    controlPaddingXLarge: 12 * 1.3334,
    // TODO: Deprecate
    controlBoxShadowFocus: `0 0 0 0.5px ${COLORS.theme.accent}`,
    controlHeight: CONTROL_HEIGHT,
    controlHeightXSmall: `calc( ${CONTROL_HEIGHT} * 0.6 )`,
    controlHeightSmall: `calc( ${CONTROL_HEIGHT} * 0.8 )`,
    controlHeightLarge: `calc( ${CONTROL_HEIGHT} * 1.2 )`,
    controlHeightXLarge: `calc( ${CONTROL_HEIGHT} * 1.4 )`
  };
  var config_values_default = Object.assign({}, CONTROL_PROPS, {
    colorDivider: "rgba(0, 0, 0, 0.1)",
    colorScrollbarThumb: "rgba(0, 0, 0, 0.2)",
    colorScrollbarThumbHover: "rgba(0, 0, 0, 0.5)",
    colorScrollbarTrack: "rgba(0, 0, 0, 0.04)",
    elevationIntensity: 1,
    radiusXSmall: "1px",
    radiusSmall: "2px",
    radiusMedium: "4px",
    radiusLarge: "8px",
    radiusFull: "9999px",
    radiusRound: "50%",
    borderWidth: "1px",
    borderWidthFocus: "1.5px",
    borderWidthTab: "4px",
    spinnerSize: 16,
    fontSize: "13px",
    fontSizeH1: "calc(2.44 * 13px)",
    fontSizeH2: "calc(1.95 * 13px)",
    fontSizeH3: "calc(1.56 * 13px)",
    fontSizeH4: "calc(1.25 * 13px)",
    fontSizeH5: "13px",
    fontSizeH6: "calc(0.8 * 13px)",
    fontSizeInputMobile: "16px",
    fontSizeMobile: "15px",
    fontSizeSmall: "calc(0.92 * 13px)",
    fontSizeXSmall: "calc(0.75 * 13px)",
    fontLineHeightBase: "1.4",
    fontWeight: "normal",
    fontWeightEmphasis: "600",
    gridBase: "4px",
    elevationXSmall: `0 1px 1px rgba(0, 0, 0, 0.03), 0 1px 2px rgba(0, 0, 0, 0.02), 0 3px 3px rgba(0, 0, 0, 0.02), 0 4px 4px rgba(0, 0, 0, 0.01)`,
    elevationSmall: `0 1px 2px rgba(0, 0, 0, 0.05), 0 2px 3px rgba(0, 0, 0, 0.04), 0 6px 6px rgba(0, 0, 0, 0.03), 0 8px 8px rgba(0, 0, 0, 0.02)`,
    elevationMedium: `0 2px 3px rgba(0, 0, 0, 0.05), 0 4px 5px rgba(0, 0, 0, 0.04), 0 12px 12px rgba(0, 0, 0, 0.03), 0 16px 16px rgba(0, 0, 0, 0.02)`,
    elevationLarge: `0 5px 15px rgba(0, 0, 0, 0.08), 0 15px 27px rgba(0, 0, 0, 0.07), 0 30px 36px rgba(0, 0, 0, 0.04), 0 50px 43px rgba(0, 0, 0, 0.02)`,
    surfaceBorderColor: "rgba(0, 0, 0, 0.1)",
    surfaceColor: COLORS.white,
    // Modal exit animation: `use-modal-exit-animation` parses this for the
    // `animationend` timeout race; keep the numeric duration equal to the WPDS
    // `motion-duration-md` token on `.components-modal__frame` in modal/style.scss.
    transitionDuration: "200ms",
    transitionDurationFast: "160ms",
    transitionDurationFaster: "120ms",
    transitionDurationFastest: "100ms",
    transitionTimingFunction: "cubic-bezier(0.08, 0.52, 0.52, 1)",
    transitionTimingFunctionControl: "cubic-bezier(0.12, 0.8, 0.32, 1)"
  });

  // packages/components/build-module/utils/base-label.mjs
  var baseLabelTypography = /* @__PURE__ */ css("font-size:11px;font-weight:", config_values_default.fontWeightEmphasis, ";line-height:1.4;text-transform:uppercase;" + (false ? "" : ";label:baseLabelTypography;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJhc2UtbGFiZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWXNDIiwiZmlsZSI6ImJhc2UtbGFiZWwudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5cbi8qKlxuICogSW50ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBDT05GSUcgZnJvbSAnLi9jb25maWctdmFsdWVzLmpzJztcblxuLy8gVGhpcyBpcyBhIHZlcnkgbG93LWxldmVsIG1peGluIHdoaWNoIHlvdSBzaG91bGRuJ3QgaGF2ZSB0byB1c2UgZGlyZWN0bHkuXG4vLyBUcnkgdG8gdXNlIEJhc2VDb250cm9sJ3MgU3R5bGVkTGFiZWwgb3IgQmFzZUNvbnRyb2wuVmlzdWFsTGFiZWwgaWYgeW91IGNhbi5cbmV4cG9ydCBjb25zdCBiYXNlTGFiZWxUeXBvZ3JhcGh5ID0gY3NzYFxuXHRmb250LXNpemU6IDExcHg7XG5cdGZvbnQtd2VpZ2h0OiAkeyBDT05GSUcuZm9udFdlaWdodEVtcGhhc2lzIH07XG5cdGxpbmUtaGVpZ2h0OiAxLjQ7XG5cdHRleHQtdHJhbnNmb3JtOiB1cHBlcmNhc2U7XG5gO1xuIl19 */");

  // packages/components/build-module/utils/dropdown-motion.mjs
  var DROPDOWN_MOTION = Object.freeze({
    SLIDE_DISTANCE: 4,
    SLIDE_DURATION: 200,
    SLIDE_EASING: {
      function: "cubic-bezier",
      args: [0.25, 0, 0, 1]
    },
    FADE_DURATION: 100,
    FADE_EASING: {
      function: "linear"
    }
  });
  var convertEasingToString = (easing) => {
    if (easing.args?.length) {
      return `${easing.function}(${easing.args.join(",")})`;
    }
    return easing.function;
  };
  var DROPDOWN_MOTION_CSS = Object.freeze({
    SLIDE_DISTANCE: `${DROPDOWN_MOTION.SLIDE_DISTANCE}px`,
    SLIDE_DURATION: `${DROPDOWN_MOTION.SLIDE_DURATION}ms`,
    SLIDE_EASING: convertEasingToString(DROPDOWN_MOTION.SLIDE_EASING),
    FADE_DURATION: `${DROPDOWN_MOTION.FADE_DURATION}ms`,
    FADE_EASING: convertEasingToString(DROPDOWN_MOTION.FADE_EASING)
  });

  // packages/components/build-module/popover/utils.mjs
  var POSITION_TO_PLACEMENT = {
    bottom: "bottom",
    top: "top",
    "middle left": "left",
    "middle right": "right",
    "bottom left": "bottom-end",
    "bottom center": "bottom",
    "bottom right": "bottom-start",
    "top left": "top-end",
    "top center": "top",
    "top right": "top-start",
    "middle left left": "left",
    "middle left right": "left",
    "middle left bottom": "left-end",
    "middle left top": "left-start",
    "middle right left": "right",
    "middle right right": "right",
    "middle right bottom": "right-end",
    "middle right top": "right-start",
    "bottom left left": "bottom-end",
    "bottom left right": "bottom-end",
    "bottom left bottom": "bottom-end",
    "bottom left top": "bottom-end",
    "bottom center left": "bottom",
    "bottom center right": "bottom",
    "bottom center bottom": "bottom",
    "bottom center top": "bottom",
    "bottom right left": "bottom-start",
    "bottom right right": "bottom-start",
    "bottom right bottom": "bottom-start",
    "bottom right top": "bottom-start",
    "top left left": "top-end",
    "top left right": "top-end",
    "top left bottom": "top-end",
    "top left top": "top-end",
    "top center left": "top",
    "top center right": "top",
    "top center bottom": "top",
    "top center top": "top",
    "top right left": "top-start",
    "top right right": "top-start",
    "top right bottom": "top-start",
    "top right top": "top-start",
    // `middle`/`middle center [corner?]` positions are associated to a fallback
    // `bottom` placement because there aren't any corresponding placement values.
    middle: "bottom",
    "middle center": "bottom",
    "middle center bottom": "bottom",
    "middle center left": "bottom",
    "middle center right": "bottom",
    "middle center top": "bottom"
  };
  var positionToPlacement = (position2) => POSITION_TO_PLACEMENT[position2] ?? "bottom";
  var PLACEMENT_TO_ANIMATION_ORIGIN = {
    top: {
      originX: 0.5,
      originY: 1
    },
    // open from bottom, center
    "top-start": {
      originX: 0,
      originY: 1
    },
    // open from bottom, left
    "top-end": {
      originX: 1,
      originY: 1
    },
    // open from bottom, right
    right: {
      originX: 0,
      originY: 0.5
    },
    // open from middle, left
    "right-start": {
      originX: 0,
      originY: 0
    },
    // open from top, left
    "right-end": {
      originX: 0,
      originY: 1
    },
    // open from bottom, left
    bottom: {
      originX: 0.5,
      originY: 0
    },
    // open from top, center
    "bottom-start": {
      originX: 0,
      originY: 0
    },
    // open from top, left
    "bottom-end": {
      originX: 1,
      originY: 0
    },
    // open from top, right
    left: {
      originX: 1,
      originY: 0.5
    },
    // open from middle, right
    "left-start": {
      originX: 1,
      originY: 0
    },
    // open from top, right
    "left-end": {
      originX: 1,
      originY: 1
    },
    // open from bottom, right
    overlay: {
      originX: 0.5,
      originY: 0.5
    }
    // open from center, center
  };
  var placementToMotionAnimationProps = (placement) => {
    const translateProp = placement.startsWith("top") || placement.startsWith("bottom") ? "translateY" : "translateX";
    const translateDirection = placement.startsWith("top") || placement.startsWith("left") ? 1 : -1;
    return {
      style: PLACEMENT_TO_ANIMATION_ORIGIN[placement],
      initial: {
        opacity: 0,
        [translateProp]: `${DROPDOWN_MOTION.SLIDE_DISTANCE * translateDirection}px`
      },
      animate: {
        opacity: 1,
        [translateProp]: 0
      },
      transition: {
        opacity: {
          duration: DROPDOWN_MOTION.FADE_DURATION / 1e3,
          ease: DROPDOWN_MOTION.FADE_EASING.function
        },
        [translateProp]: {
          duration: DROPDOWN_MOTION.SLIDE_DURATION / 1e3,
          ease: cubicBezier(...DROPDOWN_MOTION.SLIDE_EASING.args)
        }
      }
    };
  };
  function isTopBottom(anchorRef) {
    return !!anchorRef?.top;
  }
  function isRef(anchorRef) {
    return !!anchorRef?.current;
  }
  var getReferenceElement = ({
    anchor,
    anchorRef,
    anchorRect,
    getAnchorRect,
    fallbackReferenceElement
  }) => {
    let referenceElement = null;
    if (anchor) {
      referenceElement = anchor;
    } else if (isTopBottom(anchorRef)) {
      referenceElement = {
        getBoundingClientRect() {
          const topRect = anchorRef.top.getBoundingClientRect();
          const bottomRect = anchorRef.bottom.getBoundingClientRect();
          return new window.DOMRect(topRect.x, topRect.y, topRect.width, bottomRect.bottom - topRect.top);
        }
      };
    } else if (isRef(anchorRef)) {
      referenceElement = anchorRef.current;
    } else if (anchorRef) {
      referenceElement = anchorRef;
    } else if (anchorRect) {
      referenceElement = {
        getBoundingClientRect() {
          return anchorRect;
        }
      };
    } else if (getAnchorRect) {
      referenceElement = {
        getBoundingClientRect() {
          const rect = getAnchorRect(fallbackReferenceElement);
          return new window.DOMRect(rect.x ?? rect.left, rect.y ?? rect.top, rect.width ?? rect.right - rect.left, rect.height ?? rect.bottom - rect.top);
        }
      };
    } else if (fallbackReferenceElement) {
      referenceElement = fallbackReferenceElement.parentElement;
    }
    return referenceElement ?? null;
  };
  var computePopoverPosition = (c3) => c3 === null || Number.isNaN(c3) ? void 0 : Math.round(c3);

  // packages/components/build-module/tooltip/context.mjs
  var import_element13 = __toESM(require_element(), 1);
  var TooltipInternalContext = (0, import_element13.createContext)({
    isNestedInTooltip: false
  });
  TooltipInternalContext.displayName = "TooltipInternalContext";

  // packages/components/build-module/tooltip/index.mjs
  var import_jsx_runtime44 = __toESM(require_jsx_runtime(), 1);
  var TOOLTIP_DELAY = 700;
  var CONTEXT_VALUE = {
    isNestedInTooltip: true
  };
  function UnforwardedTooltip(props, ref) {
    const {
      children,
      className: className2,
      delay: delay2 = TOOLTIP_DELAY,
      hideOnClick = true,
      placement,
      position: position2,
      shortcut,
      text,
      ...restProps
    } = props;
    const {
      isNestedInTooltip
    } = (0, import_element14.useContext)(TooltipInternalContext);
    const baseId = (0, import_compose.useInstanceId)(Tooltip22, "tooltip");
    const describedById = text || shortcut ? baseId : void 0;
    const isOnlyChild = import_element14.Children.count(children) === 1;
    if (!isOnlyChild) {
      if (true) {
        console.error("wp-components.Tooltip should be called with only a single child element.");
      }
    }
    let computedPlacement;
    if (placement !== void 0) {
      computedPlacement = placement;
    } else if (position2 !== void 0) {
      computedPlacement = positionToPlacement(position2);
      (0, import_deprecated.default)("`position` prop in wp.components.tooltip", {
        since: "6.4",
        alternative: "`placement` prop"
      });
    }
    computedPlacement = computedPlacement || "top";
    const tooltipStore = useTooltipStore({
      placement: computedPlacement,
      showTimeout: delay2
    });
    const mounted = useStoreState(tooltipStore, "mounted");
    if (isNestedInTooltip) {
      return isOnlyChild ? /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(Role, {
        ...restProps,
        render: children
      }) : children;
    }
    function addDescribedById(element) {
      return describedById && mounted && element.props["aria-describedby"] === void 0 && element.props["aria-label"] !== text ? (0, import_element14.cloneElement)(element, {
        "aria-describedby": describedById
      }) : element;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(TooltipInternalContext.Provider, {
      value: CONTEXT_VALUE,
      children: [/* @__PURE__ */ (0, import_jsx_runtime44.jsx)(TooltipAnchor, {
        onClick: hideOnClick ? tooltipStore.hide : void 0,
        store: tooltipStore,
        render: isOnlyChild ? addDescribedById(children) : void 0,
        ref,
        children: isOnlyChild ? void 0 : children
      }), isOnlyChild && (text || shortcut) && /* @__PURE__ */ (0, import_jsx_runtime44.jsxs)(Tooltip, {
        ...restProps,
        className: clsx_default("components-tooltip", className2),
        unmountOnHide: true,
        gutter: 4,
        id: describedById,
        overflowPadding: 0.5,
        store: tooltipStore,
        children: [text, shortcut && /* @__PURE__ */ (0, import_jsx_runtime44.jsx)(shortcut_default, {
          className: text ? "components-tooltip__shortcut" : "",
          shortcut
        })]
      })]
    });
  }
  var Tooltip22 = (0, import_element14.forwardRef)(UnforwardedTooltip);
  var tooltip_default = Tooltip22;

  // packages/components/build-module/context/context-system-provider.mjs
  var import_deepmerge = __toESM(require_cjs(), 1);
  var import_es6 = __toESM(require_es6(), 1);

  // node_modules/is-plain-object/dist/is-plain-object.mjs
  function isObject(o4) {
    return Object.prototype.toString.call(o4) === "[object Object]";
  }
  function isPlainObject(o4) {
    var ctor, prot;
    if (isObject(o4) === false) return false;
    ctor = o4.constructor;
    if (ctor === void 0) return true;
    prot = ctor.prototype;
    if (isObject(prot) === false) return false;
    if (prot.hasOwnProperty("isPrototypeOf") === false) {
      return false;
    }
    return true;
  }

  // packages/components/build-module/context/context-system-provider.mjs
  var import_element15 = __toESM(require_element(), 1);
  var import_warning = __toESM(require_warning(), 1);
  var import_jsx_runtime45 = __toESM(require_jsx_runtime(), 1);
  var ComponentsContext = (0, import_element15.createContext)(
    /** @type {Record<string, any>} */
    {}
  );
  ComponentsContext.displayName = "ComponentsContext";
  var useComponentsContext = () => (0, import_element15.useContext)(ComponentsContext);
  function useContextSystemBridge({
    value
  }) {
    const parentContext = useComponentsContext();
    const valueRef = (0, import_element15.useRef)(value);
    use_update_effect_default(() => {
      if (
        // Objects are equivalent.
        (0, import_es6.default)(valueRef.current, value) && // But not the same reference.
        valueRef.current !== value
      ) {
        true ? (0, import_warning.default)(`Please memoize your context: ${JSON.stringify(value)}`) : void 0;
      }
    }, [value]);
    const config = (0, import_element15.useMemo)(() => {
      return (0, import_deepmerge.default)(parentContext ?? {}, value ?? {}, {
        isMergeableObject: isPlainObject
      });
    }, [parentContext, value]);
    return config;
  }
  var BaseContextSystemProvider = ({
    children,
    value
  }) => {
    const contextValue = useContextSystemBridge({
      value
    });
    return /* @__PURE__ */ (0, import_jsx_runtime45.jsx)(ComponentsContext.Provider, {
      value: contextValue,
      children
    });
  };
  var ContextSystemProvider = (0, import_element15.memo)(BaseContextSystemProvider);

  // packages/components/build-module/context/context-connect.mjs
  var import_element16 = __toESM(require_element(), 1);
  var import_warning2 = __toESM(require_warning(), 1);

  // packages/components/build-module/context/constants.mjs
  var COMPONENT_NAMESPACE = "data-wp-component";
  var CONNECTED_NAMESPACE = "data-wp-c16t";
  var CONNECT_STATIC_NAMESPACE = "__contextSystemKey__";

  // node_modules/tslib/tslib.es6.mjs
  var __assign = function() {
    __assign = Object.assign || function __assign4(t4) {
      for (var s3, i3 = 1, n3 = arguments.length; i3 < n3; i3++) {
        s3 = arguments[i3];
        for (var p3 in s3) if (Object.prototype.hasOwnProperty.call(s3, p3)) t4[p3] = s3[p3];
      }
      return t4;
    };
    return __assign.apply(this, arguments);
  };

  // node_modules/lower-case/dist.es2015/index.js
  function lowerCase(str) {
    return str.toLowerCase();
  }

  // node_modules/no-case/dist.es2015/index.js
  var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
  var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
  function noCase(input, options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    var _a = options2.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options2.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options2.transform, transform = _c === void 0 ? lowerCase : _c, _d = options2.delimiter, delimiter2 = _d === void 0 ? " " : _d;
    var result = replace2(replace2(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
    var start = 0;
    var end = result.length;
    while (result.charAt(start) === "\0")
      start++;
    while (result.charAt(end - 1) === "\0")
      end--;
    return result.slice(start, end).split("\0").map(transform).join(delimiter2);
  }
  function replace2(input, re4, value) {
    if (re4 instanceof RegExp)
      return input.replace(re4, value);
    return re4.reduce(function(input2, re5) {
      return input2.replace(re5, value);
    }, input);
  }

  // node_modules/dot-case/dist.es2015/index.js
  function dotCase(input, options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    return noCase(input, __assign({ delimiter: "." }, options2));
  }

  // node_modules/param-case/dist.es2015/index.js
  function paramCase(input, options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    return dotCase(input, __assign({ delimiter: "-" }, options2));
  }

  // packages/components/build-module/context/get-styled-class-name-from-key.mjs
  function getStyledClassName(namespace) {
    const kebab = paramCase(namespace);
    return `components-${kebab}`;
  }
  var getStyledClassNameFromKey = memize(getStyledClassName);

  // packages/components/build-module/context/context-connect.mjs
  function contextConnect(Component7, namespace) {
    return _contextConnect(Component7, namespace, {
      forwardsRef: true
    });
  }
  function contextConnectWithoutRef(Component7, namespace) {
    return _contextConnect(Component7, namespace);
  }
  function _contextConnect(Component7, namespace, options2) {
    const WrappedComponent = options2?.forwardsRef ? (0, import_element16.forwardRef)(Component7) : Component7;
    if (typeof namespace === "undefined") {
      true ? (0, import_warning2.default)("contextConnect: Please provide a namespace") : void 0;
    }
    let mergedNamespace = WrappedComponent[CONNECT_STATIC_NAMESPACE] || [namespace];
    if (Array.isArray(namespace)) {
      mergedNamespace = [...mergedNamespace, ...namespace];
    }
    if (typeof namespace === "string") {
      mergedNamespace = [...mergedNamespace, namespace];
    }
    return Object.assign(WrappedComponent, {
      [CONNECT_STATIC_NAMESPACE]: [...new Set(mergedNamespace)],
      displayName: namespace,
      selector: `.${getStyledClassNameFromKey(namespace)}`
    });
  }
  function getConnectNamespace(Component7) {
    if (!Component7) {
      return [];
    }
    let namespaces = [];
    if (Component7[CONNECT_STATIC_NAMESPACE]) {
      namespaces = Component7[CONNECT_STATIC_NAMESPACE];
    }
    if (Component7.type && Component7.type[CONNECT_STATIC_NAMESPACE]) {
      namespaces = Component7.type[CONNECT_STATIC_NAMESPACE];
    }
    return namespaces;
  }
  function hasConnectNamespace(Component7, match4) {
    if (!Component7) {
      return false;
    }
    if (typeof match4 === "string") {
      return getConnectNamespace(Component7).includes(match4);
    }
    if (Array.isArray(match4)) {
      return match4.some((result) => getConnectNamespace(Component7).includes(result));
    }
    return false;
  }

  // packages/components/build-module/context/use-context-system.mjs
  var import_warning3 = __toESM(require_warning(), 1);

  // packages/components/build-module/context/utils.mjs
  function getNamespace(componentName) {
    return {
      [COMPONENT_NAMESPACE]: componentName
    };
  }
  function getConnectedNamespace() {
    return {
      [CONNECTED_NAMESPACE]: true
    };
  }

  // packages/components/build-module/context/use-context-system.mjs
  function useContextSystem(props, namespace) {
    const contextSystemProps = useComponentsContext();
    if (typeof namespace === "undefined") {
      true ? (0, import_warning3.default)("useContextSystem: Please provide a namespace") : void 0;
    }
    const contextProps = contextSystemProps?.[namespace] || {};
    const finalComponentProps = {
      ...getConnectedNamespace(),
      ...getNamespace(namespace)
    };
    const {
      _overrides: overrideProps,
      ...otherContextProps
    } = contextProps;
    const initialMergedProps = Object.entries(otherContextProps).length ? Object.assign({}, otherContextProps, props) : props;
    const cx2 = useCx();
    const classes = cx2(getStyledClassNameFromKey(namespace), props.className);
    const rendered = typeof initialMergedProps.renderChildren === "function" ? initialMergedProps.renderChildren(initialMergedProps) : initialMergedProps.children;
    for (const key in initialMergedProps) {
      finalComponentProps[key] = initialMergedProps[key];
    }
    for (const key in overrideProps) {
      finalComponentProps[key] = overrideProps[key];
    }
    if (rendered !== void 0) {
      finalComponentProps.children = rendered;
    }
    finalComponentProps.className = classes;
    return finalComponentProps;
  }

  // packages/components/build-module/visually-hidden/styles.mjs
  var visuallyHidden = {
    border: 0,
    clip: "rect(1px, 1px, 1px, 1px)",
    WebkitClipPath: "inset( 50% )",
    clipPath: "inset( 50% )",
    height: "1px",
    margin: "-1px",
    overflow: "hidden",
    padding: 0,
    position: "absolute",
    width: "1px",
    wordWrap: "normal",
    wordBreak: "normal"
  };

  // packages/components/build-module/view/component.mjs
  var import_element18 = __toESM(require_element(), 1);

  // packages/components/build-module/utils/polymorphic-element.mjs
  var import_element17 = __toESM(require_element(), 1);
  var import_jsx_runtime46 = __toESM(require_jsx_runtime(), 1);
  var customAttributeRegExp = /^(data|aria|x)-/i;
  var eventHandlerRegExp = /^on[A-Z]/;
  var svgElementNames = new Set(`animate animateMotion animateTransform circle clipPath defs desc ellipse
	feBlend feColorMatrix feComponentTransfer feComposite feConvolveMatrix
	feDiffuseLighting feDisplacementMap feDistantLight feDropShadow feFlood
	feFuncA feFuncB feFuncG feFuncR feGaussianBlur feImage feMerge feMergeNode
	feMorphology feOffset fePointLight feSpecularLighting feSpotLight feTile
	feTurbulence filter foreignObject g image line linearGradient marker mask
	metadata mpath path pattern polygon polyline radialGradient rect set stop svg
	switch symbol text textPath tspan use view`.split(/\s+/));
  var baseElementProps = new Set(`children dangerouslySetInnerHTML key autoFocus defaultValue defaultChecked
	innerHTML suppressContentEditableWarning suppressHydrationWarning valueLink
	abbr accept acceptCharset accessKey action allow allowUserMedia
	allowPaymentRequest allowFullScreen allowTransparency alt async autoComplete
	autoPlay capture cellPadding cellSpacing challenge charSet checked cite classID
	className cols colSpan content contentEditable contextMenu controls controlsList
	coords crossOrigin data dateTime decoding default defer dir disabled
	disablePictureInPicture disableRemotePlayback download draggable encType
	enterKeyHint fetchpriority fetchPriority form formAction formEncType formMethod
	formNoValidate formTarget frameBorder headers height hidden high href hrefLang
	htmlFor httpEquiv id inputMode integrity is keyParams keyType kind label lang
	list loading loop low marginHeight marginWidth max maxLength media mediaGroup
	method min minLength multiple muted name nonce noValidate open optimum pattern
	placeholder playsInline popover popoverTarget popoverTargetAction poster
	preload profile radioGroup readOnly referrerPolicy rel required reversed role
	rows rowSpan sandbox scope scoped scrolling seamless selected shape size sizes
	slot span spellCheck src srcDoc srcLang srcSet start step style summary
	tabIndex target title translate type useMap value width wmode wrap about
	datatype inlist prefix property resource typeof vocab autoCapitalize
	autoCorrect autoSave color incremental fallback inert itemProp itemScope
	itemType itemID itemRef on option results security unselectable`.split(/\s+/));
  var svgElementProps = new Set(`accentHeight accumulate additive alignmentBaseline allowReorder alphabetic
	amplitude arabicForm ascent attributeName attributeType autoReverse azimuth
	baseFrequency baselineShift baseProfile bbox begin bias by calcMode capHeight
	clip clipPathUnits clipPath clipRule colorInterpolation
	colorInterpolationFilters colorProfile colorRendering contentScriptType
	contentStyleType cursor cx cy d decelerate descent diffuseConstant direction
	display divisor dominantBaseline dur dx dy edgeMode elevation enableBackground
	end exponent externalResourcesRequired fill fillOpacity fillRule filter
	filterRes filterUnits floodColor floodOpacity focusable fontFamily fontSize
	fontSizeAdjust fontStretch fontStyle fontVariant fontWeight format from fr fx
	fy g1 g2 glyphName glyphOrientationHorizontal glyphOrientationVertical
	glyphRef gradientTransform gradientUnits hanging horizAdvX horizOriginX
	ideographic imageRendering in in2 intercept k k1 k2 k3 k4 kernelMatrix
	kernelUnitLength kerning keyPoints keySplines keyTimes lengthAdjust
	letterSpacing lightingColor limitingConeAngle local markerEnd markerMid
	markerStart markerHeight markerUnits markerWidth mask maskContentUnits
	maskUnits mathematical mode numOctaves offset opacity operator order orient
	orientation origin overflow overlinePosition overlineThickness panose1
	paintOrder pathLength patternContentUnits patternTransform patternUnits
	pointerEvents points pointsAtX pointsAtY pointsAtZ preserveAlpha
	preserveAspectRatio primitiveUnits r radius refX refY renderingIntent
	repeatCount repeatDur requiredExtensions requiredFeatures restart result rotate
	rx ry scale seed shapeRendering slope spacing specularConstant
	specularExponent speed spreadMethod startOffset stdDeviation stemh stemv
	stitchTiles stopColor stopOpacity strikethroughPosition strikethroughThickness
	string stroke strokeDasharray strokeDashoffset strokeLinecap strokeLinejoin
	strokeMiterlimit strokeOpacity strokeWidth surfaceScale systemLanguage
	tableValues targetX targetY textAnchor textDecoration textRendering textLength
	to transform u1 u2 underlinePosition underlineThickness unicode unicodeBidi
	unicodeRange unitsPerEm vAlphabetic vHanging vIdeographic vMathematical values
	vectorEffect version vertAdvY vertOriginX vertOriginY viewBox viewTarget
	visibility widths wordSpacing writingMode x xHeight x1 x2 xChannelSelector
	xlinkActuate xlinkArcrole xlinkHref xlinkRole xlinkShow xlinkTitle xlinkType
	xmlBase xmlns xmlnsXlink xmlLang xmlSpace y y1 y2 yChannelSelector z
	zoomAndPan`.split(/\s+/));
  var compatElementProps = /* @__PURE__ */ new Set(["autofocus", "class", "for"]);
  function isValidIntrinsicElementProp(prop, element) {
    if (customAttributeRegExp.test(prop) || eventHandlerRegExp.test(prop)) {
      return true;
    }
    if (baseElementProps.has(prop) || compatElementProps.has(prop)) {
      return true;
    }
    return svgElementNames.has(element) && svgElementProps.has(prop);
  }
  function filterIntrinsicElementProps(props, element) {
    return Object.fromEntries(Object.entries(props).filter(([prop]) => isValidIntrinsicElementProp(prop, element)));
  }
  function UnforwardedPolymorphicElement({
    as,
    ...props
  }, ref) {
    const Element2 = as || "div";
    const forwardedProps = typeof Element2 === "string" ? filterIntrinsicElementProps(props, Element2) : props;
    return /* @__PURE__ */ (0, import_jsx_runtime46.jsx)(Element2, {
      ref,
      ...forwardedProps
    });
  }
  var PolymorphicElement = (0, import_element17.forwardRef)(UnforwardedPolymorphicElement);

  // packages/components/build-module/view/component.mjs
  var import_jsx_runtime47 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedView({
    css: css3,
    ...restProps
  }, ref) {
    void css3;
    return /* @__PURE__ */ (0, import_jsx_runtime47.jsx)(PolymorphicElement, {
      ref,
      ...restProps
    });
  }
  var View = Object.assign((0, import_element18.forwardRef)(UnforwardedView), {
    selector: ".components-view"
  });
  var component_default = View;

  // packages/components/build-module/visually-hidden/component.mjs
  var import_jsx_runtime48 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedVisuallyHidden(props, forwardedRef) {
    const {
      style: styleProp,
      ...contextProps
    } = useContextSystem(props, "VisuallyHidden");
    return /* @__PURE__ */ (0, import_jsx_runtime48.jsx)(component_default, {
      ref: forwardedRef,
      ...contextProps,
      "data-visually-hidden": "",
      style: {
        ...visuallyHidden,
        ...styleProp || {}
      }
    });
  }
  var VisuallyHidden3 = contextConnect(UnconnectedVisuallyHidden, "VisuallyHidden");
  var component_default2 = VisuallyHidden3;

  // packages/components/build-module/alignment-matrix-control/utils.mjs
  var import_i18n3 = __toESM(require_i18n(), 1);
  var GRID = [["top left", "top center", "top right"], ["center left", "center center", "center right"], ["bottom left", "bottom center", "bottom right"]];
  var ALIGNMENT_LABEL = {
    "top left": (0, import_i18n3.__)("Top Left"),
    "top center": (0, import_i18n3.__)("Top Center"),
    "top right": (0, import_i18n3.__)("Top Right"),
    "center left": (0, import_i18n3.__)("Center Left"),
    "center center": (0, import_i18n3.__)("Center"),
    center: (0, import_i18n3.__)("Center"),
    "center right": (0, import_i18n3.__)("Center Right"),
    "bottom left": (0, import_i18n3.__)("Bottom Left"),
    "bottom center": (0, import_i18n3.__)("Bottom Center"),
    "bottom right": (0, import_i18n3.__)("Bottom Right")
  };
  var ALIGNMENTS = GRID.flat();
  function normalize(value) {
    const normalized = value === "center" ? "center center" : value;
    const transformed = normalized?.replace("-", " ");
    return ALIGNMENTS.includes(transformed) ? transformed : void 0;
  }
  function getItemId(prefixId, value) {
    const normalized = normalize(value);
    if (!normalized) {
      return;
    }
    const id3 = normalized.replace(" ", "-");
    return `${prefixId}-${id3}`;
  }
  function getItemValue(prefixId, id3) {
    const value = id3?.replace(prefixId + "-", "");
    return normalize(value);
  }
  function getAlignmentIndex(alignment = "center") {
    const normalized = normalize(alignment);
    if (!normalized) {
      return void 0;
    }
    const index2 = ALIGNMENTS.indexOf(normalized);
    return index2 > -1 ? index2 : void 0;
  }

  // packages/components/build-module/alignment-matrix-control/cell.mjs
  var import_jsx_runtime49 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE = "data-wp-hash";
  function getRuntime() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument(targetDocument) {
    const runtime = getRuntime();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle(hash2, css3) {
    const runtime = getRuntime();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle("0c5e50ec66", "._02e2af5803bf5bda__grid-container{aspect-ratio:1;border:1px solid transparent;border-radius:4px;box-sizing:border-box;cursor:var(--wpds-cursor-control,pointer);direction:ltr;display:grid;grid-template-columns:repeat(3,1fr);grid-template-rows:repeat(3,1fr);outline:none}.c421f8ed08c23077__grid-row{box-sizing:border-box;display:grid;grid-column:1/-1;grid-template-columns:repeat(3,1fr)}._3af769f755097fdb__cell{align-items:center;appearance:none;border:none;box-sizing:border-box;display:flex;justify-content:center;margin:0;outline:none;padding:0;position:relative}._37ef12d4fb6d6131__point{aspect-ratio:1;border:3px solid;box-sizing:border-box;color:var(--wp-components-color-gray-400,var(--wpds-color-stroke-interactive-neutral,#8d8d8d));contain:strict;display:block;margin:auto;width:6px}._3af769f755097fdb__cell[data-active-item] ._37ef12d4fb6d6131__point{color:var(--wp-components-color-foreground,var(--wpds-color-foreground-content-neutral,#1e1e1e));transform:scale(1.6666666667)}._3af769f755097fdb__cell:not([data-active-item]):hover ._37ef12d4fb6d6131__point{color:var(--wp-components-color-accent,var(--wp-admin-theme-color,#3858e9))}._3af769f755097fdb__cell[data-focus-visible] ._37ef12d4fb6d6131__point{outline:1px solid var(--wp-components-color-accent,var(--wp-admin-theme-color,#3858e9));outline-offset:1px}@media not (prefers-reduced-motion){._37ef12d4fb6d6131__point{transition-duration:.12s;transition-property:color,transform;transition-timing-function:linear}}");
  }
  var style_module_default = { "grid-container": "_02e2af5803bf5bda__grid-container", "grid-row": "c421f8ed08c23077__grid-row", "cell": "_3af769f755097fdb__cell", "point": "_37ef12d4fb6d6131__point" };
  function Cell({
    id: id3,
    value,
    ...props
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime49.jsx)(tooltip_default, {
      text: ALIGNMENT_LABEL[value],
      children: /* @__PURE__ */ (0, import_jsx_runtime49.jsxs)(Composite22.Item, {
        id: id3,
        render: /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("span", {
          ...props,
          className: clsx_default(style_module_default.cell, props.className),
          role: "gridcell"
        }),
        children: [/* @__PURE__ */ (0, import_jsx_runtime49.jsx)(component_default2, {
          children: value
        }), /* @__PURE__ */ (0, import_jsx_runtime49.jsx)("span", {
          className: style_module_default.point,
          role: "presentation"
        })]
      })
    });
  }

  // packages/components/build-module/alignment-matrix-control/icon.mjs
  var import_primitives = __toESM(require_primitives(), 1);
  var import_jsx_runtime50 = __toESM(require_jsx_runtime(), 1);
  var BASE_SIZE = 24;
  var GRID_CELL_SIZE = 7;
  var GRID_PADDING = (BASE_SIZE - 3 * GRID_CELL_SIZE) / 2;
  var DOT_SIZE = 2;
  var DOT_SIZE_SELECTED = 4;
  function AlignmentMatrixControlIcon({
    className: className2,
    disablePointerEvents = true,
    size: size4,
    width,
    height,
    style: style2 = {},
    value = "center",
    ...props
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(import_primitives.SVG, {
      xmlns: "http://www.w3.org/2000/svg",
      viewBox: `0 0 ${BASE_SIZE} ${BASE_SIZE}`,
      width: size4 ?? width ?? BASE_SIZE,
      height: size4 ?? height ?? BASE_SIZE,
      role: "presentation",
      className: clsx_default("component-alignment-matrix-control-icon", className2),
      style: {
        pointerEvents: disablePointerEvents ? "none" : void 0,
        ...style2
      },
      ...props,
      children: ALIGNMENTS.map((align, index2) => {
        const dotSize = getAlignmentIndex(value) === index2 ? DOT_SIZE_SELECTED : DOT_SIZE;
        return /* @__PURE__ */ (0, import_jsx_runtime50.jsx)(import_primitives.Rect, {
          x: GRID_PADDING + index2 % 3 * GRID_CELL_SIZE + (GRID_CELL_SIZE - dotSize) / 2,
          y: GRID_PADDING + Math.floor(index2 / 3) * GRID_CELL_SIZE + (GRID_CELL_SIZE - dotSize) / 2,
          width: dotSize,
          height: dotSize,
          fill: "currentColor"
        }, align);
      })
    });
  }
  var icon_default = AlignmentMatrixControlIcon;

  // packages/components/build-module/alignment-matrix-control/index.mjs
  var import_jsx_runtime51 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE2 = "data-wp-hash";
  function getRuntime2() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument2(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash2(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE2}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE2) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle2(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime2();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash2(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE2, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument2(targetDocument) {
    const runtime = getRuntime2();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle2(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle2(hash2, css3) {
    const runtime = getRuntime2();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle2(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle2("0c5e50ec66", "._02e2af5803bf5bda__grid-container{aspect-ratio:1;border:1px solid transparent;border-radius:4px;box-sizing:border-box;cursor:var(--wpds-cursor-control,pointer);direction:ltr;display:grid;grid-template-columns:repeat(3,1fr);grid-template-rows:repeat(3,1fr);outline:none}.c421f8ed08c23077__grid-row{box-sizing:border-box;display:grid;grid-column:1/-1;grid-template-columns:repeat(3,1fr)}._3af769f755097fdb__cell{align-items:center;appearance:none;border:none;box-sizing:border-box;display:flex;justify-content:center;margin:0;outline:none;padding:0;position:relative}._37ef12d4fb6d6131__point{aspect-ratio:1;border:3px solid;box-sizing:border-box;color:var(--wp-components-color-gray-400,var(--wpds-color-stroke-interactive-neutral,#8d8d8d));contain:strict;display:block;margin:auto;width:6px}._3af769f755097fdb__cell[data-active-item] ._37ef12d4fb6d6131__point{color:var(--wp-components-color-foreground,var(--wpds-color-foreground-content-neutral,#1e1e1e));transform:scale(1.6666666667)}._3af769f755097fdb__cell:not([data-active-item]):hover ._37ef12d4fb6d6131__point{color:var(--wp-components-color-accent,var(--wp-admin-theme-color,#3858e9))}._3af769f755097fdb__cell[data-focus-visible] ._37ef12d4fb6d6131__point{outline:1px solid var(--wp-components-color-accent,var(--wp-admin-theme-color,#3858e9));outline-offset:1px}@media not (prefers-reduced-motion){._37ef12d4fb6d6131__point{transition-duration:.12s;transition-property:color,transform;transition-timing-function:linear}}");
  }
  var style_module_default2 = { "grid-container": "_02e2af5803bf5bda__grid-container", "grid-row": "c421f8ed08c23077__grid-row", "cell": "_3af769f755097fdb__cell", "point": "_37ef12d4fb6d6131__point" };
  function UnforwardedAlignmentMatrixControl({
    className: className2,
    id: id3,
    label = (0, import_i18n4.__)("Alignment Matrix Control"),
    defaultValue: defaultValue2 = "center center",
    value,
    onChange,
    width = 92,
    ...props
  }) {
    const baseId = (0, import_compose2.useInstanceId)(UnforwardedAlignmentMatrixControl, "alignment-matrix-control", id3);
    const setActiveId = (0, import_element19.useCallback)((nextActiveId) => {
      const nextValue = getItemValue(baseId, nextActiveId);
      if (nextValue) {
        onChange?.(nextValue);
      }
    }, [baseId, onChange]);
    const classes = clsx_default("component-alignment-matrix-control", style_module_default2["grid-container"], className2);
    return /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(Composite22, {
      defaultActiveId: getItemId(baseId, defaultValue2),
      activeId: getItemId(baseId, value),
      setActiveId,
      rtl: (0, import_i18n4.isRTL)(),
      render: /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("div", {
        ...props,
        className: classes,
        "aria-label": label,
        id: baseId,
        role: "grid",
        style: {
          width: `${width}px`
        }
      }),
      children: GRID.map((cells, index2) => /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(Composite22.Row, {
        render: /* @__PURE__ */ (0, import_jsx_runtime51.jsx)("div", {
          className: style_module_default2["grid-row"],
          role: "row"
        }),
        children: cells.map((cell) => /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(Cell, {
          id: getItemId(baseId, cell),
          value: cell
        }, cell))
      }, index2))
    });
  }
  var AlignmentMatrixControl = Object.assign(UnforwardedAlignmentMatrixControl, {
    /**
     * Render an alignment matrix as an icon.
     *
     * ```jsx
     * import { AlignmentMatrixControl } from '@wordpress/components';
     *
     * <Icon icon={<AlignmentMatrixControl.Icon value="top left" />} />
     * ```
     */
    Icon: Object.assign(icon_default, {
      displayName: "AlignmentMatrixControl.Icon"
    })
  });
  var alignment_matrix_control_default = AlignmentMatrixControl;

  // packages/components/build-module/animate/index.mjs
  function getDefaultOrigin(type) {
    return type === "appear" ? "top" : "left";
  }
  function getAnimateClassName(options2) {
    if (options2.type === "loading") {
      return "components-animate__loading";
    }
    const {
      type,
      origin = getDefaultOrigin(type)
    } = options2;
    if (type === "appear") {
      const [yAxis, xAxis = "center"] = origin.split(" ");
      return clsx_default("components-animate__appear", {
        ["is-from-" + xAxis]: xAxis !== "center",
        ["is-from-" + yAxis]: yAxis !== "middle"
      });
    }
    if (type === "slide-in") {
      return clsx_default("components-animate__slide-in", "is-from-" + origin);
    }
    return void 0;
  }
  function Animate({
    type,
    options: options2 = {},
    children
  }) {
    return children({
      className: getAnimateClassName({
        type,
        ...options2
      })
    });
  }
  var animate_default = Animate;

  // packages/components/build-module/angle-picker-control/index.mjs
  var import_element37 = __toESM(require_element(), 1);
  var import_i18n6 = __toESM(require_i18n(), 1);

  // packages/components/build-module/flex/flex/hook.mjs
  var import_deprecated2 = __toESM(require_deprecated(), 1);

  // packages/components/build-module/utils/use-responsive-value.mjs
  var import_element20 = __toESM(require_element(), 1);
  var breakpoints = ["40em", "52em", "64em"];
  var useBreakpointIndex = (options2 = {}) => {
    const {
      defaultIndex = 0
    } = options2;
    if (typeof defaultIndex !== "number") {
      throw new TypeError(`Default breakpoint index should be a number. Got: ${defaultIndex}, ${typeof defaultIndex}`);
    } else if (defaultIndex < 0 || defaultIndex > breakpoints.length - 1) {
      throw new RangeError(`Default breakpoint index out of range. Theme has ${breakpoints.length} breakpoints, got index ${defaultIndex}`);
    }
    const [value, setValue] = (0, import_element20.useState)(defaultIndex);
    (0, import_element20.useEffect)(() => {
      const getIndex = () => breakpoints.filter((bp) => {
        return typeof window !== "undefined" ? window.matchMedia(`screen and (min-width: ${bp})`).matches : false;
      }).length;
      const onResize = () => {
        const newValue = getIndex();
        if (value !== newValue) {
          setValue(newValue);
        }
      };
      onResize();
      if (typeof window !== "undefined") {
        window.addEventListener("resize", onResize);
      }
      return () => {
        if (typeof window !== "undefined") {
          window.removeEventListener("resize", onResize);
        }
      };
    }, [value]);
    return value;
  };
  function useResponsiveValue(values, options2 = {}) {
    const index2 = useBreakpointIndex(options2);
    if (!Array.isArray(values) && typeof values !== "function") {
      return values;
    }
    const array = values || [];
    return array[index2 >= array.length ? array.length - 1 : index2];
  }

  // packages/components/build-module/utils/space.mjs
  var GRID_BASE = "4px";
  function space(value) {
    if (typeof value === "undefined") {
      return void 0;
    }
    if (!value) {
      return "0";
    }
    const asInt = typeof value === "number" ? value : Number(value);
    if (typeof window !== "undefined" && window.CSS?.supports?.("margin", value.toString()) || Number.isNaN(asInt)) {
      return value.toString();
    }
    return `calc(${GRID_BASE} * ${value})`;
  }

  // packages/components/build-module/flex/flex/hook.mjs
  var STYLE_HASH_ATTRIBUTE3 = "data-wp-hash";
  function getRuntime3() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument3(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash3(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE3}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE3) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle3(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime3();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash3(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE3, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument3(targetDocument) {
    const runtime = getRuntime3();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle3(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle3(hash2, css3) {
    const runtime = getRuntime3();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle3(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle3("1931a27616", ".e518617e7c3a18e7__flex{align-items:var(--wp-components-flex-align);display:flex;flex-direction:var(--wp-components-flex-direction);flex-wrap:var(--wp-components-flex-wrap);gap:var(--wp-components-flex-gap);justify-content:var(--wp-components-flex-justify)}.e4a76957e0b12292__expanded-column{height:100%}.cc39999a5fb580d4__expanded-row{width:100%}.bc09d0edcc10c304__item{display:var(--wp-components-flex-item-display);max-height:100%;max-width:100%;min-height:0;min-width:0}.c184ec8e81027f31__block{flex:1}.f9694ed4faabfc82__items-column>*{min-height:0}._3896336788892095__items-row>*{min-width:0}");
  }
  var style_module_default3 = { "flex": "e518617e7c3a18e7__flex", "expanded-column": "e4a76957e0b12292__expanded-column", "expanded-row": "cc39999a5fb580d4__expanded-row", "item": "bc09d0edcc10c304__item", "block": "c184ec8e81027f31__block", "items-column": "f9694ed4faabfc82__items-column", "items-row": "_3896336788892095__items-row" };
  function useDeprecatedProps(props) {
    const {
      isReversed,
      ...otherProps
    } = props;
    if (typeof isReversed !== "undefined") {
      (0, import_deprecated2.default)("Flex isReversed", {
        alternative: 'Flex direction="row-reverse" or "column-reverse"',
        since: "5.9"
      });
      return {
        ...otherProps,
        direction: isReversed ? "row-reverse" : "row"
      };
    }
    return otherProps;
  }
  function useFlex(props) {
    const {
      align,
      className: className2,
      direction: directionProp = "row",
      expanded = true,
      gap = 2,
      justify = "space-between",
      style: style2,
      wrap = false,
      ...otherProps
    } = useContextSystem(useDeprecatedProps(props), "Flex");
    const directionAsArray = Array.isArray(directionProp) ? directionProp : [directionProp];
    const direction = useResponsiveValue(directionAsArray);
    const isColumn = typeof direction === "string" && !!direction.includes("column");
    const flexStyle = {
      ...style2,
      "--wp-components-flex-align": align ?? (isColumn ? "normal" : "center"),
      "--wp-components-flex-direction": direction,
      "--wp-components-flex-wrap": wrap ? "wrap" : "nowrap",
      "--wp-components-flex-gap": space(gap),
      "--wp-components-flex-justify": justify
    };
    return {
      ...otherProps,
      className: clsx_default(style_module_default3.flex, isColumn ? style_module_default3["items-column"] : style_module_default3["items-row"], expanded && (isColumn ? style_module_default3["expanded-column"] : style_module_default3["expanded-row"]), className2),
      style: flexStyle,
      isColumn
    };
  }

  // packages/components/build-module/flex/context.mjs
  var import_element21 = __toESM(require_element(), 1);
  var FlexContext = (0, import_element21.createContext)({
    flexItemDisplay: void 0
  });
  var useFlexContext = () => (0, import_element21.useContext)(FlexContext);

  // packages/components/build-module/flex/flex/component.mjs
  var import_jsx_runtime52 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedFlex(props, forwardedRef) {
    const {
      children,
      isColumn,
      ...otherProps
    } = useFlex(props);
    return /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(FlexContext.Provider, {
      value: {
        flexItemDisplay: isColumn ? "block" : void 0
      },
      children: /* @__PURE__ */ (0, import_jsx_runtime52.jsx)(component_default, {
        ...otherProps,
        ref: forwardedRef,
        children
      })
    });
  }
  var Flex = contextConnect(UnconnectedFlex, "Flex");
  var component_default3 = Flex;

  // packages/components/build-module/flex/flex-item/hook.mjs
  var STYLE_HASH_ATTRIBUTE4 = "data-wp-hash";
  function getRuntime4() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument4(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash4(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE4}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE4) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle4(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime4();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash4(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE4, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument4(targetDocument) {
    const runtime = getRuntime4();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle4(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle4(hash2, css3) {
    const runtime = getRuntime4();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle4(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle4("1931a27616", ".e518617e7c3a18e7__flex{align-items:var(--wp-components-flex-align);display:flex;flex-direction:var(--wp-components-flex-direction);flex-wrap:var(--wp-components-flex-wrap);gap:var(--wp-components-flex-gap);justify-content:var(--wp-components-flex-justify)}.e4a76957e0b12292__expanded-column{height:100%}.cc39999a5fb580d4__expanded-row{width:100%}.bc09d0edcc10c304__item{display:var(--wp-components-flex-item-display);max-height:100%;max-width:100%;min-height:0;min-width:0}.c184ec8e81027f31__block{flex:1}.f9694ed4faabfc82__items-column>*{min-height:0}._3896336788892095__items-row>*{min-width:0}");
  }
  var style_module_default4 = { "flex": "e518617e7c3a18e7__flex", "expanded-column": "e4a76957e0b12292__expanded-column", "expanded-row": "cc39999a5fb580d4__expanded-row", "item": "bc09d0edcc10c304__item", "block": "c184ec8e81027f31__block", "items-column": "f9694ed4faabfc82__items-column", "items-row": "_3896336788892095__items-row" };
  function useFlexItem(props) {
    const {
      className: className2,
      display: displayProp,
      isBlock = false,
      style: style2,
      ...otherProps
    } = useContextSystem(props, "FlexItem");
    const contextDisplay = useFlexContext().flexItemDisplay;
    const display = displayProp || contextDisplay;
    const itemStyle = {
      ...style2,
      "--wp-components-flex-item-display": display || "block"
    };
    return {
      ...otherProps,
      className: clsx_default(style_module_default4.item, isBlock && style_module_default4.block, className2),
      style: itemStyle
    };
  }

  // packages/components/build-module/flex/flex-item/component.mjs
  var import_jsx_runtime53 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedFlexItem(props, forwardedRef) {
    const flexItemProps = useFlexItem(props);
    return /* @__PURE__ */ (0, import_jsx_runtime53.jsx)(component_default, {
      ...flexItemProps,
      ref: forwardedRef
    });
  }
  var FlexItem = contextConnect(UnconnectedFlexItem, "FlexItem");
  var component_default4 = FlexItem;

  // packages/components/build-module/flex/flex-block/hook.mjs
  function useFlexBlock(props) {
    const otherProps = useContextSystem(props, "FlexBlock");
    const flexItemProps = useFlexItem({
      isBlock: true,
      ...otherProps
    });
    return flexItemProps;
  }

  // packages/components/build-module/flex/flex-block/component.mjs
  var import_jsx_runtime54 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedFlexBlock(props, forwardedRef) {
    const flexBlockProps = useFlexBlock(props);
    return /* @__PURE__ */ (0, import_jsx_runtime54.jsx)(component_default, {
      ...flexBlockProps,
      ref: forwardedRef
    });
  }
  var FlexBlock = contextConnect(UnconnectedFlexBlock, "FlexBlock");
  var component_default5 = FlexBlock;

  // packages/components/build-module/spacer/hook.mjs
  var STYLE_HASH_ATTRIBUTE5 = "data-wp-hash";
  function getRuntime5() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument5(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash5(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE5}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE5) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle5(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime5();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash5(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE5, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument5(targetDocument) {
    const runtime = getRuntime5();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle5(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle5(hash2, css3) {
    const runtime = getRuntime5();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle5(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle5("f61ad86e00", "._91de5852bdb7a4b8__spacer{--wp-components-spacer-margin:initial;--wp-components-spacer-margin-block-start:initial;--wp-components-spacer-margin-block-end:initial;--wp-components-spacer-margin-inline-start:initial;--wp-components-spacer-margin-inline-end:initial;--wp-components-spacer-padding:initial;--wp-components-spacer-padding-block-start:initial;--wp-components-spacer-padding-block-end:initial;--wp-components-spacer-padding-inline-start:initial;--wp-components-spacer-padding-inline-end:initial;margin:var(--wp-components-spacer-margin);margin-block-end:var(--wp-components-spacer-margin-block-end,var(--wp-components-spacer-margin));margin-block-start:var(--wp-components-spacer-margin-block-start,var(--wp-components-spacer-margin));margin-inline-end:var(--wp-components-spacer-margin-inline-end,var(--wp-components-spacer-margin));margin-inline-start:var(--wp-components-spacer-margin-inline-start,var(--wp-components-spacer-margin));padding:var(--wp-components-spacer-padding);padding-block-end:var(--wp-components-spacer-padding-block-end,var(--wp-components-spacer-padding));padding-block-start:var(--wp-components-spacer-padding-block-start,var(--wp-components-spacer-padding));padding-inline-end:var(--wp-components-spacer-padding-inline-end,var(--wp-components-spacer-padding));padding-inline-start:var(--wp-components-spacer-padding-inline-start,var(--wp-components-spacer-padding))}");
  }
  var style_module_default5 = { "spacer": "_91de5852bdb7a4b8__spacer" };
  function isDefined(o4) {
    return typeof o4 !== "undefined" && o4 !== null;
  }
  function useSpacer(props) {
    const {
      className: className2,
      margin,
      marginBottom = 2,
      marginLeft,
      marginRight,
      marginTop,
      marginX,
      marginY,
      padding: padding2,
      paddingBottom,
      paddingLeft,
      paddingRight,
      paddingTop,
      paddingX,
      paddingY: paddingY2,
      style: style2,
      ...otherProps
    } = useContextSystem(props, "Spacer");
    const spacingStyle = {};
    if (isDefined(margin)) {
      spacingStyle["--wp-components-spacer-margin"] = space(margin);
    }
    if (isDefined(marginY)) {
      spacingStyle["--wp-components-spacer-margin-block-start"] = space(marginY);
      spacingStyle["--wp-components-spacer-margin-block-end"] = space(marginY);
    }
    if (isDefined(marginX)) {
      spacingStyle["--wp-components-spacer-margin-inline-start"] = space(marginX);
      spacingStyle["--wp-components-spacer-margin-inline-end"] = space(marginX);
    }
    if (isDefined(marginTop)) {
      spacingStyle["--wp-components-spacer-margin-block-start"] = space(marginTop);
    }
    if (isDefined(marginBottom)) {
      spacingStyle["--wp-components-spacer-margin-block-end"] = space(marginBottom);
    }
    if (isDefined(marginLeft)) {
      spacingStyle["--wp-components-spacer-margin-inline-start"] = space(marginLeft);
    }
    if (isDefined(marginRight)) {
      spacingStyle["--wp-components-spacer-margin-inline-end"] = space(marginRight);
    }
    if (isDefined(padding2)) {
      spacingStyle["--wp-components-spacer-padding"] = space(padding2);
    }
    if (isDefined(paddingY2)) {
      spacingStyle["--wp-components-spacer-padding-block-start"] = space(paddingY2);
      spacingStyle["--wp-components-spacer-padding-block-end"] = space(paddingY2);
    }
    if (isDefined(paddingX)) {
      spacingStyle["--wp-components-spacer-padding-inline-start"] = space(paddingX);
      spacingStyle["--wp-components-spacer-padding-inline-end"] = space(paddingX);
    }
    if (isDefined(paddingTop)) {
      spacingStyle["--wp-components-spacer-padding-block-start"] = space(paddingTop);
    }
    if (isDefined(paddingBottom)) {
      spacingStyle["--wp-components-spacer-padding-block-end"] = space(paddingBottom);
    }
    if (isDefined(paddingLeft)) {
      spacingStyle["--wp-components-spacer-padding-inline-start"] = space(paddingLeft);
    }
    if (isDefined(paddingRight)) {
      spacingStyle["--wp-components-spacer-padding-inline-end"] = space(paddingRight);
    }
    const spacerStyle = {
      ...spacingStyle,
      ...style2
    };
    return {
      ...otherProps,
      className: clsx_default(style_module_default5.spacer, className2),
      style: spacerStyle
    };
  }

  // packages/components/build-module/spacer/component.mjs
  var import_jsx_runtime55 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedSpacer(props, forwardedRef) {
    const spacerProps = useSpacer(props);
    return /* @__PURE__ */ (0, import_jsx_runtime55.jsx)(component_default, {
      ...spacerProps,
      ref: forwardedRef
    });
  }
  var Spacer = contextConnect(UnconnectedSpacer, "Spacer");
  var component_default6 = Spacer;

  // packages/components/build-module/number-control/index.mjs
  var import_element35 = __toESM(require_element(), 1);
  var import_i18n5 = __toESM(require_i18n(), 1);

  // packages/icons/build-module/icon/index.mjs
  var import_element22 = __toESM(require_element(), 1);
  var icon_default2 = (0, import_element22.forwardRef)(
    ({ icon, size: size4 = 24, ...props }, ref) => {
      return (0, import_element22.cloneElement)(icon, {
        width: size4,
        height: size4,
        ...props,
        ref
      });
    }
  );

  // packages/icons/build-module/library/arrow-left.mjs
  var import_primitives2 = __toESM(require_primitives(), 1);
  var import_jsx_runtime56 = __toESM(require_jsx_runtime(), 1);
  var arrow_left_default = /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(import_primitives2.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime56.jsx)(import_primitives2.Path, { d: "M20 11.2H6.8l3.7-3.7-1-1L3.9 12l5.6 5.5 1-1-3.7-3.7H20z" }) });

  // packages/icons/build-module/library/arrow-right.mjs
  var import_primitives3 = __toESM(require_primitives(), 1);
  var import_jsx_runtime57 = __toESM(require_jsx_runtime(), 1);
  var arrow_right_default = /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(import_primitives3.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime57.jsx)(import_primitives3.Path, { d: "m14.5 6.5-1 1 3.7 3.7H4v1.6h13.2l-3.7 3.7 1 1 5.6-5.5z" }) });

  // packages/icons/build-module/library/caution.mjs
  var import_primitives4 = __toESM(require_primitives(), 1);
  var import_jsx_runtime58 = __toESM(require_jsx_runtime(), 1);
  var caution_default = /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(import_primitives4.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime58.jsx)(import_primitives4.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M5.5 12a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0ZM12 4a8 8 0 1 0 0 16 8 8 0 0 0 0-16Zm-.75 12v-1.5h1.5V16h-1.5Zm0-8v5h1.5V8h-1.5Z" }) });

  // packages/icons/build-module/library/check.mjs
  var import_primitives5 = __toESM(require_primitives(), 1);
  var import_jsx_runtime59 = __toESM(require_jsx_runtime(), 1);
  var check_default = /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_primitives5.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime59.jsx)(import_primitives5.Path, { d: "M16.5 7.5 10 13.9l-2.5-2.4-1 1 3.5 3.6 7.5-7.6z" }) });

  // packages/icons/build-module/library/chevron-down.mjs
  var import_primitives6 = __toESM(require_primitives(), 1);
  var import_jsx_runtime60 = __toESM(require_jsx_runtime(), 1);
  var chevron_down_default = /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(import_primitives6.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime60.jsx)(import_primitives6.Path, { d: "M17.5 11.6L12 16l-5.5-4.4.9-1.2L12 14l4.5-3.6 1 1.2z" }) });

  // packages/icons/build-module/library/chevron-right-small.mjs
  var import_primitives7 = __toESM(require_primitives(), 1);
  var import_jsx_runtime61 = __toESM(require_jsx_runtime(), 1);
  var chevron_right_small_default = /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(import_primitives7.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime61.jsx)(import_primitives7.Path, { d: "M10.8622 8.04053L14.2805 12.0286L10.8622 16.0167L9.72327 15.0405L12.3049 12.0286L9.72327 9.01672L10.8622 8.04053Z" }) });

  // packages/icons/build-module/library/chevron-right.mjs
  var import_primitives8 = __toESM(require_primitives(), 1);
  var import_jsx_runtime62 = __toESM(require_jsx_runtime(), 1);
  var chevron_right_default = /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(import_primitives8.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime62.jsx)(import_primitives8.Path, { d: "M10.6 6L9.4 7l4.6 5-4.6 5 1.2 1 5.4-6z" }) });

  // packages/icons/build-module/library/chevron-up.mjs
  var import_primitives9 = __toESM(require_primitives(), 1);
  var import_jsx_runtime63 = __toESM(require_jsx_runtime(), 1);
  var chevron_up_default = /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(import_primitives9.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime63.jsx)(import_primitives9.Path, { d: "M6.5 12.4L12 8l5.5 4.4-.9 1.2L12 10l-4.5 3.6-1-1.2z" }) });

  // packages/icons/build-module/library/close-small.mjs
  var import_primitives10 = __toESM(require_primitives(), 1);
  var import_jsx_runtime64 = __toESM(require_jsx_runtime(), 1);
  var close_small_default = /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(import_primitives10.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime64.jsx)(import_primitives10.Path, { d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z" }) });

  // packages/icons/build-module/library/close.mjs
  var import_primitives11 = __toESM(require_primitives(), 1);
  var import_jsx_runtime65 = __toESM(require_jsx_runtime(), 1);
  var close_default = /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(import_primitives11.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime65.jsx)(import_primitives11.Path, { d: "m13.06 12 6.47-6.47-1.06-1.06L12 10.94 5.53 4.47 4.47 5.53 10.94 12l-6.47 6.47 1.06 1.06L12 13.06l6.47 6.47 1.06-1.06L13.06 12Z" }) });

  // packages/icons/build-module/library/copy.mjs
  var import_primitives12 = __toESM(require_primitives(), 1);
  var import_jsx_runtime66 = __toESM(require_jsx_runtime(), 1);
  var copy_default = /* @__PURE__ */ (0, import_jsx_runtime66.jsx)(import_primitives12.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime66.jsx)(import_primitives12.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M5 4.5h11a.5.5 0 0 1 .5.5v11a.5.5 0 0 1-.5.5H5a.5.5 0 0 1-.5-.5V5a.5.5 0 0 1 .5-.5ZM3 5a2 2 0 0 1 2-2h11a2 2 0 0 1 2 2v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5Zm17 3v10.75c0 .69-.56 1.25-1.25 1.25H6v1.5h12.75a2.75 2.75 0 0 0 2.75-2.75V8H20Z" }) });

  // packages/icons/build-module/library/error.mjs
  var import_primitives13 = __toESM(require_primitives(), 1);
  var import_jsx_runtime67 = __toESM(require_jsx_runtime(), 1);
  var error_default = /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(import_primitives13.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime67.jsx)(import_primitives13.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M12.218 5.377a.25.25 0 0 0-.436 0l-7.29 12.96a.25.25 0 0 0 .218.373h14.58a.25.25 0 0 0 .218-.372l-7.29-12.96Zm-1.743-.735c.669-1.19 2.381-1.19 3.05 0l7.29 12.96a1.75 1.75 0 0 1-1.525 2.608H4.71a1.75 1.75 0 0 1-1.525-2.608l7.29-12.96ZM12.75 17.46h-1.5v-1.5h1.5v1.5Zm-1.5-3h1.5v-5h-1.5v5Z" }) });

  // packages/icons/build-module/library/info.mjs
  var import_primitives14 = __toESM(require_primitives(), 1);
  var import_jsx_runtime68 = __toESM(require_jsx_runtime(), 1);
  var info_default = /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(import_primitives14.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime68.jsx)(import_primitives14.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M5.5 12a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0ZM12 4a8 8 0 1 0 0 16 8 8 0 0 0 0-16Zm.75 4v1.5h-1.5V8h1.5Zm0 8v-5h-1.5v5h1.5Z" }) });

  // packages/icons/build-module/library/line-dashed.mjs
  var import_primitives15 = __toESM(require_primitives(), 1);
  var import_jsx_runtime69 = __toESM(require_jsx_runtime(), 1);
  var line_dashed_default = /* @__PURE__ */ (0, import_jsx_runtime69.jsx)(import_primitives15.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime69.jsx)(import_primitives15.Path, { fillRule: "evenodd", d: "M5 11.25h3v1.5H5v-1.5zm5.5 0h3v1.5h-3v-1.5zm8.5 0h-3v1.5h3v-1.5z", clipRule: "evenodd" }) });

  // packages/icons/build-module/library/line-dotted.mjs
  var import_primitives16 = __toESM(require_primitives(), 1);
  var import_jsx_runtime70 = __toESM(require_jsx_runtime(), 1);
  var line_dotted_default = /* @__PURE__ */ (0, import_jsx_runtime70.jsx)(import_primitives16.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime70.jsx)(import_primitives16.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M5.25 11.25h1.5v1.5h-1.5v-1.5zm3 0h1.5v1.5h-1.5v-1.5zm4.5 0h-1.5v1.5h1.5v-1.5zm1.5 0h1.5v1.5h-1.5v-1.5zm4.5 0h-1.5v1.5h1.5v-1.5z" }) });

  // packages/icons/build-module/library/line-solid.mjs
  var import_primitives17 = __toESM(require_primitives(), 1);
  var import_jsx_runtime71 = __toESM(require_jsx_runtime(), 1);
  var line_solid_default = /* @__PURE__ */ (0, import_jsx_runtime71.jsx)(import_primitives17.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime71.jsx)(import_primitives17.Path, { d: "M5 11.25h14v1.5H5z" }) });

  // packages/icons/build-module/library/link-off.mjs
  var import_primitives18 = __toESM(require_primitives(), 1);
  var import_jsx_runtime72 = __toESM(require_jsx_runtime(), 1);
  var link_off_default = /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(import_primitives18.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime72.jsx)(import_primitives18.Path, { d: "M17.031 4.703 15.576 4l-1.56 3H14v.03l-2.324 4.47H9.5V13h1.396l-1.502 2.889h-.95a3.694 3.694 0 0 1 0-7.389H10V7H8.444a5.194 5.194 0 1 0 0 10.389h.17L7.5 19.53l1.416.719L15.049 8.5h.507a3.694 3.694 0 0 1 0 7.39H14v1.5h1.556a5.194 5.194 0 0 0 .273-10.383l1.202-2.304Z" }) });

  // packages/icons/build-module/library/link.mjs
  var import_primitives19 = __toESM(require_primitives(), 1);
  var import_jsx_runtime73 = __toESM(require_jsx_runtime(), 1);
  var link_default = /* @__PURE__ */ (0, import_jsx_runtime73.jsx)(import_primitives19.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime73.jsx)(import_primitives19.Path, { d: "M10 17.389H8.444A5.194 5.194 0 1 1 8.444 7H10v1.5H8.444a3.694 3.694 0 0 0 0 7.389H10v1.5ZM14 7h1.556a5.194 5.194 0 0 1 0 10.39H14v-1.5h1.556a3.694 3.694 0 0 0 0-7.39H14V7Zm-4.5 6h5v-1.5h-5V13Z" }) });

  // packages/icons/build-module/library/menu.mjs
  var import_primitives20 = __toESM(require_primitives(), 1);
  var import_jsx_runtime74 = __toESM(require_jsx_runtime(), 1);
  var menu_default = /* @__PURE__ */ (0, import_jsx_runtime74.jsx)(import_primitives20.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime74.jsx)(import_primitives20.Path, { d: "M5 5v1.5h14V5H5zm0 7.8h14v-1.5H5v1.5zM5 19h14v-1.5H5V19z" }) });

  // packages/icons/build-module/library/more-vertical.mjs
  var import_primitives21 = __toESM(require_primitives(), 1);
  var import_jsx_runtime75 = __toESM(require_jsx_runtime(), 1);
  var more_vertical_default = /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(import_primitives21.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime75.jsx)(import_primitives21.Path, { d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z" }) });

  // packages/icons/build-module/library/plus.mjs
  var import_primitives22 = __toESM(require_primitives(), 1);
  var import_jsx_runtime76 = __toESM(require_jsx_runtime(), 1);
  var plus_default = /* @__PURE__ */ (0, import_jsx_runtime76.jsx)(import_primitives22.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime76.jsx)(import_primitives22.Path, { d: "M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z" }) });

  // packages/icons/build-module/library/published.mjs
  var import_primitives23 = __toESM(require_primitives(), 1);
  var import_jsx_runtime77 = __toESM(require_jsx_runtime(), 1);
  var published_default = /* @__PURE__ */ (0, import_jsx_runtime77.jsx)(import_primitives23.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime77.jsx)(import_primitives23.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M12 18.5a6.5 6.5 0 1 1 0-13 6.5 6.5 0 0 1 0 13ZM4 12a8 8 0 1 1 16 0 8 8 0 0 1-16 0Zm11.53-1.47-1.06-1.06L11 12.94l-1.47-1.47-1.06 1.06L11 15.06l4.53-4.53Z" }) });

  // packages/icons/build-module/library/reset.mjs
  var import_primitives24 = __toESM(require_primitives(), 1);
  var import_jsx_runtime78 = __toESM(require_jsx_runtime(), 1);
  var reset_default = /* @__PURE__ */ (0, import_jsx_runtime78.jsx)(import_primitives24.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime78.jsx)(import_primitives24.Path, { d: "M7 11.5h10V13H7z" }) });

  // packages/icons/build-module/library/search.mjs
  var import_primitives25 = __toESM(require_primitives(), 1);
  var import_jsx_runtime79 = __toESM(require_jsx_runtime(), 1);
  var search_default = /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(import_primitives25.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime79.jsx)(import_primitives25.Path, { d: "M13 5c-3.3 0-6 2.7-6 6 0 1.4.5 2.7 1.3 3.7l-3.8 3.8 1.1 1.1 3.8-3.8c1 .8 2.3 1.3 3.7 1.3 3.3 0 6-2.7 6-6S16.3 5 13 5zm0 10.5c-2.5 0-4.5-2-4.5-4.5s2-4.5 4.5-4.5 4.5 2 4.5 4.5-2 4.5-4.5 4.5z" }) });

  // packages/icons/build-module/library/settings.mjs
  var import_primitives26 = __toESM(require_primitives(), 1);
  var import_jsx_runtime80 = __toESM(require_jsx_runtime(), 1);
  var settings_default = /* @__PURE__ */ (0, import_jsx_runtime80.jsxs)(import_primitives26.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: [
    /* @__PURE__ */ (0, import_jsx_runtime80.jsx)(import_primitives26.Path, { d: "m19 7.5h-7.628c-.3089-.87389-1.1423-1.5-2.122-1.5-.97966 0-1.81309.62611-2.12197 1.5h-2.12803v1.5h2.12803c.30888.87389 1.14231 1.5 2.12197 1.5.9797 0 1.8131-.62611 2.122-1.5h7.628z" }),
    /* @__PURE__ */ (0, import_jsx_runtime80.jsx)(import_primitives26.Path, { d: "m19 15h-2.128c-.3089-.8739-1.1423-1.5-2.122-1.5s-1.8131.6261-2.122 1.5h-7.628v1.5h7.628c.3089.8739 1.1423 1.5 2.122 1.5s1.8131-.6261 2.122-1.5h2.128z" })
  ] });

  // packages/icons/build-module/library/swatch.mjs
  var import_primitives27 = __toESM(require_primitives(), 1);
  var import_jsx_runtime81 = __toESM(require_jsx_runtime(), 1);
  var swatch_default = /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(import_primitives27.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime81.jsx)(import_primitives27.Path, { d: "M7.1 5.7 8 6.9c.4-.3.9-.6 1.5-.8l-.6-1.4c-.7.3-1.3.6-1.8 1ZM4.6 8.9l1.4.6c.2-.5.5-1 .8-1.5l-1.2-.9c-.4.6-.8 1.2-1 1.8Zm14.8 0c-.3-.7-.6-1.3-1-1.8l-1.2.9c.3.4.6.9.8 1.5l1.4-.6ZM7.1 18.3c.6.4 1.2.8 1.8 1l.6-1.4c-.5-.2-1-.5-1.5-.8l-.9 1.2ZM5.5 12v-.9h-.7l-.7-.2v2l1.5-.2v-.9Zm-.7 3h-.2c.3.7.6 1.3 1 1.9l1.2-.9c-.3-.4-.6-.9-.8-1.5l-1.2.5Zm9.7 3 .5 1.2v.2c.7-.3 1.3-.6 1.9-1l-.9-1.2c-.4.3-.9.6-1.5.8Zm-2.5.5h-.9l-.2 1.3v.2h2l-.2-1.5h-.9Zm7.9-7.5-1.5.2V13h.7l.7.2v-2ZM18 14.5c-.2.5-.5 1-.8 1.5l1.2.9c.4-.6.8-1.2 1-1.8h-.2l-1.2-.6ZM11 4.1l.2 1.5H13V4.2h-1.9ZM14.5 6c.5.2 1 .5 1.5.8l.9-1.2c-.6-.4-1.2-.8-1.8-1L14.5 6Z" }) });

  // packages/icons/build-module/library/tip.mjs
  var import_primitives28 = __toESM(require_primitives(), 1);
  var import_jsx_runtime82 = __toESM(require_jsx_runtime(), 1);
  var tip_default = /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(import_primitives28.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime82.jsx)(import_primitives28.Path, { d: "M12 15.8c-3.7 0-6.8-3-6.8-6.8s3-6.8 6.8-6.8c3.7 0 6.8 3 6.8 6.8s-3.1 6.8-6.8 6.8zm0-12C9.1 3.8 6.8 6.1 6.8 9s2.4 5.2 5.2 5.2c2.9 0 5.2-2.4 5.2-5.2S14.9 3.8 12 3.8zM8 17.5h8V19H8zM10 20.5h4V22h-4z" }) });

  // packages/icons/build-module/library/upload.mjs
  var import_primitives29 = __toESM(require_primitives(), 1);
  var import_jsx_runtime83 = __toESM(require_jsx_runtime(), 1);
  var upload_default = /* @__PURE__ */ (0, import_jsx_runtime83.jsx)(import_primitives29.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime83.jsx)(import_primitives29.Path, { d: "M18.5 15v3.5H13V6.7l4.5 4.1 1-1.1-6.2-5.8-5.8 5.8 1 1.1 4-4v11.7h-6V15H4v5h16v-5z" }) });

  // packages/components/build-module/number-control/index.mjs
  var import_compose7 = __toESM(require_compose(), 1);
  var import_deprecated4 = __toESM(require_deprecated(), 1);

  // node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js
  var React8 = __toESM(require_react());
  init_emotion_is_prop_valid_esm();
  var isDevelopment4 = false;
  var testOmitPropsOnStringTag = isPropValid;
  var testOmitPropsOnComponent = function testOmitPropsOnComponent2(key) {
    return key !== "theme";
  };
  var getDefaultShouldForwardProp = function getDefaultShouldForwardProp2(tag) {
    return typeof tag === "string" && // 96 is one less than the char code
    // for "a" so this is checking that
    // it's a lowercase character
    tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
  };
  var composeShouldForwardProps = function composeShouldForwardProps2(tag, options2, isReal) {
    var shouldForwardProp;
    if (options2) {
      var optionsShouldForwardProp = options2.shouldForwardProp;
      shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function(propName) {
        return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
      } : optionsShouldForwardProp;
    }
    if (typeof shouldForwardProp !== "function" && isReal) {
      shouldForwardProp = tag.__emotion_forwardProp;
    }
    return shouldForwardProp;
  };
  var Insertion3 = function Insertion4(_ref9) {
    var cache2 = _ref9.cache, serialized = _ref9.serialized, isStringTag = _ref9.isStringTag;
    registerStyles(cache2, serialized, isStringTag);
    useInsertionEffectAlwaysWithSyncFallback(function() {
      return insertStyles(cache2, serialized, isStringTag);
    });
    return null;
  };
  var createStyled = function createStyled2(tag, options2) {
    var isReal = tag.__emotion_real === tag;
    var baseTag = isReal && tag.__emotion_base || tag;
    var identifierName;
    var targetClassName;
    if (options2 !== void 0) {
      identifierName = options2.label;
      targetClassName = options2.target;
    }
    var shouldForwardProp = composeShouldForwardProps(tag, options2, isReal);
    var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
    var shouldUseAs = !defaultShouldForwardProp("as");
    return function() {
      var args = arguments;
      var styles3 = isReal && tag.__emotion_styles !== void 0 ? tag.__emotion_styles.slice(0) : [];
      if (identifierName !== void 0) {
        styles3.push("label:" + identifierName + ";");
      }
      if (args[0] == null || args[0].raw === void 0) {
        styles3.push.apply(styles3, args);
      } else {
        var templateStringsArr = args[0];
        styles3.push(templateStringsArr[0]);
        var len = args.length;
        var i3 = 1;
        for (; i3 < len; i3++) {
          styles3.push(args[i3], templateStringsArr[i3]);
        }
      }
      var Styled = withEmotionCache(function(props, cache2, ref) {
        var FinalTag = shouldUseAs && props.as || baseTag;
        var className2 = "";
        var classInterpolations = [];
        var mergedProps = props;
        if (props.theme == null) {
          mergedProps = {};
          for (var key in props) {
            mergedProps[key] = props[key];
          }
          mergedProps.theme = React8.useContext(ThemeContext);
        }
        if (typeof props.className === "string") {
          className2 = getRegisteredStyles(cache2.registered, classInterpolations, props.className);
        } else if (props.className != null) {
          className2 = props.className + " ";
        }
        var serialized = serializeStyles(styles3.concat(classInterpolations), cache2.registered, mergedProps);
        className2 += cache2.key + "-" + serialized.name;
        if (targetClassName !== void 0) {
          className2 += " " + targetClassName;
        }
        var finalShouldForwardProp = shouldUseAs && shouldForwardProp === void 0 ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
        var newProps = {};
        for (var _key in props) {
          if (shouldUseAs && _key === "as") continue;
          if (finalShouldForwardProp(_key)) {
            newProps[_key] = props[_key];
          }
        }
        newProps.className = className2;
        if (ref) {
          newProps.ref = ref;
        }
        return /* @__PURE__ */ React8.createElement(React8.Fragment, null, /* @__PURE__ */ React8.createElement(Insertion3, {
          cache: cache2,
          serialized,
          isStringTag: typeof FinalTag === "string"
        }), /* @__PURE__ */ React8.createElement(FinalTag, newProps));
      });
      Styled.displayName = identifierName !== void 0 ? identifierName : "Styled(" + (typeof baseTag === "string" ? baseTag : baseTag.displayName || baseTag.name || "Component") + ")";
      Styled.defaultProps = tag.defaultProps;
      Styled.__emotion_real = Styled;
      Styled.__emotion_base = baseTag;
      Styled.__emotion_styles = styles3;
      Styled.__emotion_forwardProp = shouldForwardProp;
      Object.defineProperty(Styled, "toString", {
        value: function value() {
          if (targetClassName === void 0 && isDevelopment4) {
            return "NO_COMPONENT_SELECTOR";
          }
          return "." + targetClassName;
        }
      });
      Styled.withComponent = function(nextTag, nextOptions) {
        var newStyled = createStyled2(nextTag, _extends({}, options2, nextOptions, {
          shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
        }));
        return newStyled.apply(void 0, styles3);
      };
      return Styled;
    };
  };

  // packages/components/build-module/input-control/index.mjs
  var import_compose5 = __toESM(require_compose(), 1);
  var import_element31 = __toESM(require_element(), 1);

  // packages/components/build-module/input-control/input-base.mjs
  var import_compose3 = __toESM(require_compose(), 1);
  var import_element26 = __toESM(require_element(), 1);

  // packages/components/build-module/input-control/backdrop.mjs
  var import_element25 = __toESM(require_element(), 1);

  // packages/components/build-module/text/hook.mjs
  var import_element24 = __toESM(require_element(), 1);

  // packages/components/build-module/truncate/utils.mjs
  var TRUNCATE_ELLIPSIS = "\u2026";
  var TRUNCATE_TYPE = {
    auto: "auto",
    head: "head",
    middle: "middle",
    tail: "tail",
    none: "none"
  };
  var TRUNCATE_DEFAULT_PROPS = {
    ellipsis: TRUNCATE_ELLIPSIS,
    ellipsizeMode: TRUNCATE_TYPE.auto,
    limit: 0,
    numberOfLines: 0
  };
  function truncateMiddle(word, headLength, tailLength, ellipsis) {
    if (typeof word !== "string") {
      return "";
    }
    const wordLength = word.length;
    const frontLength = ~~headLength;
    const backLength = ~~tailLength;
    const truncateStr = isValueDefined(ellipsis) ? ellipsis : TRUNCATE_ELLIPSIS;
    if (frontLength === 0 && backLength === 0 || frontLength >= wordLength || backLength >= wordLength || frontLength + backLength >= wordLength) {
      return word;
    } else if (backLength === 0) {
      return word.slice(0, frontLength) + truncateStr;
    }
    return word.slice(0, frontLength) + truncateStr + word.slice(wordLength - backLength);
  }
  function truncateContent(words = "", props) {
    const mergedProps = {
      ...TRUNCATE_DEFAULT_PROPS,
      ...props
    };
    const {
      ellipsis,
      ellipsizeMode,
      limit
    } = mergedProps;
    if (ellipsizeMode === TRUNCATE_TYPE.none) {
      return words;
    }
    let truncateHead;
    let truncateTail;
    switch (ellipsizeMode) {
      case TRUNCATE_TYPE.head:
        truncateHead = 0;
        truncateTail = limit;
        break;
      case TRUNCATE_TYPE.middle:
        truncateHead = Math.floor(limit / 2);
        truncateTail = Math.floor(limit / 2);
        break;
      default:
        truncateHead = limit;
        truncateTail = 0;
    }
    const truncatedContent = ellipsizeMode !== TRUNCATE_TYPE.auto ? truncateMiddle(words, truncateHead, truncateTail, ellipsis) : words;
    return truncatedContent;
  }

  // packages/components/build-module/truncate/hook.mjs
  var STYLE_HASH_ATTRIBUTE6 = "data-wp-hash";
  function getRuntime6() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument6(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash6(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE6}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE6) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle6(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime6();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash6(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE6, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument6(targetDocument) {
    const runtime = getRuntime6();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle6(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle6(hash2, css3) {
    const runtime = getRuntime6();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle6(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle6("beeae56da8", "._51f2afb77f24a721__truncate{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.d232bf8e2132288d__is-line-clamp{-webkit-box-orient:vertical;-webkit-line-clamp:var(--wp-components-truncate-lines);display:-webkit-box;overflow:hidden}.d232bf8e2132288d__is-line-clamp._95bf20b727db236f__is-single-line{word-break:break-all}");
  }
  var style_module_default6 = { "truncate": "_51f2afb77f24a721__truncate", "is-line-clamp": "d232bf8e2132288d__is-line-clamp", "is-single-line": "_95bf20b727db236f__is-single-line" };
  function useTruncate(props) {
    const {
      className: className2,
      children,
      ellipsis = TRUNCATE_ELLIPSIS,
      ellipsizeMode = TRUNCATE_TYPE.auto,
      limit = 0,
      numberOfLines = 0,
      style: style2,
      ...otherProps
    } = useContextSystem(props, "Truncate");
    let childrenAsText;
    if (typeof children === "string") {
      childrenAsText = children;
    } else if (typeof children === "number") {
      childrenAsText = children.toString();
    }
    const truncatedContent = childrenAsText ? truncateContent(childrenAsText, {
      ellipsis,
      ellipsizeMode,
      limit,
      numberOfLines
    }) : children;
    const shouldTruncate = !!childrenAsText && ellipsizeMode === TRUNCATE_TYPE.auto;
    const shouldClampLines = shouldTruncate && !!numberOfLines;
    const shouldClampSingleLine = shouldClampLines && numberOfLines === 1;
    const classes = clsx_default(shouldTruncate && !numberOfLines && style_module_default6.truncate, shouldClampLines && style_module_default6["is-line-clamp"], shouldClampSingleLine && style_module_default6["is-single-line"], className2);
    const truncateStyle = shouldClampLines ? {
      ...style2,
      "--wp-components-truncate-lines": numberOfLines
    } : style2;
    return {
      ...otherProps,
      className: classes,
      style: truncateStyle,
      children: truncatedContent
    };
  }

  // packages/components/build-module/truncate/component.mjs
  var import_jsx_runtime84 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedTruncate(props, forwardedRef) {
    const truncateProps = useTruncate(props);
    return /* @__PURE__ */ (0, import_jsx_runtime84.jsx)(component_default, {
      as: "span",
      ...truncateProps,
      ref: forwardedRef
    });
  }
  var Truncate = contextConnect(UnconnectedTruncate, "Truncate");
  var component_default7 = Truncate;

  // packages/components/build-module/text/styles.mjs
  var styles_exports = {};
  __export(styles_exports, {
    Text: () => Text,
    block: () => block,
    destructive: () => destructive,
    highlighterText: () => highlighterText,
    muted: () => muted,
    positive: () => positive,
    upperCase: () => upperCase
  });
  function _EMOTION_STRINGIFIED_CSS_ERROR__2() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Text = /* @__PURE__ */ css("color:", COLORS.theme.foreground, ";line-height:", config_values_default.fontLineHeightBase, ";margin:0;text-wrap:pretty;" + (false ? "" : ";label:Text;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFVdUIiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBDT0xPUlMsIENPTkZJRyB9IGZyb20gJy4uL3V0aWxzJztcblxuZXhwb3J0IGNvbnN0IFRleHQgPSBjc3NgXG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuZm9yZWdyb3VuZCB9O1xuXHRsaW5lLWhlaWdodDogJHsgQ09ORklHLmZvbnRMaW5lSGVpZ2h0QmFzZSB9O1xuXHRtYXJnaW46IDA7XG5cdHRleHQtd3JhcDogcHJldHR5O1xuYDtcblxuZXhwb3J0IGNvbnN0IGJsb2NrID0gY3NzYFxuXHRkaXNwbGF5OiBibG9jaztcbmA7XG5cbmV4cG9ydCBjb25zdCBwb3NpdGl2ZSA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy5hbGVydC5ncmVlbiB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IGRlc3RydWN0aXZlID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLmFsZXJ0LnJlZCB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IG11dGVkID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmdyYXlbIDcwMCBdIH07XG5gO1xuXG5leHBvcnQgY29uc3QgaGlnaGxpZ2h0ZXJUZXh0ID0gY3NzYFxuXHRtYXJrIHtcblx0XHRiYWNrZ3JvdW5kOiAkeyBDT0xPUlMuYWxlcnQueWVsbG93IH07XG5cdFx0Ym9yZGVyLXJhZGl1czogJHsgQ09ORklHLnJhZGl1c1NtYWxsIH07XG5cdFx0Ym94LXNoYWRvdzpcblx0XHRcdDAgMCAwIDFweCByZ2JhKCAwLCAwLCAwLCAwLjA1ICkgaW5zZXQsXG5cdFx0XHQwIC0xcHggMCByZ2JhKCAwLCAwLCAwLCAwLjEgKSBpbnNldDtcblx0fVxuYDtcblxuZXhwb3J0IGNvbnN0IHVwcGVyQ2FzZSA9IGNzc2Bcblx0dGV4dC10cmFuc2Zvcm06IHVwcGVyY2FzZTtcbmA7XG4iXX0= */");
  var block = false ? {
    name: "4zleql",
    styles: "display:block"
  } : {
    name: "14aceuy-block",
    styles: "display:block;label:block;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFpQndCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBUZXh0ID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0bGluZS1oZWlnaHQ6ICR7IENPTkZJRy5mb250TGluZUhlaWdodEJhc2UgfTtcblx0bWFyZ2luOiAwO1xuXHR0ZXh0LXdyYXA6IHByZXR0eTtcbmA7XG5cbmV4cG9ydCBjb25zdCBibG9jayA9IGNzc2Bcblx0ZGlzcGxheTogYmxvY2s7XG5gO1xuXG5leHBvcnQgY29uc3QgcG9zaXRpdmUgPSBjc3NgXG5cdGNvbG9yOiAkeyBDT0xPUlMuYWxlcnQuZ3JlZW4gfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBkZXN0cnVjdGl2ZSA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy5hbGVydC5yZWQgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBtdXRlZCA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5ncmF5WyA3MDAgXSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IGhpZ2hsaWdodGVyVGV4dCA9IGNzc2Bcblx0bWFyayB7XG5cdFx0YmFja2dyb3VuZDogJHsgQ09MT1JTLmFsZXJ0LnllbGxvdyB9O1xuXHRcdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRcdGJveC1zaGFkb3c6XG5cdFx0XHQwIDAgMCAxcHggcmdiYSggMCwgMCwgMCwgMC4wNSApIGluc2V0LFxuXHRcdFx0MCAtMXB4IDAgcmdiYSggMCwgMCwgMCwgMC4xICkgaW5zZXQ7XG5cdH1cbmA7XG5cbmV4cG9ydCBjb25zdCB1cHBlckNhc2UgPSBjc3NgXG5cdHRleHQtdHJhbnNmb3JtOiB1cHBlcmNhc2U7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__2
  };
  var positive = /* @__PURE__ */ css("color:", COLORS.alert.green, ";" + (false ? "" : ";label:positive;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFxQjJCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBUZXh0ID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0bGluZS1oZWlnaHQ6ICR7IENPTkZJRy5mb250TGluZUhlaWdodEJhc2UgfTtcblx0bWFyZ2luOiAwO1xuXHR0ZXh0LXdyYXA6IHByZXR0eTtcbmA7XG5cbmV4cG9ydCBjb25zdCBibG9jayA9IGNzc2Bcblx0ZGlzcGxheTogYmxvY2s7XG5gO1xuXG5leHBvcnQgY29uc3QgcG9zaXRpdmUgPSBjc3NgXG5cdGNvbG9yOiAkeyBDT0xPUlMuYWxlcnQuZ3JlZW4gfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBkZXN0cnVjdGl2ZSA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy5hbGVydC5yZWQgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBtdXRlZCA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5ncmF5WyA3MDAgXSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IGhpZ2hsaWdodGVyVGV4dCA9IGNzc2Bcblx0bWFyayB7XG5cdFx0YmFja2dyb3VuZDogJHsgQ09MT1JTLmFsZXJ0LnllbGxvdyB9O1xuXHRcdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRcdGJveC1zaGFkb3c6XG5cdFx0XHQwIDAgMCAxcHggcmdiYSggMCwgMCwgMCwgMC4wNSApIGluc2V0LFxuXHRcdFx0MCAtMXB4IDAgcmdiYSggMCwgMCwgMCwgMC4xICkgaW5zZXQ7XG5cdH1cbmA7XG5cbmV4cG9ydCBjb25zdCB1cHBlckNhc2UgPSBjc3NgXG5cdHRleHQtdHJhbnNmb3JtOiB1cHBlcmNhc2U7XG5gO1xuIl19 */");
  var destructive = /* @__PURE__ */ css("color:", COLORS.alert.red, ";" + (false ? "" : ";label:destructive;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF5QjhCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBUZXh0ID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0bGluZS1oZWlnaHQ6ICR7IENPTkZJRy5mb250TGluZUhlaWdodEJhc2UgfTtcblx0bWFyZ2luOiAwO1xuXHR0ZXh0LXdyYXA6IHByZXR0eTtcbmA7XG5cbmV4cG9ydCBjb25zdCBibG9jayA9IGNzc2Bcblx0ZGlzcGxheTogYmxvY2s7XG5gO1xuXG5leHBvcnQgY29uc3QgcG9zaXRpdmUgPSBjc3NgXG5cdGNvbG9yOiAkeyBDT0xPUlMuYWxlcnQuZ3JlZW4gfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBkZXN0cnVjdGl2ZSA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy5hbGVydC5yZWQgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBtdXRlZCA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5ncmF5WyA3MDAgXSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IGhpZ2hsaWdodGVyVGV4dCA9IGNzc2Bcblx0bWFyayB7XG5cdFx0YmFja2dyb3VuZDogJHsgQ09MT1JTLmFsZXJ0LnllbGxvdyB9O1xuXHRcdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRcdGJveC1zaGFkb3c6XG5cdFx0XHQwIDAgMCAxcHggcmdiYSggMCwgMCwgMCwgMC4wNSApIGluc2V0LFxuXHRcdFx0MCAtMXB4IDAgcmdiYSggMCwgMCwgMCwgMC4xICkgaW5zZXQ7XG5cdH1cbmA7XG5cbmV4cG9ydCBjb25zdCB1cHBlckNhc2UgPSBjc3NgXG5cdHRleHQtdHJhbnNmb3JtOiB1cHBlcmNhc2U7XG5gO1xuIl19 */");
  var muted = /* @__PURE__ */ css("color:", COLORS.theme.gray[700], ";" + (false ? "" : ";label:muted;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE2QndCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBUZXh0ID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0bGluZS1oZWlnaHQ6ICR7IENPTkZJRy5mb250TGluZUhlaWdodEJhc2UgfTtcblx0bWFyZ2luOiAwO1xuXHR0ZXh0LXdyYXA6IHByZXR0eTtcbmA7XG5cbmV4cG9ydCBjb25zdCBibG9jayA9IGNzc2Bcblx0ZGlzcGxheTogYmxvY2s7XG5gO1xuXG5leHBvcnQgY29uc3QgcG9zaXRpdmUgPSBjc3NgXG5cdGNvbG9yOiAkeyBDT0xPUlMuYWxlcnQuZ3JlZW4gfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBkZXN0cnVjdGl2ZSA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy5hbGVydC5yZWQgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBtdXRlZCA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5ncmF5WyA3MDAgXSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IGhpZ2hsaWdodGVyVGV4dCA9IGNzc2Bcblx0bWFyayB7XG5cdFx0YmFja2dyb3VuZDogJHsgQ09MT1JTLmFsZXJ0LnllbGxvdyB9O1xuXHRcdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRcdGJveC1zaGFkb3c6XG5cdFx0XHQwIDAgMCAxcHggcmdiYSggMCwgMCwgMCwgMC4wNSApIGluc2V0LFxuXHRcdFx0MCAtMXB4IDAgcmdiYSggMCwgMCwgMCwgMC4xICkgaW5zZXQ7XG5cdH1cbmA7XG5cbmV4cG9ydCBjb25zdCB1cHBlckNhc2UgPSBjc3NgXG5cdHRleHQtdHJhbnNmb3JtOiB1cHBlcmNhc2U7XG5gO1xuIl19 */");
  var highlighterText = /* @__PURE__ */ css("mark{background:", COLORS.alert.yellow, ";border-radius:", config_values_default.radiusSmall, ";box-shadow:0 0 0 1px rgba( 0, 0, 0, 0.05 ) inset,0 -1px 0 rgba( 0, 0, 0, 0.1 ) inset;}" + (false ? "" : ";label:highlighterText;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFpQ2tDIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBUZXh0ID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0bGluZS1oZWlnaHQ6ICR7IENPTkZJRy5mb250TGluZUhlaWdodEJhc2UgfTtcblx0bWFyZ2luOiAwO1xuXHR0ZXh0LXdyYXA6IHByZXR0eTtcbmA7XG5cbmV4cG9ydCBjb25zdCBibG9jayA9IGNzc2Bcblx0ZGlzcGxheTogYmxvY2s7XG5gO1xuXG5leHBvcnQgY29uc3QgcG9zaXRpdmUgPSBjc3NgXG5cdGNvbG9yOiAkeyBDT0xPUlMuYWxlcnQuZ3JlZW4gfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBkZXN0cnVjdGl2ZSA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy5hbGVydC5yZWQgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBtdXRlZCA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5ncmF5WyA3MDAgXSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IGhpZ2hsaWdodGVyVGV4dCA9IGNzc2Bcblx0bWFyayB7XG5cdFx0YmFja2dyb3VuZDogJHsgQ09MT1JTLmFsZXJ0LnllbGxvdyB9O1xuXHRcdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRcdGJveC1zaGFkb3c6XG5cdFx0XHQwIDAgMCAxcHggcmdiYSggMCwgMCwgMCwgMC4wNSApIGluc2V0LFxuXHRcdFx0MCAtMXB4IDAgcmdiYSggMCwgMCwgMCwgMC4xICkgaW5zZXQ7XG5cdH1cbmA7XG5cbmV4cG9ydCBjb25zdCB1cHBlckNhc2UgPSBjc3NgXG5cdHRleHQtdHJhbnNmb3JtOiB1cHBlcmNhc2U7XG5gO1xuIl19 */");
  var upperCase = false ? {
    name: "50zrmy",
    styles: "text-transform:uppercase"
  } : {
    name: "1mrt3zt-upperCase",
    styles: "text-transform:uppercase;label:upperCase;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEyQzRCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBUZXh0ID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0bGluZS1oZWlnaHQ6ICR7IENPTkZJRy5mb250TGluZUhlaWdodEJhc2UgfTtcblx0bWFyZ2luOiAwO1xuXHR0ZXh0LXdyYXA6IHByZXR0eTtcbmA7XG5cbmV4cG9ydCBjb25zdCBibG9jayA9IGNzc2Bcblx0ZGlzcGxheTogYmxvY2s7XG5gO1xuXG5leHBvcnQgY29uc3QgcG9zaXRpdmUgPSBjc3NgXG5cdGNvbG9yOiAkeyBDT0xPUlMuYWxlcnQuZ3JlZW4gfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBkZXN0cnVjdGl2ZSA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy5hbGVydC5yZWQgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBtdXRlZCA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5ncmF5WyA3MDAgXSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IGhpZ2hsaWdodGVyVGV4dCA9IGNzc2Bcblx0bWFyayB7XG5cdFx0YmFja2dyb3VuZDogJHsgQ09MT1JTLmFsZXJ0LnllbGxvdyB9O1xuXHRcdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRcdGJveC1zaGFkb3c6XG5cdFx0XHQwIDAgMCAxcHggcmdiYSggMCwgMCwgMCwgMC4wNSApIGluc2V0LFxuXHRcdFx0MCAtMXB4IDAgcmdiYSggMCwgMCwgMCwgMC4xICkgaW5zZXQ7XG5cdH1cbmA7XG5cbmV4cG9ydCBjb25zdCB1cHBlckNhc2UgPSBjc3NgXG5cdHRleHQtdHJhbnNmb3JtOiB1cHBlcmNhc2U7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__2
  };

  // packages/components/build-module/text/utils.mjs
  var import_highlight_words_core = __toESM(require_dist(), 1);
  var import_element23 = __toESM(require_element(), 1);
  var lowercaseProps = (object) => {
    const mapped = {};
    for (const key in object) {
      mapped[key.toLowerCase()] = object[key];
    }
    return mapped;
  };
  var memoizedLowercaseProps = memize(lowercaseProps);
  function createHighlighterText({
    activeClassName = "",
    activeIndex = -1,
    activeStyle,
    autoEscape,
    caseSensitive = false,
    children,
    findChunks,
    highlightClassName = "",
    highlightStyle = {},
    highlightTag = "mark",
    sanitize: sanitize2,
    searchWords = [],
    unhighlightClassName = "",
    unhighlightStyle
  }) {
    if (!children) {
      return null;
    }
    if (typeof children !== "string") {
      return children;
    }
    const textToHighlight = children;
    const chunks = (0, import_highlight_words_core.findAll)({
      autoEscape,
      caseSensitive,
      findChunks,
      sanitize: sanitize2,
      searchWords,
      textToHighlight
    });
    const HighlightTag = highlightTag;
    let highlightIndex = -1;
    let highlightClassNames = "";
    let highlightStyles;
    const textContent = chunks.map((chunk, index2) => {
      const text = textToHighlight.substr(chunk.start, chunk.end - chunk.start);
      if (chunk.highlight) {
        highlightIndex++;
        let highlightClass;
        if (typeof highlightClassName === "object") {
          if (!caseSensitive) {
            highlightClassName = memoizedLowercaseProps(highlightClassName);
            highlightClass = highlightClassName[text.toLowerCase()];
          } else {
            highlightClass = highlightClassName[text];
          }
        } else {
          highlightClass = highlightClassName;
        }
        const isActive = highlightIndex === +activeIndex;
        highlightClassNames = `${highlightClass} ${isActive ? activeClassName : ""}`;
        highlightStyles = isActive === true && activeStyle !== null ? Object.assign({}, highlightStyle, activeStyle) : highlightStyle;
        const props = {
          children: text,
          className: highlightClassNames,
          key: index2,
          style: highlightStyles
        };
        if (typeof HighlightTag !== "string") {
          props.highlightIndex = highlightIndex;
        }
        return (0, import_element23.createElement)(HighlightTag, props);
      }
      return (0, import_element23.createElement)("span", {
        children: text,
        className: unhighlightClassName,
        key: index2,
        style: unhighlightStyle
      });
    });
    return textContent;
  }

  // packages/components/build-module/utils/font-size.mjs
  var BASE_FONT_SIZE = 13;
  var PRESET_FONT_SIZES = {
    body: BASE_FONT_SIZE,
    caption: 10,
    footnote: 11,
    largeTitle: 28,
    subheadline: 12,
    title: 20
  };
  var HEADING_FONT_SIZES = [1, 2, 3, 4, 5, 6].flatMap((n3) => [n3, n3.toString()]);
  function getFontSize(size4 = BASE_FONT_SIZE) {
    if (size4 in PRESET_FONT_SIZES) {
      return getFontSize(PRESET_FONT_SIZES[size4]);
    }
    if (typeof size4 !== "number") {
      const parsed = parseFloat(size4);
      if (Number.isNaN(parsed)) {
        return size4;
      }
      size4 = parsed;
    }
    const ratio = `(${size4} / ${BASE_FONT_SIZE})`;
    return `calc(${ratio} * ${config_values_default.fontSize})`;
  }
  function getHeadingFontSize(size4 = 3) {
    if (!HEADING_FONT_SIZES.includes(size4)) {
      return getFontSize(size4);
    }
    const headingSize = `fontSizeH${size4}`;
    return config_values_default[headingSize];
  }

  // packages/components/build-module/text/get-line-height.mjs
  function getLineHeight(adjustLineHeightForInnerControls, lineHeight) {
    if (lineHeight) {
      return lineHeight;
    }
    if (!adjustLineHeightForInnerControls) {
      return;
    }
    let value = `calc(${config_values_default.controlHeight} + ${space(2)})`;
    switch (adjustLineHeightForInnerControls) {
      case "large":
        value = `calc(${config_values_default.controlHeightLarge} + ${space(2)})`;
        break;
      case "small":
        value = `calc(${config_values_default.controlHeightSmall} + ${space(2)})`;
        break;
      case "xSmall":
        value = `calc(${config_values_default.controlHeightXSmall} + ${space(2)})`;
        break;
      default:
        break;
    }
    return value;
  }

  // packages/components/build-module/text/hook.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__3() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var _ref = false ? {
    name: "50zrmy",
    styles: "text-transform:uppercase"
  } : {
    name: "1tgq1bq-upperCaseStyles",
    styles: "text-transform:uppercase;label:upperCaseStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__3
  };
  function useText(props) {
    const {
      adjustLineHeightForInnerControls,
      align,
      children,
      className: className2,
      color: color2,
      ellipsizeMode,
      isDestructive = false,
      display,
      highlightEscape = false,
      highlightCaseSensitive = false,
      highlightWords,
      highlightSanitize,
      isBlock = false,
      letterSpacing,
      lineHeight: lineHeightProp,
      optimizeReadabilityFor,
      size: size4,
      truncate = false,
      upperCase: upperCase2 = false,
      variant,
      weight = config_values_default.fontWeight,
      ...otherProps
    } = useContextSystem(props, "Text");
    let content = children;
    const isHighlighter = Array.isArray(highlightWords);
    const isCaption = size4 === "caption";
    if (isHighlighter) {
      if (typeof children !== "string") {
        throw new TypeError("`children` of `Text` must only be `string` types when `highlightWords` is defined");
      }
      content = createHighlighterText({
        autoEscape: highlightEscape,
        children,
        caseSensitive: highlightCaseSensitive,
        searchWords: highlightWords,
        sanitize: highlightSanitize
      });
    }
    const cx2 = useCx();
    const classes = (0, import_element24.useMemo)(() => {
      const lineHeight = getLineHeight(adjustLineHeightForInnerControls, lineHeightProp);
      const base = /* @__PURE__ */ css({
        color: color2,
        display,
        fontSize: getFontSize(size4),
        fontWeight: weight,
        lineHeight,
        letterSpacing,
        textAlign: align
      }, false ? "" : ";label:base;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      const upperCaseStyles = _ref;
      let optimalTextColor = null;
      if (optimizeReadabilityFor) {
        const isOptimalTextColorDark = getOptimalTextShade(optimizeReadabilityFor) === "dark";
        optimalTextColor = isOptimalTextColorDark ? /* @__PURE__ */ css({
          color: COLORS.gray[900]
        }, false ? "" : ";label:optimalTextColor;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */") : /* @__PURE__ */ css({
          color: COLORS.white
        }, false ? "" : ";label:optimalTextColor;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      }
      const textStyles = /* @__PURE__ */ css(Text, base, optimalTextColor, isDestructive && destructive, !!isHighlighter && highlighterText, isBlock && block, isCaption && muted, variant && styles_exports[variant], upperCase2 && upperCaseStyles, false ? "" : ";label:textStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      return cx2(textStyles, className2);
    }, [adjustLineHeightForInnerControls, align, className2, color2, cx2, display, isBlock, isCaption, isDestructive, isHighlighter, letterSpacing, lineHeightProp, optimizeReadabilityFor, size4, upperCase2, variant, weight]);
    let finalEllipsizeMode;
    if (truncate === true) {
      finalEllipsizeMode = "auto";
    }
    if (truncate === false) {
      finalEllipsizeMode = "none";
    }
    const finalComponentProps = {
      ...otherProps,
      className: classes,
      children,
      ellipsizeMode: ellipsizeMode || finalEllipsizeMode
    };
    const truncateProps = useTruncate(finalComponentProps);
    if (!truncate && Array.isArray(children)) {
      content = import_element24.Children.map(children, (child) => {
        if (typeof child !== "object" || child === null || !("props" in child)) {
          return child;
        }
        const isLink = hasConnectNamespace(child, ["Link"]);
        if (isLink) {
          return (0, import_element24.cloneElement)(child, {
            size: child.props.size || "inherit"
          });
        }
        return child;
      });
    }
    return {
      ...truncateProps,
      children: truncate ? truncateProps.children : content
    };
  }

  // packages/components/build-module/text/component.mjs
  var import_jsx_runtime85 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedText(props, forwardedRef) {
    const textProps = useText(props);
    return /* @__PURE__ */ (0, import_jsx_runtime85.jsx)(component_default, {
      as: "span",
      ...textProps,
      ref: forwardedRef
    });
  }
  var Text2 = contextConnect(UnconnectedText, "Text");
  var component_default8 = Text2;

  // packages/components/build-module/input-control/styles/input-control-styles.mjs
  var import_jsx_runtime86 = __toESM(require_jsx_runtime(), 1);
  function _EMOTION_STRINGIFIED_CSS_ERROR__4() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Prefix = /* @__PURE__ */ createStyled("span", false ? {
    target: "em5sgkm8"
  } : {
    target: "em5sgkm8",
    label: "Prefix"
  })(false ? {
    name: "pvvbxf",
    styles: "box-sizing:border-box;display:block"
  } : {
    name: "pvvbxf",
    styles: "box-sizing:border-box;display:block/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__4
  });
  var Suffix = /* @__PURE__ */ createStyled("span", false ? {
    target: "em5sgkm7"
  } : {
    target: "em5sgkm7",
    label: "Suffix"
  })(false ? {
    name: "jgf79h",
    styles: "align-items:center;align-self:stretch;box-sizing:border-box;display:flex"
  } : {
    name: "jgf79h",
    styles: "align-items:center;align-self:stretch;box-sizing:border-box;display:flex/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__4
  });
  var backdropBorderColor = ({
    disabled,
    isBorderless
  }) => {
    if (isBorderless) {
      return "transparent";
    }
    if (disabled) {
      return COLORS.ui.borderDisabled;
    }
    return COLORS.ui.border;
  };
  var BackdropUI = /* @__PURE__ */ createStyled("div", false ? {
    target: "em5sgkm6"
  } : {
    target: "em5sgkm6",
    label: "BackdropUI"
  })("&&&{box-sizing:border-box;border-color:", backdropBorderColor, ";border-radius:inherit;border-style:solid;border-width:1px;bottom:0;left:0;margin:0;padding:0;pointer-events:none;position:absolute;right:0;top:0;", rtl({
    paddingLeft: 2
  }), ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var Root = /* @__PURE__ */ createStyled(component_default3, false ? {
    target: "em5sgkm5"
  } : {
    target: "em5sgkm5",
    label: "Root"
  })("box-sizing:border-box;position:relative;border-radius:", config_values_default.radiusSmall, ";padding-top:0;&:focus-within:not( :has( :is( ", Prefix, ", ", Suffix, " ):focus-within ) ){", BackdropUI, "{border-color:", COLORS.ui.borderFocus, ";box-shadow:", config_values_default.controlBoxShadowFocus, ";outline:2px solid transparent;outline-offset:-2px;}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var containerDisabledStyles = ({
    disabled
  }) => {
    const backgroundColor = disabled ? COLORS.ui.backgroundDisabled : COLORS.ui.background;
    return /* @__PURE__ */ css({
      backgroundColor
    }, false ? "" : ";label:containerDisabledStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var _ref2 = false ? {
    name: "1d3w5wq",
    styles: "width:100%"
  } : {
    name: "uo2pd2-containerWidthStyles",
    styles: "width:100%;label:containerWidthStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__4
  };
  var containerWidthStyles = ({
    __unstableInputWidth,
    labelPosition
  }) => {
    if (!__unstableInputWidth) {
      return _ref2;
    }
    if (labelPosition === "side") {
      return "";
    }
    if (labelPosition === "edge") {
      return /* @__PURE__ */ css({
        flex: `0 0 ${__unstableInputWidth}`
      }, false ? "" : ";label:containerWidthStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
    }
    return /* @__PURE__ */ css({
      width: __unstableInputWidth
    }, false ? "" : ";label:containerWidthStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var Container = /* @__PURE__ */ createStyled("div", false ? {
    target: "em5sgkm4"
  } : {
    target: "em5sgkm4",
    label: "Container"
  })("align-items:center;box-sizing:border-box;border-radius:inherit;display:flex;flex:1;position:relative;", containerDisabledStyles, " ", containerWidthStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var disabledStyles = ({
    disabled
  }) => {
    if (!disabled) {
      return "";
    }
    return /* @__PURE__ */ css({
      color: COLORS.ui.textDisabled
    }, false ? "" : ";label:disabledStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var fontSizeStyles = ({
    inputSize: size4
  }) => {
    const sizes = {
      default: "13px",
      small: "11px",
      compact: "13px",
      "__unstable-large": "13px"
    };
    const fontSize = sizes[size4] || sizes.default;
    const fontSizeMobile = "16px";
    if (!fontSize) {
      return "";
    }
    return /* @__PURE__ */ css("font-size:", fontSizeMobile, ";@media ( min-width: 600px ){font-size:", fontSize, ";}" + (false ? "" : ";label:fontSizeStyles;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var getSizeConfig = ({
    inputSize: size4
  }) => {
    const sizes = {
      default: {
        height: 40,
        lineHeight: 1,
        minHeight: 40,
        paddingLeft: config_values_default.controlPaddingX,
        paddingRight: config_values_default.controlPaddingX
      },
      small: {
        height: 24,
        lineHeight: 1,
        minHeight: 24,
        paddingLeft: config_values_default.controlPaddingXSmall,
        paddingRight: config_values_default.controlPaddingXSmall
      },
      compact: {
        height: 32,
        lineHeight: 1,
        minHeight: 32,
        paddingLeft: config_values_default.controlPaddingXSmall,
        paddingRight: config_values_default.controlPaddingXSmall
      },
      "__unstable-large": {
        height: 40,
        lineHeight: 1,
        minHeight: 40,
        paddingLeft: config_values_default.controlPaddingX,
        paddingRight: config_values_default.controlPaddingX
      }
    };
    return sizes[size4] || sizes.default;
  };
  var sizeStyles = (props) => {
    return /* @__PURE__ */ css(getSizeConfig(props), false ? "" : ";label:sizeStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var customPaddings = ({
    paddingInlineStart,
    paddingInlineEnd
  }) => {
    return /* @__PURE__ */ css({
      paddingInlineStart,
      paddingInlineEnd
    }, false ? "" : ";label:customPaddings;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var dragStyles = ({
    isDragging: isDragging2,
    dragCursor
  }) => {
    let defaultArrowStyles;
    let activeDragCursorStyles;
    if (isDragging2) {
      defaultArrowStyles = /* @__PURE__ */ css("cursor:", dragCursor, ";user-select:none;&::-webkit-outer-spin-button,&::-webkit-inner-spin-button{-webkit-appearance:none!important;margin:0!important;}" + (false ? "" : ";label:defaultArrowStyles;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
    }
    if (isDragging2 && dragCursor) {
      activeDragCursorStyles = /* @__PURE__ */ css("&:active{cursor:", dragCursor, ";}" + (false ? "" : ";label:activeDragCursorStyles;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
    }
    return /* @__PURE__ */ css(defaultArrowStyles, " ", activeDragCursorStyles, ";" + (false ? "" : ";label:dragStyles;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var Input = /* @__PURE__ */ createStyled("input", false ? {
    target: "em5sgkm3"
  } : {
    target: "em5sgkm3",
    label: "Input"
  })("&&&{background-color:transparent;box-sizing:border-box;border:none;box-shadow:none!important;color:", COLORS.theme.foreground, ";display:block;font-family:inherit;margin:0;outline:none;width:100%;", dragStyles, " ", disabledStyles, " ", fontSizeStyles, " ", sizeStyles, " ", customPaddings, " &::-webkit-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&::-moz-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&:-ms-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&[type='email'],&[type='url']{direction:ltr;}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var BaseLabel = /* @__PURE__ */ createStyled(component_default8, false ? {
    target: "em5sgkm2"
  } : {
    target: "em5sgkm2",
    label: "BaseLabel"
  })("&&&{", baseLabelTypography, ";box-sizing:border-box;display:block;padding-top:0;padding-bottom:0;max-width:100%;z-index:1;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var Label = (props) => /* @__PURE__ */ (0, import_jsx_runtime86.jsx)(BaseLabel, {
    ...props,
    as: "label"
  });
  var LabelWrapper = /* @__PURE__ */ createStyled(component_default4, false ? {
    target: "em5sgkm1"
  } : {
    target: "em5sgkm1",
    label: "LabelWrapper"
  })(false ? {
    name: "1b6uupn",
    styles: "max-width:calc( 100% - 10px )"
  } : {
    name: "1b6uupn",
    styles: "max-width:calc( 100% - 10px )/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__4
  });
  var prefixSuffixWrapperStyles = ({
    variant = "default",
    size: size4,
    isPrefix
  }) => {
    const {
      paddingLeft: padding2
    } = getSizeConfig({
      inputSize: size4
    });
    const paddingProperty = isPrefix ? "paddingInlineStart" : "paddingInlineEnd";
    if (variant === "default") {
      return /* @__PURE__ */ css({
        [paddingProperty]: padding2
      }, false ? "" : ";label:prefixSuffixWrapperStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
    }
    return /* @__PURE__ */ css({
      display: "flex",
      [paddingProperty]: padding2 - 4
    }, false ? "" : ";label:prefixSuffixWrapperStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var PrefixSuffixWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "em5sgkm0"
  } : {
    target: "em5sgkm0",
    label: "PrefixSuffixWrapper"
  })(prefixSuffixWrapperStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // packages/components/build-module/input-control/backdrop.mjs
  var import_jsx_runtime87 = __toESM(require_jsx_runtime(), 1);
  function Backdrop({
    disabled = false,
    isBorderless = false
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime87.jsx)(BackdropUI, {
      "aria-hidden": "true",
      className: "components-input-control__backdrop",
      disabled,
      isBorderless
    });
  }
  var MemoizedBackdrop = (0, import_element25.memo)(Backdrop);
  var backdrop_default = MemoizedBackdrop;

  // packages/components/build-module/input-control/label.mjs
  var import_jsx_runtime88 = __toESM(require_jsx_runtime(), 1);
  function Label2({
    children,
    hideLabelFromVision,
    htmlFor,
    ...props
  }) {
    if (!children) {
      return null;
    }
    if (hideLabelFromVision) {
      return /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(component_default2, {
        as: "label",
        htmlFor,
        children
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(LabelWrapper, {
      children: /* @__PURE__ */ (0, import_jsx_runtime88.jsx)(Label, {
        htmlFor,
        ...props,
        children
      })
    });
  }

  // packages/components/build-module/input-control/input-base.mjs
  var import_jsx_runtime89 = __toESM(require_jsx_runtime(), 1);
  function useUniqueId(idProp) {
    const instanceId = (0, import_compose3.useInstanceId)(InputBase);
    const id3 = `input-base-control-${instanceId}`;
    return idProp || id3;
  }
  function getUIFlexProps(labelPosition) {
    const props = {};
    switch (labelPosition) {
      case "top":
        props.direction = "column";
        props.expanded = false;
        props.gap = 0;
        break;
      case "bottom":
        props.direction = "column-reverse";
        props.expanded = false;
        props.gap = 0;
        break;
      case "edge":
        props.justify = "space-between";
        break;
    }
    return props;
  }
  function InputBase(props, ref) {
    const {
      __unstableInputWidth,
      children,
      className: className2,
      disabled = false,
      hideLabelFromVision = false,
      labelPosition,
      id: idProp,
      isBorderless = false,
      label,
      prefix: prefix2,
      size: size4 = "default",
      suffix,
      ...restProps
    } = useContextSystem(props, "InputBase");
    const id3 = useUniqueId(idProp);
    const hideLabel = hideLabelFromVision || !label;
    const prefixSuffixContextValue = (0, import_element26.useMemo)(() => {
      return {
        InputControlPrefixWrapper: {
          size: size4
        },
        InputControlSuffixWrapper: {
          size: size4
        }
      };
    }, [size4]);
    return (
      // @ts-expect-error The `direction` prop from Flex (FlexDirection) conflicts with legacy SVGAttributes `direction` (string) that come from React intrinsic prop definitions.
      /* @__PURE__ */ (0, import_jsx_runtime89.jsxs)(Root, {
        ...restProps,
        ...getUIFlexProps(labelPosition),
        className: className2,
        gap: 2,
        ref,
        children: [/* @__PURE__ */ (0, import_jsx_runtime89.jsx)(Label2, {
          className: "components-input-control__label",
          hideLabelFromVision,
          labelPosition,
          htmlFor: id3,
          children: label
        }), /* @__PURE__ */ (0, import_jsx_runtime89.jsxs)(Container, {
          __unstableInputWidth,
          className: "components-input-control__container",
          disabled,
          hideLabel,
          labelPosition,
          children: [/* @__PURE__ */ (0, import_jsx_runtime89.jsxs)(ContextSystemProvider, {
            value: prefixSuffixContextValue,
            children: [prefix2 && /* @__PURE__ */ (0, import_jsx_runtime89.jsx)(Prefix, {
              className: "components-input-control__prefix",
              children: prefix2
            }), children, suffix && /* @__PURE__ */ (0, import_jsx_runtime89.jsx)(Suffix, {
              className: "components-input-control__suffix",
              children: suffix
            })]
          }), /* @__PURE__ */ (0, import_jsx_runtime89.jsx)(backdrop_default, {
            disabled,
            isBorderless
          })]
        })]
      })
    );
  }
  var input_base_default = contextConnect(InputBase, "InputBase");

  // node_modules/@use-gesture/core/dist/maths-0ab39ae9.esm.js
  function clamp3(v3, min3, max3) {
    return Math.max(min3, Math.min(v3, max3));
  }
  var V = {
    toVector(v3, fallback) {
      if (v3 === void 0) v3 = fallback;
      return Array.isArray(v3) ? v3 : [v3, v3];
    },
    add(v1, v22) {
      return [v1[0] + v22[0], v1[1] + v22[1]];
    },
    sub(v1, v22) {
      return [v1[0] - v22[0], v1[1] - v22[1]];
    },
    addTo(v1, v22) {
      v1[0] += v22[0];
      v1[1] += v22[1];
    },
    subTo(v1, v22) {
      v1[0] -= v22[0];
      v1[1] -= v22[1];
    }
  };
  function rubberband(distance2, dimension, constant) {
    if (dimension === 0 || Math.abs(dimension) === Infinity) return Math.pow(distance2, constant * 5);
    return distance2 * dimension * constant / (dimension + constant * distance2);
  }
  function rubberbandIfOutOfBounds(position2, min3, max3, constant = 0.15) {
    if (constant === 0) return clamp3(position2, min3, max3);
    if (position2 < min3) return -rubberband(min3 - position2, max3 - min3, constant) + min3;
    if (position2 > max3) return +rubberband(position2 - max3, max3 - min3, constant) + max3;
    return position2;
  }
  function computeRubberband(bounds, [Vx, Vy], [Rx, Ry]) {
    const [[X0, X1], [Y0, Y1]] = bounds;
    return [rubberbandIfOutOfBounds(Vx, X0, X1, Rx), rubberbandIfOutOfBounds(Vy, Y0, Y1, Ry)];
  }

  // node_modules/@use-gesture/core/dist/actions-fe213e88.esm.js
  function _toPrimitive(input, hint) {
    if (typeof input !== "object" || input === null) return input;
    var prim = input[Symbol.toPrimitive];
    if (prim !== void 0) {
      var res = prim.call(input, hint || "default");
      if (typeof res !== "object") return res;
      throw new TypeError("@@toPrimitive must return a primitive value.");
    }
    return (hint === "string" ? String : Number)(input);
  }
  function _toPropertyKey(arg) {
    var key = _toPrimitive(arg, "string");
    return typeof key === "symbol" ? key : String(key);
  }
  function _defineProperty(obj, key, value) {
    key = _toPropertyKey(key);
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
    return obj;
  }
  function ownKeys(e3, r4) {
    var t4 = Object.keys(e3);
    if (Object.getOwnPropertySymbols) {
      var o4 = Object.getOwnPropertySymbols(e3);
      r4 && (o4 = o4.filter(function(r5) {
        return Object.getOwnPropertyDescriptor(e3, r5).enumerable;
      })), t4.push.apply(t4, o4);
    }
    return t4;
  }
  function _objectSpread2(e3) {
    for (var r4 = 1; r4 < arguments.length; r4++) {
      var t4 = null != arguments[r4] ? arguments[r4] : {};
      r4 % 2 ? ownKeys(Object(t4), true).forEach(function(r5) {
        _defineProperty(e3, r5, t4[r5]);
      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e3, Object.getOwnPropertyDescriptors(t4)) : ownKeys(Object(t4)).forEach(function(r5) {
        Object.defineProperty(e3, r5, Object.getOwnPropertyDescriptor(t4, r5));
      });
    }
    return e3;
  }
  var EVENT_TYPE_MAP = {
    pointer: {
      start: "down",
      change: "move",
      end: "up"
    },
    mouse: {
      start: "down",
      change: "move",
      end: "up"
    },
    touch: {
      start: "start",
      change: "move",
      end: "end"
    },
    gesture: {
      start: "start",
      change: "change",
      end: "end"
    }
  };
  function capitalize(string) {
    if (!string) return "";
    return string[0].toUpperCase() + string.slice(1);
  }
  var actionsWithoutCaptureSupported = ["enter", "leave"];
  function hasCapture(capture = false, actionKey) {
    return capture && !actionsWithoutCaptureSupported.includes(actionKey);
  }
  function toHandlerProp(device, action = "", capture = false) {
    const deviceProps = EVENT_TYPE_MAP[device];
    const actionKey = deviceProps ? deviceProps[action] || action : action;
    return "on" + capitalize(device) + capitalize(actionKey) + (hasCapture(capture, actionKey) ? "Capture" : "");
  }
  var pointerCaptureEvents = ["gotpointercapture", "lostpointercapture"];
  function parseProp(prop) {
    let eventKey = prop.substring(2).toLowerCase();
    const passive = !!~eventKey.indexOf("passive");
    if (passive) eventKey = eventKey.replace("passive", "");
    const captureKey = pointerCaptureEvents.includes(eventKey) ? "capturecapture" : "capture";
    const capture = !!~eventKey.indexOf(captureKey);
    if (capture) eventKey = eventKey.replace("capture", "");
    return {
      device: eventKey,
      capture,
      passive
    };
  }
  function toDomEventType(device, action = "") {
    const deviceProps = EVENT_TYPE_MAP[device];
    const actionKey = deviceProps ? deviceProps[action] || action : action;
    return device + actionKey;
  }
  function isTouch(event) {
    return "touches" in event;
  }
  function getPointerType(event) {
    if (isTouch(event)) return "touch";
    if ("pointerType" in event) return event.pointerType;
    return "mouse";
  }
  function getCurrentTargetTouchList(event) {
    return Array.from(event.touches).filter((e3) => {
      var _event$currentTarget, _event$currentTarget$;
      return e3.target === event.currentTarget || ((_event$currentTarget = event.currentTarget) === null || _event$currentTarget === void 0 || (_event$currentTarget$ = _event$currentTarget.contains) === null || _event$currentTarget$ === void 0 ? void 0 : _event$currentTarget$.call(_event$currentTarget, e3.target));
    });
  }
  function getTouchList(event) {
    return event.type === "touchend" || event.type === "touchcancel" ? event.changedTouches : event.targetTouches;
  }
  function getValueEvent(event) {
    return isTouch(event) ? getTouchList(event)[0] : event;
  }
  function touchIds(event) {
    return getCurrentTargetTouchList(event).map((touch) => touch.identifier);
  }
  function pointerId(event) {
    const valueEvent = getValueEvent(event);
    return isTouch(event) ? valueEvent.identifier : valueEvent.pointerId;
  }
  function pointerValues(event) {
    const valueEvent = getValueEvent(event);
    return [valueEvent.clientX, valueEvent.clientY];
  }
  function getEventDetails(event) {
    const payload = {};
    if ("buttons" in event) payload.buttons = event.buttons;
    if ("shiftKey" in event) {
      const {
        shiftKey,
        altKey,
        metaKey,
        ctrlKey
      } = event;
      Object.assign(payload, {
        shiftKey,
        altKey,
        metaKey,
        ctrlKey
      });
    }
    return payload;
  }
  function call(v3, ...args) {
    if (typeof v3 === "function") {
      return v3(...args);
    } else {
      return v3;
    }
  }
  function noop3() {
  }
  function chain2(...fns) {
    if (fns.length === 0) return noop3;
    if (fns.length === 1) return fns[0];
    return function() {
      let result;
      for (const fn of fns) {
        result = fn.apply(this, arguments) || result;
      }
      return result;
    };
  }
  function assignDefault(value, fallback) {
    return Object.assign({}, fallback, value || {});
  }
  var BEFORE_LAST_KINEMATICS_DELAY = 32;
  var Engine = class {
    constructor(ctrl, args, key) {
      this.ctrl = ctrl;
      this.args = args;
      this.key = key;
      if (!this.state) {
        this.state = {};
        this.computeValues([0, 0]);
        this.computeInitial();
        if (this.init) this.init();
        this.reset();
      }
    }
    get state() {
      return this.ctrl.state[this.key];
    }
    set state(state) {
      this.ctrl.state[this.key] = state;
    }
    get shared() {
      return this.ctrl.state.shared;
    }
    get eventStore() {
      return this.ctrl.gestureEventStores[this.key];
    }
    get timeoutStore() {
      return this.ctrl.gestureTimeoutStores[this.key];
    }
    get config() {
      return this.ctrl.config[this.key];
    }
    get sharedConfig() {
      return this.ctrl.config.shared;
    }
    get handler() {
      return this.ctrl.handlers[this.key];
    }
    reset() {
      const {
        state,
        shared,
        ingKey,
        args
      } = this;
      shared[ingKey] = state._active = state.active = state._blocked = state._force = false;
      state._step = [false, false];
      state.intentional = false;
      state._movement = [0, 0];
      state._distance = [0, 0];
      state._direction = [0, 0];
      state._delta = [0, 0];
      state._bounds = [[-Infinity, Infinity], [-Infinity, Infinity]];
      state.args = args;
      state.axis = void 0;
      state.memo = void 0;
      state.elapsedTime = state.timeDelta = 0;
      state.direction = [0, 0];
      state.distance = [0, 0];
      state.overflow = [0, 0];
      state._movementBound = [false, false];
      state.velocity = [0, 0];
      state.movement = [0, 0];
      state.delta = [0, 0];
      state.timeStamp = 0;
    }
    start(event) {
      const state = this.state;
      const config = this.config;
      if (!state._active) {
        this.reset();
        this.computeInitial();
        state._active = true;
        state.target = event.target;
        state.currentTarget = event.currentTarget;
        state.lastOffset = config.from ? call(config.from, state) : state.offset;
        state.offset = state.lastOffset;
        state.startTime = state.timeStamp = event.timeStamp;
      }
    }
    computeValues(values) {
      const state = this.state;
      state._values = values;
      state.values = this.config.transform(values);
    }
    computeInitial() {
      const state = this.state;
      state._initial = state._values;
      state.initial = state.values;
    }
    compute(event) {
      const {
        state,
        config,
        shared
      } = this;
      state.args = this.args;
      let dt = 0;
      if (event) {
        state.event = event;
        if (config.preventDefault && event.cancelable) state.event.preventDefault();
        state.type = event.type;
        shared.touches = this.ctrl.pointerIds.size || this.ctrl.touchIds.size;
        shared.locked = !!document.pointerLockElement;
        Object.assign(shared, getEventDetails(event));
        shared.down = shared.pressed = shared.buttons % 2 === 1 || shared.touches > 0;
        dt = event.timeStamp - state.timeStamp;
        state.timeStamp = event.timeStamp;
        state.elapsedTime = state.timeStamp - state.startTime;
      }
      if (state._active) {
        const _absoluteDelta = state._delta.map(Math.abs);
        V.addTo(state._distance, _absoluteDelta);
      }
      if (this.axisIntent) this.axisIntent(event);
      const [_m0, _m1] = state._movement;
      const [t0, t1] = config.threshold;
      const {
        _step,
        values
      } = state;
      if (config.hasCustomTransform) {
        if (_step[0] === false) _step[0] = Math.abs(_m0) >= t0 && values[0];
        if (_step[1] === false) _step[1] = Math.abs(_m1) >= t1 && values[1];
      } else {
        if (_step[0] === false) _step[0] = Math.abs(_m0) >= t0 && Math.sign(_m0) * t0;
        if (_step[1] === false) _step[1] = Math.abs(_m1) >= t1 && Math.sign(_m1) * t1;
      }
      state.intentional = _step[0] !== false || _step[1] !== false;
      if (!state.intentional) return;
      const movement = [0, 0];
      if (config.hasCustomTransform) {
        const [v0, v1] = values;
        movement[0] = _step[0] !== false ? v0 - _step[0] : 0;
        movement[1] = _step[1] !== false ? v1 - _step[1] : 0;
      } else {
        movement[0] = _step[0] !== false ? _m0 - _step[0] : 0;
        movement[1] = _step[1] !== false ? _m1 - _step[1] : 0;
      }
      if (this.restrictToAxis && !state._blocked) this.restrictToAxis(movement);
      const previousOffset = state.offset;
      const gestureIsActive = state._active && !state._blocked || state.active;
      if (gestureIsActive) {
        state.first = state._active && !state.active;
        state.last = !state._active && state.active;
        state.active = shared[this.ingKey] = state._active;
        if (event) {
          if (state.first) {
            if ("bounds" in config) state._bounds = call(config.bounds, state);
            if (this.setup) this.setup();
          }
          state.movement = movement;
          this.computeOffset();
        }
      }
      const [ox, oy] = state.offset;
      const [[x0, x1], [y0, y1]] = state._bounds;
      state.overflow = [ox < x0 ? -1 : ox > x1 ? 1 : 0, oy < y0 ? -1 : oy > y1 ? 1 : 0];
      state._movementBound[0] = state.overflow[0] ? state._movementBound[0] === false ? state._movement[0] : state._movementBound[0] : false;
      state._movementBound[1] = state.overflow[1] ? state._movementBound[1] === false ? state._movement[1] : state._movementBound[1] : false;
      const rubberband2 = state._active ? config.rubberband || [0, 0] : [0, 0];
      state.offset = computeRubberband(state._bounds, state.offset, rubberband2);
      state.delta = V.sub(state.offset, previousOffset);
      this.computeMovement();
      if (gestureIsActive && (!state.last || dt > BEFORE_LAST_KINEMATICS_DELAY)) {
        state.delta = V.sub(state.offset, previousOffset);
        const absoluteDelta = state.delta.map(Math.abs);
        V.addTo(state.distance, absoluteDelta);
        state.direction = state.delta.map(Math.sign);
        state._direction = state._delta.map(Math.sign);
        if (!state.first && dt > 0) {
          state.velocity = [absoluteDelta[0] / dt, absoluteDelta[1] / dt];
          state.timeDelta = dt;
        }
      }
    }
    emit() {
      const state = this.state;
      const shared = this.shared;
      const config = this.config;
      if (!state._active) this.clean();
      if ((state._blocked || !state.intentional) && !state._force && !config.triggerAllEvents) return;
      const memo6 = this.handler(_objectSpread2(_objectSpread2(_objectSpread2({}, shared), state), {}, {
        [this.aliasKey]: state.values
      }));
      if (memo6 !== void 0) state.memo = memo6;
    }
    clean() {
      this.eventStore.clean();
      this.timeoutStore.clean();
    }
  };
  function selectAxis([dx, dy], threshold) {
    const absDx = Math.abs(dx);
    const absDy = Math.abs(dy);
    if (absDx > absDy && absDx > threshold) {
      return "x";
    }
    if (absDy > absDx && absDy > threshold) {
      return "y";
    }
    return void 0;
  }
  var CoordinatesEngine = class extends Engine {
    constructor(...args) {
      super(...args);
      _defineProperty(this, "aliasKey", "xy");
    }
    reset() {
      super.reset();
      this.state.axis = void 0;
    }
    init() {
      this.state.offset = [0, 0];
      this.state.lastOffset = [0, 0];
    }
    computeOffset() {
      this.state.offset = V.add(this.state.lastOffset, this.state.movement);
    }
    computeMovement() {
      this.state.movement = V.sub(this.state.offset, this.state.lastOffset);
    }
    axisIntent(event) {
      const state = this.state;
      const config = this.config;
      if (!state.axis && event) {
        const threshold = typeof config.axisThreshold === "object" ? config.axisThreshold[getPointerType(event)] : config.axisThreshold;
        state.axis = selectAxis(state._movement, threshold);
      }
      state._blocked = (config.lockDirection || !!config.axis) && !state.axis || !!config.axis && config.axis !== state.axis;
    }
    restrictToAxis(v3) {
      if (this.config.axis || this.config.lockDirection) {
        switch (this.state.axis) {
          case "x":
            v3[1] = 0;
            break;
          case "y":
            v3[0] = 0;
            break;
        }
      }
    }
  };
  var identity2 = (v3) => v3;
  var DEFAULT_RUBBERBAND = 0.15;
  var commonConfigResolver = {
    enabled(value = true) {
      return value;
    },
    eventOptions(value, _k, config) {
      return _objectSpread2(_objectSpread2({}, config.shared.eventOptions), value);
    },
    preventDefault(value = false) {
      return value;
    },
    triggerAllEvents(value = false) {
      return value;
    },
    rubberband(value = 0) {
      switch (value) {
        case true:
          return [DEFAULT_RUBBERBAND, DEFAULT_RUBBERBAND];
        case false:
          return [0, 0];
        default:
          return V.toVector(value);
      }
    },
    from(value) {
      if (typeof value === "function") return value;
      if (value != null) return V.toVector(value);
    },
    transform(value, _k, config) {
      const transform = value || config.shared.transform;
      this.hasCustomTransform = !!transform;
      if (true) {
        const originalTransform = transform || identity2;
        return (v3) => {
          const r4 = originalTransform(v3);
          if (!isFinite(r4[0]) || !isFinite(r4[1])) {
            console.warn(`[@use-gesture]: config.transform() must produce a valid result, but it was: [${r4[0]},${[1]}]`);
          }
          return r4;
        };
      }
      return transform || identity2;
    },
    threshold(value) {
      return V.toVector(value, 0);
    }
  };
  if (true) {
    Object.assign(commonConfigResolver, {
      domTarget(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`domTarget\` option has been renamed to \`target\`.`);
        }
        return NaN;
      },
      lockDirection(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`lockDirection\` option has been merged with \`axis\`. Use it as in \`{ axis: 'lock' }\``);
        }
        return NaN;
      },
      initial(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`initial\` option has been renamed to \`from\`.`);
        }
        return NaN;
      }
    });
  }
  var DEFAULT_AXIS_THRESHOLD = 0;
  var coordinatesConfigResolver = _objectSpread2(_objectSpread2({}, commonConfigResolver), {}, {
    axis(_v, _k, {
      axis
    }) {
      this.lockDirection = axis === "lock";
      if (!this.lockDirection) return axis;
    },
    axisThreshold(value = DEFAULT_AXIS_THRESHOLD) {
      return value;
    },
    bounds(value = {}) {
      if (typeof value === "function") {
        return (state) => coordinatesConfigResolver.bounds(value(state));
      }
      if ("current" in value) {
        return () => value.current;
      }
      if (typeof HTMLElement === "function" && value instanceof HTMLElement) {
        return value;
      }
      const {
        left = -Infinity,
        right = Infinity,
        top = -Infinity,
        bottom = Infinity
      } = value;
      return [[left, right], [top, bottom]];
    }
  });
  var KEYS_DELTA_MAP = {
    ArrowRight: (displacement, factor = 1) => [displacement * factor, 0],
    ArrowLeft: (displacement, factor = 1) => [-1 * displacement * factor, 0],
    ArrowUp: (displacement, factor = 1) => [0, -1 * displacement * factor],
    ArrowDown: (displacement, factor = 1) => [0, displacement * factor]
  };
  var DragEngine = class extends CoordinatesEngine {
    constructor(...args) {
      super(...args);
      _defineProperty(this, "ingKey", "dragging");
    }
    reset() {
      super.reset();
      const state = this.state;
      state._pointerId = void 0;
      state._pointerActive = false;
      state._keyboardActive = false;
      state._preventScroll = false;
      state._delayed = false;
      state.swipe = [0, 0];
      state.tap = false;
      state.canceled = false;
      state.cancel = this.cancel.bind(this);
    }
    setup() {
      const state = this.state;
      if (state._bounds instanceof HTMLElement) {
        const boundRect = state._bounds.getBoundingClientRect();
        const targetRect = state.currentTarget.getBoundingClientRect();
        const _bounds = {
          left: boundRect.left - targetRect.left + state.offset[0],
          right: boundRect.right - targetRect.right + state.offset[0],
          top: boundRect.top - targetRect.top + state.offset[1],
          bottom: boundRect.bottom - targetRect.bottom + state.offset[1]
        };
        state._bounds = coordinatesConfigResolver.bounds(_bounds);
      }
    }
    cancel() {
      const state = this.state;
      if (state.canceled) return;
      state.canceled = true;
      state._active = false;
      setTimeout(() => {
        this.compute();
        this.emit();
      }, 0);
    }
    setActive() {
      this.state._active = this.state._pointerActive || this.state._keyboardActive;
    }
    clean() {
      this.pointerClean();
      this.state._pointerActive = false;
      this.state._keyboardActive = false;
      super.clean();
    }
    pointerDown(event) {
      const config = this.config;
      const state = this.state;
      if (event.buttons != null && (Array.isArray(config.pointerButtons) ? !config.pointerButtons.includes(event.buttons) : config.pointerButtons !== -1 && config.pointerButtons !== event.buttons)) return;
      const ctrlIds = this.ctrl.setEventIds(event);
      if (config.pointerCapture) {
        event.target.setPointerCapture(event.pointerId);
      }
      if (ctrlIds && ctrlIds.size > 1 && state._pointerActive) return;
      this.start(event);
      this.setupPointer(event);
      state._pointerId = pointerId(event);
      state._pointerActive = true;
      this.computeValues(pointerValues(event));
      this.computeInitial();
      if (config.preventScrollAxis && getPointerType(event) !== "mouse") {
        state._active = false;
        this.setupScrollPrevention(event);
      } else if (config.delay > 0) {
        this.setupDelayTrigger(event);
        if (config.triggerAllEvents) {
          this.compute(event);
          this.emit();
        }
      } else {
        this.startPointerDrag(event);
      }
    }
    startPointerDrag(event) {
      const state = this.state;
      state._active = true;
      state._preventScroll = true;
      state._delayed = false;
      this.compute(event);
      this.emit();
    }
    pointerMove(event) {
      const state = this.state;
      const config = this.config;
      if (!state._pointerActive) return;
      const id3 = pointerId(event);
      if (state._pointerId !== void 0 && id3 !== state._pointerId) return;
      const _values = pointerValues(event);
      if (document.pointerLockElement === event.target) {
        state._delta = [event.movementX, event.movementY];
      } else {
        state._delta = V.sub(_values, state._values);
        this.computeValues(_values);
      }
      V.addTo(state._movement, state._delta);
      this.compute(event);
      if (state._delayed && state.intentional) {
        this.timeoutStore.remove("dragDelay");
        state.active = false;
        this.startPointerDrag(event);
        return;
      }
      if (config.preventScrollAxis && !state._preventScroll) {
        if (state.axis) {
          if (state.axis === config.preventScrollAxis || config.preventScrollAxis === "xy") {
            state._active = false;
            this.clean();
            return;
          } else {
            this.timeoutStore.remove("startPointerDrag");
            this.startPointerDrag(event);
            return;
          }
        } else {
          return;
        }
      }
      this.emit();
    }
    pointerUp(event) {
      this.ctrl.setEventIds(event);
      try {
        if (this.config.pointerCapture && event.target.hasPointerCapture(event.pointerId)) {
          ;
          event.target.releasePointerCapture(event.pointerId);
        }
      } catch (_unused) {
        if (true) {
          console.warn(`[@use-gesture]: If you see this message, it's likely that you're using an outdated version of \`@react-three/fiber\`. 

Please upgrade to the latest version.`);
        }
      }
      const state = this.state;
      const config = this.config;
      if (!state._active || !state._pointerActive) return;
      const id3 = pointerId(event);
      if (state._pointerId !== void 0 && id3 !== state._pointerId) return;
      this.state._pointerActive = false;
      this.setActive();
      this.compute(event);
      const [dx, dy] = state._distance;
      state.tap = dx <= config.tapsThreshold && dy <= config.tapsThreshold;
      if (state.tap && config.filterTaps) {
        state._force = true;
      } else {
        const [_dx, _dy] = state._delta;
        const [_mx, _my] = state._movement;
        const [svx, svy] = config.swipe.velocity;
        const [sx, sy] = config.swipe.distance;
        const sdt = config.swipe.duration;
        if (state.elapsedTime < sdt) {
          const _vx = Math.abs(_dx / state.timeDelta);
          const _vy = Math.abs(_dy / state.timeDelta);
          if (_vx > svx && Math.abs(_mx) > sx) state.swipe[0] = Math.sign(_dx);
          if (_vy > svy && Math.abs(_my) > sy) state.swipe[1] = Math.sign(_dy);
        }
      }
      this.emit();
    }
    pointerClick(event) {
      if (!this.state.tap && event.detail > 0) {
        event.preventDefault();
        event.stopPropagation();
      }
    }
    setupPointer(event) {
      const config = this.config;
      const device = config.device;
      if (true) {
        try {
          if (device === "pointer" && config.preventScrollDelay === void 0) {
            const currentTarget = "uv" in event ? event.sourceEvent.currentTarget : event.currentTarget;
            const style2 = window.getComputedStyle(currentTarget);
            if (style2.touchAction === "auto") {
              console.warn(`[@use-gesture]: The drag target has its \`touch-action\` style property set to \`auto\`. It is recommended to add \`touch-action: 'none'\` so that the drag gesture behaves correctly on touch-enabled devices. For more information read this: https://use-gesture.netlify.app/docs/extras/#touch-action.

This message will only show in development mode. It won't appear in production. If this is intended, you can ignore it.`, currentTarget);
            }
          }
        } catch (_unused2) {
        }
      }
      if (config.pointerLock) {
        event.currentTarget.requestPointerLock();
      }
      if (!config.pointerCapture) {
        this.eventStore.add(this.sharedConfig.window, device, "change", this.pointerMove.bind(this));
        this.eventStore.add(this.sharedConfig.window, device, "end", this.pointerUp.bind(this));
        this.eventStore.add(this.sharedConfig.window, device, "cancel", this.pointerUp.bind(this));
      }
    }
    pointerClean() {
      if (this.config.pointerLock && document.pointerLockElement === this.state.currentTarget) {
        document.exitPointerLock();
      }
    }
    preventScroll(event) {
      if (this.state._preventScroll && event.cancelable) {
        event.preventDefault();
      }
    }
    setupScrollPrevention(event) {
      this.state._preventScroll = false;
      persistEvent(event);
      const remove = this.eventStore.add(this.sharedConfig.window, "touch", "change", this.preventScroll.bind(this), {
        passive: false
      });
      this.eventStore.add(this.sharedConfig.window, "touch", "end", remove);
      this.eventStore.add(this.sharedConfig.window, "touch", "cancel", remove);
      this.timeoutStore.add("startPointerDrag", this.startPointerDrag.bind(this), this.config.preventScrollDelay, event);
    }
    setupDelayTrigger(event) {
      this.state._delayed = true;
      this.timeoutStore.add("dragDelay", () => {
        this.state._step = [0, 0];
        this.startPointerDrag(event);
      }, this.config.delay);
    }
    keyDown(event) {
      const deltaFn = KEYS_DELTA_MAP[event.key];
      if (deltaFn) {
        const state = this.state;
        const factor = event.shiftKey ? 10 : event.altKey ? 0.1 : 1;
        this.start(event);
        state._delta = deltaFn(this.config.keyboardDisplacement, factor);
        state._keyboardActive = true;
        V.addTo(state._movement, state._delta);
        this.compute(event);
        this.emit();
      }
    }
    keyUp(event) {
      if (!(event.key in KEYS_DELTA_MAP)) return;
      this.state._keyboardActive = false;
      this.setActive();
      this.compute(event);
      this.emit();
    }
    bind(bindFunction) {
      const device = this.config.device;
      bindFunction(device, "start", this.pointerDown.bind(this));
      if (this.config.pointerCapture) {
        bindFunction(device, "change", this.pointerMove.bind(this));
        bindFunction(device, "end", this.pointerUp.bind(this));
        bindFunction(device, "cancel", this.pointerUp.bind(this));
        bindFunction("lostPointerCapture", "", this.pointerUp.bind(this));
      }
      if (this.config.keys) {
        bindFunction("key", "down", this.keyDown.bind(this));
        bindFunction("key", "up", this.keyUp.bind(this));
      }
      if (this.config.filterTaps) {
        bindFunction("click", "", this.pointerClick.bind(this), {
          capture: true,
          passive: false
        });
      }
    }
  };
  function persistEvent(event) {
    "persist" in event && typeof event.persist === "function" && event.persist();
  }
  var isBrowser3 = typeof window !== "undefined" && window.document && window.document.createElement;
  function supportsTouchEvents() {
    return isBrowser3 && "ontouchstart" in window;
  }
  function isTouchScreen() {
    return supportsTouchEvents() || isBrowser3 && window.navigator.maxTouchPoints > 1;
  }
  function supportsPointerEvents() {
    return isBrowser3 && "onpointerdown" in window;
  }
  function supportsPointerLock() {
    return isBrowser3 && "exitPointerLock" in window.document;
  }
  function supportsGestureEvents() {
    try {
      return "constructor" in GestureEvent;
    } catch (e3) {
      return false;
    }
  }
  var SUPPORT = {
    isBrowser: isBrowser3,
    gesture: supportsGestureEvents(),
    touch: supportsTouchEvents(),
    touchscreen: isTouchScreen(),
    pointer: supportsPointerEvents(),
    pointerLock: supportsPointerLock()
  };
  var DEFAULT_PREVENT_SCROLL_DELAY = 250;
  var DEFAULT_DRAG_DELAY = 180;
  var DEFAULT_SWIPE_VELOCITY = 0.5;
  var DEFAULT_SWIPE_DISTANCE = 50;
  var DEFAULT_SWIPE_DURATION = 250;
  var DEFAULT_KEYBOARD_DISPLACEMENT = 10;
  var DEFAULT_DRAG_AXIS_THRESHOLD = {
    mouse: 0,
    touch: 0,
    pen: 8
  };
  var dragConfigResolver = _objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
    device(_v, _k, {
      pointer: {
        touch = false,
        lock: lock2 = false,
        mouse = false
      } = {}
    }) {
      this.pointerLock = lock2 && SUPPORT.pointerLock;
      if (SUPPORT.touch && touch) return "touch";
      if (this.pointerLock) return "mouse";
      if (SUPPORT.pointer && !mouse) return "pointer";
      if (SUPPORT.touch) return "touch";
      return "mouse";
    },
    preventScrollAxis(value, _k, {
      preventScroll
    }) {
      this.preventScrollDelay = typeof preventScroll === "number" ? preventScroll : preventScroll || preventScroll === void 0 && value ? DEFAULT_PREVENT_SCROLL_DELAY : void 0;
      if (!SUPPORT.touchscreen || preventScroll === false) return void 0;
      return value ? value : preventScroll !== void 0 ? "y" : void 0;
    },
    pointerCapture(_v, _k, {
      pointer: {
        capture = true,
        buttons = 1,
        keys = true
      } = {}
    }) {
      this.pointerButtons = buttons;
      this.keys = keys;
      return !this.pointerLock && this.device === "pointer" && capture;
    },
    threshold(value, _k, {
      filterTaps = false,
      tapsThreshold = 3,
      axis = void 0
    }) {
      const threshold = V.toVector(value, filterTaps ? tapsThreshold : axis ? 1 : 0);
      this.filterTaps = filterTaps;
      this.tapsThreshold = tapsThreshold;
      return threshold;
    },
    swipe({
      velocity = DEFAULT_SWIPE_VELOCITY,
      distance: distance2 = DEFAULT_SWIPE_DISTANCE,
      duration = DEFAULT_SWIPE_DURATION
    } = {}) {
      return {
        velocity: this.transform(V.toVector(velocity)),
        distance: this.transform(V.toVector(distance2)),
        duration
      };
    },
    delay(value = 0) {
      switch (value) {
        case true:
          return DEFAULT_DRAG_DELAY;
        case false:
          return 0;
        default:
          return value;
      }
    },
    axisThreshold(value) {
      if (!value) return DEFAULT_DRAG_AXIS_THRESHOLD;
      return _objectSpread2(_objectSpread2({}, DEFAULT_DRAG_AXIS_THRESHOLD), value);
    },
    keyboardDisplacement(value = DEFAULT_KEYBOARD_DISPLACEMENT) {
      return value;
    }
  });
  if (true) {
    Object.assign(dragConfigResolver, {
      useTouch(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`useTouch\` option has been renamed to \`pointer.touch\`. Use it as in \`{ pointer: { touch: true } }\`.`);
        }
        return NaN;
      },
      experimental_preventWindowScrollY(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`experimental_preventWindowScrollY\` option has been renamed to \`preventScroll\`.`);
        }
        return NaN;
      },
      swipeVelocity(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`swipeVelocity\` option has been renamed to \`swipe.velocity\`. Use it as in \`{ swipe: { velocity: 0.5 } }\`.`);
        }
        return NaN;
      },
      swipeDistance(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`swipeDistance\` option has been renamed to \`swipe.distance\`. Use it as in \`{ swipe: { distance: 50 } }\`.`);
        }
        return NaN;
      },
      swipeDuration(value) {
        if (value !== void 0) {
          throw Error(`[@use-gesture]: \`swipeDuration\` option has been renamed to \`swipe.duration\`. Use it as in \`{ swipe: { duration: 250 } }\`.`);
        }
        return NaN;
      }
    });
  }
  var pinchConfigResolver = _objectSpread2(_objectSpread2({}, commonConfigResolver), {}, {
    device(_v, _k, {
      shared,
      pointer: {
        touch = false
      } = {}
    }) {
      const sharedConfig = shared;
      if (sharedConfig.target && !SUPPORT.touch && SUPPORT.gesture) return "gesture";
      if (SUPPORT.touch && touch) return "touch";
      if (SUPPORT.touchscreen) {
        if (SUPPORT.pointer) return "pointer";
        if (SUPPORT.touch) return "touch";
      }
    },
    bounds(_v, _k, {
      scaleBounds = {},
      angleBounds = {}
    }) {
      const _scaleBounds = (state) => {
        const D = assignDefault(call(scaleBounds, state), {
          min: -Infinity,
          max: Infinity
        });
        return [D.min, D.max];
      };
      const _angleBounds = (state) => {
        const A2 = assignDefault(call(angleBounds, state), {
          min: -Infinity,
          max: Infinity
        });
        return [A2.min, A2.max];
      };
      if (typeof scaleBounds !== "function" && typeof angleBounds !== "function") return [_scaleBounds(), _angleBounds()];
      return (state) => [_scaleBounds(state), _angleBounds(state)];
    },
    threshold(value, _k, config) {
      this.lockDirection = config.axis === "lock";
      const threshold = V.toVector(value, this.lockDirection ? [0.1, 3] : 0);
      return threshold;
    },
    modifierKey(value) {
      if (value === void 0) return "ctrlKey";
      return value;
    },
    pinchOnWheel(value = true) {
      return value;
    }
  });
  var moveConfigResolver = _objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
    mouseOnly: (value = true) => value
  });
  var hoverConfigResolver = _objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
    mouseOnly: (value = true) => value
  });
  var EngineMap = /* @__PURE__ */ new Map();
  var ConfigResolverMap = /* @__PURE__ */ new Map();
  function registerAction(action) {
    EngineMap.set(action.key, action.engine);
    ConfigResolverMap.set(action.key, action.resolver);
  }
  var dragAction = {
    key: "drag",
    engine: DragEngine,
    resolver: dragConfigResolver
  };

  // node_modules/@use-gesture/react/dist/use-gesture-react.esm.js
  var import_react86 = __toESM(require_react());

  // node_modules/@use-gesture/core/dist/use-gesture-core.esm.js
  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i3;
    for (i3 = 0; i3 < sourceKeys.length; i3++) {
      key = sourceKeys[i3];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }
    return target;
  }
  function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};
    var target = _objectWithoutPropertiesLoose(source, excluded);
    var key, i3;
    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
      for (i3 = 0; i3 < sourceSymbolKeys.length; i3++) {
        key = sourceSymbolKeys[i3];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }
    return target;
  }
  var sharedConfigResolver = {
    target(value) {
      if (value) {
        return () => "current" in value ? value.current : value;
      }
      return void 0;
    },
    enabled(value = true) {
      return value;
    },
    window(value = SUPPORT.isBrowser ? window : void 0) {
      return value;
    },
    eventOptions({
      passive = true,
      capture = false
    } = {}) {
      return {
        passive,
        capture
      };
    },
    transform(value) {
      return value;
    }
  };
  var _excluded = ["target", "eventOptions", "window", "enabled", "transform"];
  function resolveWith(config = {}, resolvers) {
    const result = {};
    for (const [key, resolver] of Object.entries(resolvers)) {
      switch (typeof resolver) {
        case "function":
          if (true) {
            const r4 = resolver.call(result, config[key], key, config);
            if (!Number.isNaN(r4)) result[key] = r4;
          } else {
            result[key] = resolver.call(result, config[key], key, config);
          }
          break;
        case "object":
          result[key] = resolveWith(config[key], resolver);
          break;
        case "boolean":
          if (resolver) result[key] = config[key];
          break;
      }
    }
    return result;
  }
  function parse2(newConfig, gestureKey, _config = {}) {
    const _ref9 = newConfig, {
      target,
      eventOptions,
      window: window2,
      enabled,
      transform
    } = _ref9, rest = _objectWithoutProperties(_ref9, _excluded);
    _config.shared = resolveWith({
      target,
      eventOptions,
      window: window2,
      enabled,
      transform
    }, sharedConfigResolver);
    if (gestureKey) {
      const resolver = ConfigResolverMap.get(gestureKey);
      _config[gestureKey] = resolveWith(_objectSpread2({
        shared: _config.shared
      }, rest), resolver);
    } else {
      for (const key in rest) {
        const resolver = ConfigResolverMap.get(key);
        if (resolver) {
          _config[key] = resolveWith(_objectSpread2({
            shared: _config.shared
          }, rest[key]), resolver);
        } else if (true) {
          if (!["drag", "pinch", "scroll", "wheel", "move", "hover"].includes(key)) {
            if (key === "domTarget") {
              throw Error(`[@use-gesture]: \`domTarget\` option has been renamed to \`target\`.`);
            }
            console.warn(`[@use-gesture]: Unknown config key \`${key}\` was used. Please read the documentation for further information.`);
          }
        }
      }
    }
    return _config;
  }
  var EventStore = class {
    constructor(ctrl, gestureKey) {
      _defineProperty(this, "_listeners", /* @__PURE__ */ new Set());
      this._ctrl = ctrl;
      this._gestureKey = gestureKey;
    }
    add(element, device, action, handler, options2) {
      const listeners = this._listeners;
      const type = toDomEventType(device, action);
      const _options = this._gestureKey ? this._ctrl.config[this._gestureKey].eventOptions : {};
      const eventOptions = _objectSpread2(_objectSpread2({}, _options), options2);
      element.addEventListener(type, handler, eventOptions);
      const remove = () => {
        element.removeEventListener(type, handler, eventOptions);
        listeners.delete(remove);
      };
      listeners.add(remove);
      return remove;
    }
    clean() {
      this._listeners.forEach((remove) => remove());
      this._listeners.clear();
    }
  };
  var TimeoutStore = class {
    constructor() {
      _defineProperty(this, "_timeouts", /* @__PURE__ */ new Map());
    }
    add(key, callback, ms = 140, ...args) {
      this.remove(key);
      this._timeouts.set(key, window.setTimeout(callback, ms, ...args));
    }
    remove(key) {
      const timeout = this._timeouts.get(key);
      if (timeout) window.clearTimeout(timeout);
    }
    clean() {
      this._timeouts.forEach((timeout) => void window.clearTimeout(timeout));
      this._timeouts.clear();
    }
  };
  var Controller = class {
    constructor(handlers) {
      _defineProperty(this, "gestures", /* @__PURE__ */ new Set());
      _defineProperty(this, "_targetEventStore", new EventStore(this));
      _defineProperty(this, "gestureEventStores", {});
      _defineProperty(this, "gestureTimeoutStores", {});
      _defineProperty(this, "handlers", {});
      _defineProperty(this, "config", {});
      _defineProperty(this, "pointerIds", /* @__PURE__ */ new Set());
      _defineProperty(this, "touchIds", /* @__PURE__ */ new Set());
      _defineProperty(this, "state", {
        shared: {
          shiftKey: false,
          metaKey: false,
          ctrlKey: false,
          altKey: false
        }
      });
      resolveGestures(this, handlers);
    }
    setEventIds(event) {
      if (isTouch(event)) {
        this.touchIds = new Set(touchIds(event));
        return this.touchIds;
      } else if ("pointerId" in event) {
        if (event.type === "pointerup" || event.type === "pointercancel") this.pointerIds.delete(event.pointerId);
        else if (event.type === "pointerdown") this.pointerIds.add(event.pointerId);
        return this.pointerIds;
      }
    }
    applyHandlers(handlers, nativeHandlers) {
      this.handlers = handlers;
      this.nativeHandlers = nativeHandlers;
    }
    applyConfig(config, gestureKey) {
      this.config = parse2(config, gestureKey, this.config);
    }
    clean() {
      this._targetEventStore.clean();
      for (const key of this.gestures) {
        this.gestureEventStores[key].clean();
        this.gestureTimeoutStores[key].clean();
      }
    }
    effect() {
      if (this.config.shared.target) this.bind();
      return () => this._targetEventStore.clean();
    }
    bind(...args) {
      const sharedConfig = this.config.shared;
      const props = {};
      let target;
      if (sharedConfig.target) {
        target = sharedConfig.target();
        if (!target) return;
      }
      if (sharedConfig.enabled) {
        for (const gestureKey of this.gestures) {
          const gestureConfig = this.config[gestureKey];
          const bindFunction = bindToProps(props, gestureConfig.eventOptions, !!target);
          if (gestureConfig.enabled) {
            const Engine2 = EngineMap.get(gestureKey);
            new Engine2(this, args, gestureKey).bind(bindFunction);
          }
        }
        const nativeBindFunction = bindToProps(props, sharedConfig.eventOptions, !!target);
        for (const eventKey in this.nativeHandlers) {
          nativeBindFunction(eventKey, "", (event) => this.nativeHandlers[eventKey](_objectSpread2(_objectSpread2({}, this.state.shared), {}, {
            event,
            args
          })), void 0, true);
        }
      }
      for (const handlerProp in props) {
        props[handlerProp] = chain2(...props[handlerProp]);
      }
      if (!target) return props;
      for (const handlerProp in props) {
        const {
          device,
          capture,
          passive
        } = parseProp(handlerProp);
        this._targetEventStore.add(target, device, "", props[handlerProp], {
          capture,
          passive
        });
      }
    }
  };
  function setupGesture2(ctrl, gestureKey) {
    ctrl.gestures.add(gestureKey);
    ctrl.gestureEventStores[gestureKey] = new EventStore(ctrl, gestureKey);
    ctrl.gestureTimeoutStores[gestureKey] = new TimeoutStore();
  }
  function resolveGestures(ctrl, internalHandlers) {
    if (internalHandlers.drag) setupGesture2(ctrl, "drag");
    if (internalHandlers.wheel) setupGesture2(ctrl, "wheel");
    if (internalHandlers.scroll) setupGesture2(ctrl, "scroll");
    if (internalHandlers.move) setupGesture2(ctrl, "move");
    if (internalHandlers.pinch) setupGesture2(ctrl, "pinch");
    if (internalHandlers.hover) setupGesture2(ctrl, "hover");
  }
  var bindToProps = (props, eventOptions, withPassiveOption) => (device, action, handler, options2 = {}, isNative = false) => {
    var _options$capture, _options$passive;
    const capture = (_options$capture = options2.capture) !== null && _options$capture !== void 0 ? _options$capture : eventOptions.capture;
    const passive = (_options$passive = options2.passive) !== null && _options$passive !== void 0 ? _options$passive : eventOptions.passive;
    let handlerProp = isNative ? device : toHandlerProp(device, action, capture);
    if (withPassiveOption && passive) handlerProp += "Passive";
    props[handlerProp] = props[handlerProp] || [];
    props[handlerProp].push(handler);
  };

  // node_modules/@use-gesture/react/dist/use-gesture-react.esm.js
  function useRecognizers(handlers, config = {}, gestureKey, nativeHandlers) {
    const ctrl = import_react86.default.useMemo(() => new Controller(handlers), []);
    ctrl.applyHandlers(handlers, nativeHandlers);
    ctrl.applyConfig(config, gestureKey);
    import_react86.default.useEffect(ctrl.effect.bind(ctrl));
    import_react86.default.useEffect(() => {
      return ctrl.clean.bind(ctrl);
    }, []);
    if (config.target === void 0) {
      return ctrl.bind.bind(ctrl);
    }
    return void 0;
  }
  function useDrag(handler, config) {
    registerAction(dragAction);
    return useRecognizers({
      drag: handler
    }, config || {}, "drag");
  }

  // packages/components/build-module/input-control/input-field.mjs
  var import_element29 = __toESM(require_element(), 1);

  // packages/components/build-module/input-control/utils.mjs
  var import_element27 = __toESM(require_element(), 1);
  function getDragCursor(dragDirection) {
    let dragCursor = "ns-resize";
    switch (dragDirection) {
      case "n":
      case "s":
        dragCursor = "ns-resize";
        break;
      case "e":
      case "w":
        dragCursor = "ew-resize";
        break;
    }
    return dragCursor;
  }
  function useDragCursor(isDragging2, dragDirection) {
    const dragCursor = getDragCursor(dragDirection);
    (0, import_element27.useEffect)(() => {
      if (isDragging2) {
        document.documentElement.style.cursor = dragCursor;
      } else {
        document.documentElement.style.cursor = null;
      }
    }, [isDragging2, dragCursor]);
    return dragCursor;
  }
  function useDraft(props) {
    const previousValueRef = (0, import_element27.useRef)(props.value);
    const [draft, setDraft] = (0, import_element27.useState)({});
    const value = draft.value !== void 0 ? draft.value : props.value;
    (0, import_element27.useLayoutEffect)(() => {
      const {
        current: previousValue
      } = previousValueRef;
      previousValueRef.current = props.value;
      if (draft.value !== void 0 && !draft.isStale) {
        setDraft({
          ...draft,
          isStale: true
        });
      } else if (draft.isStale && props.value !== previousValue) {
        setDraft({});
      }
    }, [props.value, draft]);
    const onChange = (nextValue, extra) => {
      setDraft((current) => Object.assign(current, {
        value: nextValue,
        isStale: false
      }));
      props.onChange(nextValue, extra);
    };
    const onBlur = (event) => {
      setDraft({});
      props.onBlur?.(event);
    };
    return {
      value,
      onBlur,
      onChange
    };
  }

  // packages/components/build-module/input-control/reducer/reducer.mjs
  var import_element28 = __toESM(require_element(), 1);

  // packages/components/build-module/input-control/reducer/state.mjs
  var initialStateReducer = (state) => state;
  var initialInputControlState = {
    error: null,
    initialValue: "",
    isDirty: false,
    isDragEnabled: false,
    isDragging: false,
    isPressEnterToChange: false,
    value: ""
  };

  // packages/components/build-module/input-control/reducer/actions.mjs
  var CHANGE = "CHANGE";
  var COMMIT = "COMMIT";
  var CONTROL = "CONTROL";
  var DRAG_END = "DRAG_END";
  var DRAG_START = "DRAG_START";
  var DRAG = "DRAG";
  var INVALIDATE = "INVALIDATE";
  var PRESS_DOWN = "PRESS_DOWN";
  var PRESS_ENTER = "PRESS_ENTER";
  var PRESS_UP = "PRESS_UP";
  var RESET = "RESET";

  // packages/components/build-module/input-control/reducer/reducer.mjs
  function mergeInitialState(initialState2 = initialInputControlState) {
    const {
      value
    } = initialState2;
    return {
      ...initialInputControlState,
      ...initialState2,
      initialValue: value
    };
  }
  function inputControlStateReducer(composedStateReducers) {
    return (state, action) => {
      const nextState = {
        ...state
      };
      switch (action.type) {
        /*
         * Controlled updates
         */
        case CONTROL:
          nextState.value = action.payload.value;
          nextState.isDirty = false;
          nextState._event = void 0;
          return nextState;
        /**
         * Keyboard events
         */
        case PRESS_UP:
          nextState.isDirty = false;
          break;
        case PRESS_DOWN:
          nextState.isDirty = false;
          break;
        /**
         * Drag events
         */
        case DRAG_START:
          nextState.isDragging = true;
          break;
        case DRAG_END:
          nextState.isDragging = false;
          break;
        /**
         * Input events
         */
        case CHANGE:
          nextState.error = null;
          nextState.value = action.payload.value;
          if (state.isPressEnterToChange) {
            nextState.isDirty = true;
          }
          break;
        case COMMIT:
          nextState.value = action.payload.value;
          nextState.isDirty = false;
          break;
        case RESET:
          nextState.error = null;
          nextState.isDirty = false;
          nextState.value = action.payload.value || state.initialValue;
          break;
        /**
         * Validation
         */
        case INVALIDATE:
          nextState.error = action.payload.error;
          break;
      }
      nextState._event = action.payload.event;
      return composedStateReducers(nextState, action);
    };
  }
  function useInputControlStateReducer(stateReducer = initialStateReducer, initialState2 = initialInputControlState, onChangeHandler) {
    const [state, dispatch] = (0, import_element28.useReducer)(inputControlStateReducer(stateReducer), mergeInitialState(initialState2));
    const createChangeEvent = (type) => (nextValue, event) => {
      dispatch({
        type,
        payload: {
          value: nextValue,
          event
        }
      });
    };
    const createKeyEvent = (type) => (event) => {
      dispatch({
        type,
        payload: {
          event
        }
      });
    };
    const createDragEvent = (type) => (payload) => {
      dispatch({
        type,
        payload
      });
    };
    const change = createChangeEvent(CHANGE);
    const invalidate = (error, event) => dispatch({
      type: INVALIDATE,
      payload: {
        error,
        event
      }
    });
    const reset = createChangeEvent(RESET);
    const commit = createChangeEvent(COMMIT);
    const dragStart = createDragEvent(DRAG_START);
    const drag2 = createDragEvent(DRAG);
    const dragEnd = createDragEvent(DRAG_END);
    const pressUp = createKeyEvent(PRESS_UP);
    const pressDown = createKeyEvent(PRESS_DOWN);
    const pressEnter = createKeyEvent(PRESS_ENTER);
    const currentStateRef = (0, import_element28.useRef)(state);
    const refPropsRef = (0, import_element28.useRef)({
      value: initialState2.value,
      onChangeHandler
    });
    (0, import_element28.useLayoutEffect)(() => {
      currentStateRef.current = state;
      refPropsRef.current = {
        value: initialState2.value,
        onChangeHandler
      };
    });
    (0, import_element28.useLayoutEffect)(() => {
      if (currentStateRef.current._event !== void 0 && state.value !== refPropsRef.current.value && !state.isDirty) {
        refPropsRef.current.onChangeHandler(state.value ?? "", {
          event: currentStateRef.current._event
        });
      }
    }, [state.value, state.isDirty]);
    (0, import_element28.useLayoutEffect)(() => {
      if (initialState2.value !== currentStateRef.current.value && !currentStateRef.current.isDirty) {
        dispatch({
          type: CONTROL,
          payload: {
            value: initialState2.value ?? ""
          }
        });
      }
    }, [initialState2.value]);
    return {
      change,
      commit,
      dispatch,
      drag: drag2,
      dragEnd,
      dragStart,
      invalidate,
      pressDown,
      pressEnter,
      pressUp,
      reset,
      state
    };
  }

  // packages/components/build-module/utils/with-ignore-ime-events.mjs
  function withIgnoreIMEEvents(handler) {
    return (event) => {
      const {
        isComposing
      } = "nativeEvent" in event ? event.nativeEvent : event;
      if (isComposing || // Workaround for Mac Safari where the final Enter/Backspace of an IME composition
      // is `isComposing=false`, even though it's technically still part of the composition.
      // These can only be detected by keyCode.
      event.keyCode === 229) {
        return;
      }
      handler(event);
    };
  }

  // packages/components/build-module/input-control/input-field.mjs
  var import_jsx_runtime90 = __toESM(require_jsx_runtime(), 1);
  var noop4 = () => {
  };
  function InputField({
    disabled = false,
    dragDirection = "n",
    dragThreshold = 10,
    id: id3,
    isDragEnabled = false,
    isPressEnterToChange = false,
    onBlur = noop4,
    onChange = noop4,
    onDrag = noop4,
    onDragEnd = noop4,
    onDragStart = noop4,
    onKeyDown = noop4,
    onValidate = noop4,
    size: size4 = "default",
    stateReducer = (state) => state,
    value: valueProp,
    type,
    ...props
  }, ref) {
    const {
      // State.
      state,
      // Actions.
      change,
      commit,
      drag: drag2,
      dragEnd,
      dragStart,
      invalidate,
      pressDown,
      pressEnter,
      pressUp,
      reset
    } = useInputControlStateReducer(stateReducer, {
      isDragEnabled,
      value: valueProp,
      isPressEnterToChange
    }, onChange);
    const {
      value,
      isDragging: isDragging2,
      isDirty
    } = state;
    const wasDirtyOnBlur = (0, import_element29.useRef)(false);
    const dragCursor = useDragCursor(isDragging2, dragDirection);
    const handleOnBlur = (event) => {
      onBlur(event);
      if (isDirty || !event.target.validity.valid) {
        wasDirtyOnBlur.current = true;
        handleOnCommit(event);
      }
    };
    const handleOnChange = (event) => {
      const nextValue = event.target.value;
      change(nextValue, event);
    };
    const handleOnCommit = (event) => {
      const nextValue = event.currentTarget.value;
      try {
        onValidate(nextValue);
        commit(nextValue, event);
      } catch (err) {
        invalidate(err, event);
      }
    };
    const handleOnKeyDown = (event) => {
      const {
        key
      } = event;
      onKeyDown(event);
      switch (key) {
        case "ArrowUp":
          pressUp(event);
          break;
        case "ArrowDown":
          pressDown(event);
          break;
        case "Enter":
          pressEnter(event);
          if (isPressEnterToChange) {
            event.preventDefault();
            handleOnCommit(event);
          }
          break;
        case "Escape":
          if (isPressEnterToChange && isDirty) {
            event.preventDefault();
            reset(valueProp, event);
          }
          break;
      }
    };
    const dragGestureProps = useDrag((dragProps2) => {
      const {
        distance: distance2,
        dragging,
        event,
        target
      } = dragProps2;
      dragProps2.event = {
        ...dragProps2.event,
        target
      };
      if (!distance2) {
        return;
      }
      event.stopPropagation();
      if (!dragging) {
        onDragEnd(dragProps2);
        dragEnd(dragProps2);
        return;
      }
      onDrag(dragProps2);
      drag2(dragProps2);
      if (!isDragging2) {
        onDragStart(dragProps2);
        dragStart(dragProps2);
      }
    }, {
      axis: dragDirection === "e" || dragDirection === "w" ? "x" : "y",
      threshold: dragThreshold,
      enabled: isDragEnabled,
      pointer: {
        capture: false
      }
    });
    const dragProps = isDragEnabled ? dragGestureProps() : {};
    return /* @__PURE__ */ (0, import_jsx_runtime90.jsx)(Input, {
      ...props,
      ...dragProps,
      className: "components-input-control__input",
      disabled,
      dragCursor,
      isDragging: isDragging2,
      id: id3,
      onBlur: handleOnBlur,
      onChange: handleOnChange,
      onKeyDown: withIgnoreIMEEvents(handleOnKeyDown),
      ref,
      inputSize: size4,
      value: value ?? "",
      type
    });
  }
  var ForwardedComponent = (0, import_element29.forwardRef)(InputField);
  var input_field_default = ForwardedComponent;

  // packages/components/build-module/base-control/index.mjs
  var import_element30 = __toESM(require_element(), 1);

  // packages/components/build-module/base-control/styles/base-control-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__5() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Wrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "ej5x27r4"
  } : {
    target: "ej5x27r4",
    label: "Wrapper"
  })("font-family:", font("default.fontFamily"), ";font-size:", font("default.fontSize"), ";", boxSizingReset, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJhc2UtY29udHJvbC1zdHlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBWWlDIiwiZmlsZSI6ImJhc2UtY29udHJvbC1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5cbi8qKlxuICogSW50ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGJhc2VMYWJlbFR5cG9ncmFwaHksIGJveFNpemluZ1Jlc2V0LCBmb250LCBDT0xPUlMgfSBmcm9tICcuLi8uLi91dGlscyc7XG5pbXBvcnQgeyBzcGFjZSB9IGZyb20gJy4uLy4uL3V0aWxzL3NwYWNlJztcblxuZXhwb3J0IGNvbnN0IFdyYXBwZXIgPSBzdHlsZWQuZGl2YFxuXHRmb250LWZhbWlseTogJHsgZm9udCggJ2RlZmF1bHQuZm9udEZhbWlseScgKSB9O1xuXHRmb250LXNpemU6ICR7IGZvbnQoICdkZWZhdWx0LmZvbnRTaXplJyApIH07XG5cblx0JHsgYm94U2l6aW5nUmVzZXQgfVxuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEZpZWxkID0gc3R5bGVkLmRpdmBcblx0LmNvbXBvbmVudHMtcGFuZWxfX3JvdyAmIHtcblx0XHRtYXJnaW4tYm90dG9tOiBpbmhlcml0O1xuXHR9XG5gO1xuXG5jb25zdCBsYWJlbFN0eWxlcyA9IGNzc2Bcblx0JHsgYmFzZUxhYmVsVHlwb2dyYXBoeSB9O1xuXG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRtYXJnaW4tYm90dG9tOiAkeyBzcGFjZSggMiApIH07XG5cdC8qKlxuXHQgKiBSZW1vdmVzIENocm9tZS9TYWZhcmkvRmlyZWZveCB1c2VyIGFnZW50IHN0eWxlc2hlZXQgcGFkZGluZyBmcm9tXG5cdCAqIFN0eWxlZExhYmVsIHdoZW4gaXQgaXMgcmVuZGVyZWQgYXMgYSBsZWdlbmQuXG5cdCAqL1xuXHRwYWRkaW5nOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZExhYmVsID0gc3R5bGVkLmxhYmVsYFxuXHQkeyBsYWJlbFN0eWxlcyB9XG5gO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkSGVscCA9IHN0eWxlZC5wYFxuXHRtYXJnaW4tdG9wOiAkeyBzcGFjZSggMiApIH07XG5cdG1hcmdpbi1ib3R0b206IDA7XG5cdGZvbnQtc2l6ZTogJHsgZm9udCggJ2hlbHBUZXh0LmZvbnRTaXplJyApIH07XG5cdGZvbnQtc3R5bGU6IG5vcm1hbDtcblx0Y29sb3I6ICR7IENPTE9SUy5ncmF5WyA3MDAgXSB9O1xuXHR0ZXh0LXdyYXA6IHByZXR0eTtcbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRWaXN1YWxMYWJlbCA9IHN0eWxlZC5zcGFuYFxuXHQkeyBsYWJlbFN0eWxlcyB9XG5gO1xuIl19 */"));
  var StyledField = /* @__PURE__ */ createStyled("div", false ? {
    target: "ej5x27r3"
  } : {
    target: "ej5x27r3",
    label: "StyledField"
  })(false ? {
    name: "1chyuqs",
    styles: ".components-panel__row &{margin-bottom:inherit;}"
  } : {
    name: "1chyuqs",
    styles: ".components-panel__row &{margin-bottom:inherit;}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJhc2UtY29udHJvbC1zdHlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJxQyIsImZpbGUiOiJiYXNlLWNvbnRyb2wtc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBiYXNlTGFiZWxUeXBvZ3JhcGh5LCBib3hTaXppbmdSZXNldCwgZm9udCwgQ09MT1JTIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0Zm9udC1mYW1pbHk6ICR7IGZvbnQoICdkZWZhdWx0LmZvbnRGYW1pbHknICkgfTtcblx0Zm9udC1zaXplOiAkeyBmb250KCAnZGVmYXVsdC5mb250U2l6ZScgKSB9O1xuXG5cdCR7IGJveFNpemluZ1Jlc2V0IH1cbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRGaWVsZCA9IHN0eWxlZC5kaXZgXG5cdC5jb21wb25lbnRzLXBhbmVsX19yb3cgJiB7XG5cdFx0bWFyZ2luLWJvdHRvbTogaW5oZXJpdDtcblx0fVxuYDtcblxuY29uc3QgbGFiZWxTdHlsZXMgPSBjc3NgXG5cdCR7IGJhc2VMYWJlbFR5cG9ncmFwaHkgfTtcblxuXHRkaXNwbGF5OiBibG9jaztcblx0bWFyZ2luLWJvdHRvbTogJHsgc3BhY2UoIDIgKSB9O1xuXHQvKipcblx0ICogUmVtb3ZlcyBDaHJvbWUvU2FmYXJpL0ZpcmVmb3ggdXNlciBhZ2VudCBzdHlsZXNoZWV0IHBhZGRpbmcgZnJvbVxuXHQgKiBTdHlsZWRMYWJlbCB3aGVuIGl0IGlzIHJlbmRlcmVkIGFzIGEgbGVnZW5kLlxuXHQgKi9cblx0cGFkZGluZzogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMYWJlbCA9IHN0eWxlZC5sYWJlbGBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEhlbHAgPSBzdHlsZWQucGBcblx0bWFyZ2luLXRvcDogJHsgc3BhY2UoIDIgKSB9O1xuXHRtYXJnaW4tYm90dG9tOiAwO1xuXHRmb250LXNpemU6ICR7IGZvbnQoICdoZWxwVGV4dC5mb250U2l6ZScgKSB9O1xuXHRmb250LXN0eWxlOiBub3JtYWw7XG5cdGNvbG9yOiAkeyBDT0xPUlMuZ3JheVsgNzAwIF0gfTtcblx0dGV4dC13cmFwOiBwcmV0dHk7XG5gO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkVmlzdWFsTGFiZWwgPSBzdHlsZWQuc3BhbmBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcbiJdfQ== */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__5
  });
  var labelStyles = /* @__PURE__ */ css(baseLabelTypography, ";display:block;margin-bottom:", space(2), ";padding:0;" + (false ? "" : ";label:labelStyles;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJhc2UtY29udHJvbC1zdHlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBeUJ1QiIsImZpbGUiOiJiYXNlLWNvbnRyb2wtc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBiYXNlTGFiZWxUeXBvZ3JhcGh5LCBib3hTaXppbmdSZXNldCwgZm9udCwgQ09MT1JTIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0Zm9udC1mYW1pbHk6ICR7IGZvbnQoICdkZWZhdWx0LmZvbnRGYW1pbHknICkgfTtcblx0Zm9udC1zaXplOiAkeyBmb250KCAnZGVmYXVsdC5mb250U2l6ZScgKSB9O1xuXG5cdCR7IGJveFNpemluZ1Jlc2V0IH1cbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRGaWVsZCA9IHN0eWxlZC5kaXZgXG5cdC5jb21wb25lbnRzLXBhbmVsX19yb3cgJiB7XG5cdFx0bWFyZ2luLWJvdHRvbTogaW5oZXJpdDtcblx0fVxuYDtcblxuY29uc3QgbGFiZWxTdHlsZXMgPSBjc3NgXG5cdCR7IGJhc2VMYWJlbFR5cG9ncmFwaHkgfTtcblxuXHRkaXNwbGF5OiBibG9jaztcblx0bWFyZ2luLWJvdHRvbTogJHsgc3BhY2UoIDIgKSB9O1xuXHQvKipcblx0ICogUmVtb3ZlcyBDaHJvbWUvU2FmYXJpL0ZpcmVmb3ggdXNlciBhZ2VudCBzdHlsZXNoZWV0IHBhZGRpbmcgZnJvbVxuXHQgKiBTdHlsZWRMYWJlbCB3aGVuIGl0IGlzIHJlbmRlcmVkIGFzIGEgbGVnZW5kLlxuXHQgKi9cblx0cGFkZGluZzogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMYWJlbCA9IHN0eWxlZC5sYWJlbGBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEhlbHAgPSBzdHlsZWQucGBcblx0bWFyZ2luLXRvcDogJHsgc3BhY2UoIDIgKSB9O1xuXHRtYXJnaW4tYm90dG9tOiAwO1xuXHRmb250LXNpemU6ICR7IGZvbnQoICdoZWxwVGV4dC5mb250U2l6ZScgKSB9O1xuXHRmb250LXN0eWxlOiBub3JtYWw7XG5cdGNvbG9yOiAkeyBDT0xPUlMuZ3JheVsgNzAwIF0gfTtcblx0dGV4dC13cmFwOiBwcmV0dHk7XG5gO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkVmlzdWFsTGFiZWwgPSBzdHlsZWQuc3BhbmBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcbiJdfQ== */");
  var StyledLabel = /* @__PURE__ */ createStyled("label", false ? {
    target: "ej5x27r2"
  } : {
    target: "ej5x27r2",
    label: "StyledLabel"
  })(labelStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJhc2UtY29udHJvbC1zdHlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBcUN1QyIsImZpbGUiOiJiYXNlLWNvbnRyb2wtc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBiYXNlTGFiZWxUeXBvZ3JhcGh5LCBib3hTaXppbmdSZXNldCwgZm9udCwgQ09MT1JTIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0Zm9udC1mYW1pbHk6ICR7IGZvbnQoICdkZWZhdWx0LmZvbnRGYW1pbHknICkgfTtcblx0Zm9udC1zaXplOiAkeyBmb250KCAnZGVmYXVsdC5mb250U2l6ZScgKSB9O1xuXG5cdCR7IGJveFNpemluZ1Jlc2V0IH1cbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRGaWVsZCA9IHN0eWxlZC5kaXZgXG5cdC5jb21wb25lbnRzLXBhbmVsX19yb3cgJiB7XG5cdFx0bWFyZ2luLWJvdHRvbTogaW5oZXJpdDtcblx0fVxuYDtcblxuY29uc3QgbGFiZWxTdHlsZXMgPSBjc3NgXG5cdCR7IGJhc2VMYWJlbFR5cG9ncmFwaHkgfTtcblxuXHRkaXNwbGF5OiBibG9jaztcblx0bWFyZ2luLWJvdHRvbTogJHsgc3BhY2UoIDIgKSB9O1xuXHQvKipcblx0ICogUmVtb3ZlcyBDaHJvbWUvU2FmYXJpL0ZpcmVmb3ggdXNlciBhZ2VudCBzdHlsZXNoZWV0IHBhZGRpbmcgZnJvbVxuXHQgKiBTdHlsZWRMYWJlbCB3aGVuIGl0IGlzIHJlbmRlcmVkIGFzIGEgbGVnZW5kLlxuXHQgKi9cblx0cGFkZGluZzogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMYWJlbCA9IHN0eWxlZC5sYWJlbGBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEhlbHAgPSBzdHlsZWQucGBcblx0bWFyZ2luLXRvcDogJHsgc3BhY2UoIDIgKSB9O1xuXHRtYXJnaW4tYm90dG9tOiAwO1xuXHRmb250LXNpemU6ICR7IGZvbnQoICdoZWxwVGV4dC5mb250U2l6ZScgKSB9O1xuXHRmb250LXN0eWxlOiBub3JtYWw7XG5cdGNvbG9yOiAkeyBDT0xPUlMuZ3JheVsgNzAwIF0gfTtcblx0dGV4dC13cmFwOiBwcmV0dHk7XG5gO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkVmlzdWFsTGFiZWwgPSBzdHlsZWQuc3BhbmBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcbiJdfQ== */"));
  var StyledHelp = /* @__PURE__ */ createStyled("p", false ? {
    target: "ej5x27r1"
  } : {
    target: "ej5x27r1",
    label: "StyledHelp"
  })("margin-top:", space(2), ";margin-bottom:0;font-size:", font("helpText.fontSize"), ";font-style:normal;color:", COLORS.gray[700], ";text-wrap:pretty;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJhc2UtY29udHJvbC1zdHlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBeUNrQyIsImZpbGUiOiJiYXNlLWNvbnRyb2wtc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBiYXNlTGFiZWxUeXBvZ3JhcGh5LCBib3hTaXppbmdSZXNldCwgZm9udCwgQ09MT1JTIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0Zm9udC1mYW1pbHk6ICR7IGZvbnQoICdkZWZhdWx0LmZvbnRGYW1pbHknICkgfTtcblx0Zm9udC1zaXplOiAkeyBmb250KCAnZGVmYXVsdC5mb250U2l6ZScgKSB9O1xuXG5cdCR7IGJveFNpemluZ1Jlc2V0IH1cbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRGaWVsZCA9IHN0eWxlZC5kaXZgXG5cdC5jb21wb25lbnRzLXBhbmVsX19yb3cgJiB7XG5cdFx0bWFyZ2luLWJvdHRvbTogaW5oZXJpdDtcblx0fVxuYDtcblxuY29uc3QgbGFiZWxTdHlsZXMgPSBjc3NgXG5cdCR7IGJhc2VMYWJlbFR5cG9ncmFwaHkgfTtcblxuXHRkaXNwbGF5OiBibG9jaztcblx0bWFyZ2luLWJvdHRvbTogJHsgc3BhY2UoIDIgKSB9O1xuXHQvKipcblx0ICogUmVtb3ZlcyBDaHJvbWUvU2FmYXJpL0ZpcmVmb3ggdXNlciBhZ2VudCBzdHlsZXNoZWV0IHBhZGRpbmcgZnJvbVxuXHQgKiBTdHlsZWRMYWJlbCB3aGVuIGl0IGlzIHJlbmRlcmVkIGFzIGEgbGVnZW5kLlxuXHQgKi9cblx0cGFkZGluZzogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMYWJlbCA9IHN0eWxlZC5sYWJlbGBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEhlbHAgPSBzdHlsZWQucGBcblx0bWFyZ2luLXRvcDogJHsgc3BhY2UoIDIgKSB9O1xuXHRtYXJnaW4tYm90dG9tOiAwO1xuXHRmb250LXNpemU6ICR7IGZvbnQoICdoZWxwVGV4dC5mb250U2l6ZScgKSB9O1xuXHRmb250LXN0eWxlOiBub3JtYWw7XG5cdGNvbG9yOiAkeyBDT0xPUlMuZ3JheVsgNzAwIF0gfTtcblx0dGV4dC13cmFwOiBwcmV0dHk7XG5gO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkVmlzdWFsTGFiZWwgPSBzdHlsZWQuc3BhbmBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcbiJdfQ== */"));
  var StyledVisualLabel = /* @__PURE__ */ createStyled("span", false ? {
    target: "ej5x27r0"
  } : {
    target: "ej5x27r0",
    label: "StyledVisualLabel"
  })(labelStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJhc2UtY29udHJvbC1zdHlsZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBa0Q0QyIsImZpbGUiOiJiYXNlLWNvbnRyb2wtc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBiYXNlTGFiZWxUeXBvZ3JhcGh5LCBib3hTaXppbmdSZXNldCwgZm9udCwgQ09MT1JTIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0Zm9udC1mYW1pbHk6ICR7IGZvbnQoICdkZWZhdWx0LmZvbnRGYW1pbHknICkgfTtcblx0Zm9udC1zaXplOiAkeyBmb250KCAnZGVmYXVsdC5mb250U2l6ZScgKSB9O1xuXG5cdCR7IGJveFNpemluZ1Jlc2V0IH1cbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRGaWVsZCA9IHN0eWxlZC5kaXZgXG5cdC5jb21wb25lbnRzLXBhbmVsX19yb3cgJiB7XG5cdFx0bWFyZ2luLWJvdHRvbTogaW5oZXJpdDtcblx0fVxuYDtcblxuY29uc3QgbGFiZWxTdHlsZXMgPSBjc3NgXG5cdCR7IGJhc2VMYWJlbFR5cG9ncmFwaHkgfTtcblxuXHRkaXNwbGF5OiBibG9jaztcblx0bWFyZ2luLWJvdHRvbTogJHsgc3BhY2UoIDIgKSB9O1xuXHQvKipcblx0ICogUmVtb3ZlcyBDaHJvbWUvU2FmYXJpL0ZpcmVmb3ggdXNlciBhZ2VudCBzdHlsZXNoZWV0IHBhZGRpbmcgZnJvbVxuXHQgKiBTdHlsZWRMYWJlbCB3aGVuIGl0IGlzIHJlbmRlcmVkIGFzIGEgbGVnZW5kLlxuXHQgKi9cblx0cGFkZGluZzogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRMYWJlbCA9IHN0eWxlZC5sYWJlbGBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEhlbHAgPSBzdHlsZWQucGBcblx0bWFyZ2luLXRvcDogJHsgc3BhY2UoIDIgKSB9O1xuXHRtYXJnaW4tYm90dG9tOiAwO1xuXHRmb250LXNpemU6ICR7IGZvbnQoICdoZWxwVGV4dC5mb250U2l6ZScgKSB9O1xuXHRmb250LXN0eWxlOiBub3JtYWw7XG5cdGNvbG9yOiAkeyBDT0xPUlMuZ3JheVsgNzAwIF0gfTtcblx0dGV4dC13cmFwOiBwcmV0dHk7XG5gO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkVmlzdWFsTGFiZWwgPSBzdHlsZWQuc3BhbmBcblx0JHsgbGFiZWxTdHlsZXMgfVxuYDtcbiJdfQ== */"));

  // packages/components/build-module/base-control/index.mjs
  var import_jsx_runtime91 = __toESM(require_jsx_runtime(), 1);

  // packages/components/build-module/base-control/hooks.mjs
  var import_compose4 = __toESM(require_compose(), 1);
  function useBaseControlProps(props) {
    const {
      help,
      id: preferredId,
      ...restProps
    } = props;
    const uniqueId = (0, import_compose4.useInstanceId)(base_control_default, "wp-components-base-control", preferredId);
    return {
      baseControlProps: {
        id: uniqueId,
        help,
        ...restProps
      },
      controlProps: {
        id: uniqueId,
        ...!!help ? {
          "aria-describedby": `${uniqueId}__help`
        } : {}
      }
    };
  }

  // packages/components/build-module/base-control/index.mjs
  var UnconnectedBaseControl = (props) => {
    const {
      id: id3,
      label,
      hideLabelFromVision = false,
      help,
      className: className2,
      children
    } = useContextSystem(props, "BaseControl");
    return /* @__PURE__ */ (0, import_jsx_runtime91.jsxs)(Wrapper, {
      className: className2,
      children: [/* @__PURE__ */ (0, import_jsx_runtime91.jsxs)(StyledField, {
        className: "components-base-control__field",
        children: [label && id3 && (hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(component_default2, {
          as: "label",
          htmlFor: id3,
          children: label
        }) : /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(StyledLabel, {
          className: "components-base-control__label",
          htmlFor: id3,
          children: label
        })), label && !id3 && (hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(component_default2, {
          as: "label",
          children: label
        }) : /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(VisualLabel, {
          children: label
        })), children]
      }), !!help && /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(StyledHelp, {
        id: id3 ? id3 + "__help" : void 0,
        className: "components-base-control__help",
        children: help
      })]
    });
  };
  var UnforwardedVisualLabel = (props, ref) => {
    const {
      className: className2,
      children,
      ...restProps
    } = props;
    return /* @__PURE__ */ (0, import_jsx_runtime91.jsx)(StyledVisualLabel, {
      ref,
      ...restProps,
      className: clsx_default("components-base-control__label", className2),
      children
    });
  };
  var VisualLabel = (0, import_element30.forwardRef)(UnforwardedVisualLabel);
  var BaseControl = Object.assign(contextConnectWithoutRef(UnconnectedBaseControl, "BaseControl"), {
    /**
     * `BaseControl.VisualLabel` is used to render a purely visual label inside a `BaseControl` component.
     *
     * It should only be used in cases where the children being rendered inside `BaseControl` are already accessibly labeled,
     * e.g., a button, but we want an additional visual label for that section equivalent to the labels `BaseControl` would
     * otherwise use if the `label` prop was passed.
     *
     * ```jsx
     * import { BaseControl } from '@wordpress/components';
     *
     * const MyBaseControl = () => (
     * 	<BaseControl help="This button is already accessibly labeled.">
     * 		<BaseControl.VisualLabel>Author</BaseControl.VisualLabel>
     * 		<Button>Select an author</Button>
     * 	</BaseControl>
     * );
     * ```
     */
    VisualLabel
  });
  var base_control_default = BaseControl;

  // packages/components/build-module/input-control/index.mjs
  var import_jsx_runtime92 = __toESM(require_jsx_runtime(), 1);
  var noop5 = () => {
  };
  function useUniqueId2(idProp) {
    const instanceId = (0, import_compose5.useInstanceId)(InputControl);
    const id3 = `inspector-input-control-${instanceId}`;
    return idProp || id3;
  }
  function UnforwardedInputControl(props, ref) {
    const {
      // Prevent passing legacy props to internal components.
      __next40pxDefaultSize: _next40pxDefaultSize,
      __next36pxDefaultSize: _next36pxDefaultSize,
      __shouldNotWarnDeprecated36pxSize: _shouldNotWarnDeprecated36pxSize,
      __unstableStateReducer: stateReducer = (state) => state,
      __unstableInputWidth,
      className: className2,
      disabled = false,
      help,
      hideLabelFromVision = false,
      id: idProp,
      isPressEnterToChange = false,
      label,
      labelPosition = "top",
      onChange = noop5,
      onValidate = noop5,
      onKeyDown = noop5,
      prefix: prefix2,
      size: size4 = "default",
      style: style2,
      suffix,
      value,
      ...restProps
    } = props;
    const id3 = useUniqueId2(idProp);
    const classes = clsx_default("components-input-control", className2);
    const draftHookProps = useDraft({
      value,
      onBlur: restProps.onBlur,
      onChange
    });
    const helpProp = !!help ? {
      "aria-describedby": `${id3}__help`
    } : {};
    return /* @__PURE__ */ (0, import_jsx_runtime92.jsx)(base_control_default, {
      className: classes,
      help,
      id: id3,
      children: /* @__PURE__ */ (0, import_jsx_runtime92.jsx)(input_base_default, {
        __unstableInputWidth,
        disabled,
        gap: 3,
        hideLabelFromVision,
        id: id3,
        justify: "left",
        label,
        labelPosition,
        prefix: prefix2,
        size: size4,
        style: style2,
        suffix,
        children: /* @__PURE__ */ (0, import_jsx_runtime92.jsx)(input_field_default, {
          ...restProps,
          ...helpProp,
          className: "components-input-control__input",
          disabled,
          id: id3,
          isPressEnterToChange,
          onKeyDown,
          onValidate,
          paddingInlineStart: prefix2 ? space(1) : void 0,
          paddingInlineEnd: suffix ? space(1) : void 0,
          ref,
          size: size4,
          stateReducer,
          ...draftHookProps
        })
      })
    });
  }
  var InputControl = (0, import_element31.forwardRef)(UnforwardedInputControl);
  var input_control_default = InputControl;

  // packages/components/build-module/button/index.mjs
  var import_deprecated3 = __toESM(require_deprecated(), 1);
  var import_element33 = __toESM(require_element(), 1);
  var import_compose6 = __toESM(require_compose(), 1);

  // packages/components/build-module/icon/index.mjs
  var import_element32 = __toESM(require_element(), 1);
  var import_primitives30 = __toESM(require_primitives(), 1);

  // packages/components/build-module/dashicon/index.mjs
  var import_jsx_runtime93 = __toESM(require_jsx_runtime(), 1);
  function Dashicon({
    icon,
    className: className2,
    size: size4 = 20,
    style: style2 = {},
    ...extraProps
  }) {
    const iconClass = ["dashicon", "dashicons", "dashicons-" + icon, className2].filter(Boolean).join(" ");
    const sizeStyles3 = (
      // using `!=` to catch both 20 and "20"
      // eslint-disable-next-line eqeqeq
      20 != size4 ? {
        fontSize: `${size4}px`,
        width: `${size4}px`,
        height: `${size4}px`
      } : {}
    );
    const styles3 = {
      ...sizeStyles3,
      ...style2
    };
    return /* @__PURE__ */ (0, import_jsx_runtime93.jsx)("span", {
      className: iconClass,
      style: styles3,
      ...extraProps
    });
  }
  var dashicon_default = Dashicon;

  // packages/components/build-module/icon/index.mjs
  var import_jsx_runtime94 = __toESM(require_jsx_runtime(), 1);
  function Icon({
    icon = null,
    size: size4 = "string" === typeof icon ? 20 : 24,
    ...additionalProps
  }) {
    if ("string" === typeof icon) {
      return /* @__PURE__ */ (0, import_jsx_runtime94.jsx)(dashicon_default, {
        icon,
        size: size4,
        ...additionalProps
      });
    }
    if ((0, import_element32.isValidElement)(icon) && dashicon_default === icon.type) {
      return (0, import_element32.cloneElement)(icon, {
        ...additionalProps
      });
    }
    if ("function" === typeof icon) {
      return (0, import_element32.createElement)(icon, {
        size: size4,
        ...additionalProps
      });
    }
    if (icon && (icon.type === "svg" || icon.type === import_primitives30.SVG)) {
      const appliedProps = {
        ...icon.props,
        width: size4,
        height: size4,
        ...additionalProps
      };
      return /* @__PURE__ */ (0, import_jsx_runtime94.jsx)(import_primitives30.SVG, {
        ...appliedProps
      });
    }
    if ((0, import_element32.isValidElement)(icon)) {
      return (0, import_element32.cloneElement)(icon, {
        // @ts-ignore Just forwarding the size prop along
        size: size4,
        width: size4,
        height: size4,
        ...additionalProps
      });
    }
    return icon;
  }
  var icon_default3 = Icon;

  // packages/components/build-module/button/index.mjs
  var import_jsx_runtime95 = __toESM(require_jsx_runtime(), 1);
  var disabledEventsOnDisabledButton = ["onMouseDown", "onClick"];
  function useDeprecatedProps2({
    __experimentalIsFocusable,
    isDefault,
    isPrimary,
    isSecondary,
    isTertiary,
    isLink,
    isPressed,
    isSmall,
    size: size4,
    variant,
    describedBy,
    ...otherProps
  }) {
    let computedSize = size4;
    let computedVariant = variant;
    const newProps = {
      accessibleWhenDisabled: __experimentalIsFocusable,
      // @todo Mark `isPressed` as deprecated
      "aria-pressed": isPressed,
      description: describedBy
    };
    if (isSmall) {
      computedSize ??= "small";
    }
    if (isPrimary) {
      computedVariant ??= "primary";
    }
    if (isTertiary) {
      computedVariant ??= "tertiary";
    }
    if (isSecondary) {
      computedVariant ??= "secondary";
    }
    if (isDefault) {
      (0, import_deprecated3.default)("wp.components.Button `isDefault` prop", {
        since: "5.4",
        alternative: 'variant="secondary"'
      });
      computedVariant ??= "secondary";
    }
    if (isLink) {
      computedVariant ??= "link";
    }
    return {
      ...newProps,
      ...otherProps,
      size: computedSize,
      variant: computedVariant
    };
  }
  var Button3 = (0, import_element33.forwardRef)(function UnforwardedButton(props, ref) {
    const {
      __next40pxDefaultSize,
      accessibleWhenDisabled,
      isBusy,
      isDestructive,
      className: className2,
      disabled,
      icon,
      iconPosition = "left",
      iconSize,
      showTooltip,
      tooltipPosition,
      shortcut,
      label,
      children,
      size: size4 = "default",
      text,
      variant,
      description,
      ...buttonOrAnchorProps
    } = useDeprecatedProps2(props);
    const {
      href,
      target,
      "aria-checked": ariaChecked,
      "aria-pressed": ariaPressed,
      "aria-selected": ariaSelected,
      ...additionalProps
    } = "href" in buttonOrAnchorProps ? buttonOrAnchorProps : {
      href: void 0,
      target: void 0,
      ...buttonOrAnchorProps
    };
    const instanceId = (0, import_compose6.useInstanceId)(Button3, "components-button__description");
    const hasChildren = "string" === typeof children && !!children || Array.isArray(children) && children?.[0] && children[0] !== null && // Tooltip should not considered as a child
    children?.[0]?.props?.className !== "components-tooltip";
    const truthyAriaPressedValues = [true, "true", "mixed"];
    const classes = clsx_default("components-button", className2, {
      "is-next-40px-default-size": __next40pxDefaultSize,
      "is-secondary": variant === "secondary",
      "is-primary": variant === "primary",
      "is-small": size4 === "small",
      "is-compact": size4 === "compact",
      "is-tertiary": variant === "tertiary",
      "is-pressed": truthyAriaPressedValues.includes(ariaPressed),
      "is-pressed-mixed": ariaPressed === "mixed",
      "is-busy": isBusy,
      "is-link": variant === "link",
      "is-destructive": isDestructive,
      "has-text": !!icon && (hasChildren || text),
      "has-icon": !!icon,
      "has-icon-right": iconPosition === "right"
    });
    const trulyDisabled = disabled && !accessibleWhenDisabled;
    const Tag = href !== void 0 && !disabled ? "a" : "button";
    const buttonProps = Tag === "button" ? {
      type: "button",
      disabled: trulyDisabled,
      "aria-checked": ariaChecked,
      "aria-pressed": ariaPressed,
      "aria-selected": ariaSelected
    } : {};
    const anchorProps = Tag === "a" ? {
      href,
      target
    } : {};
    const disableEventProps = {};
    if (disabled && accessibleWhenDisabled) {
      buttonProps["aria-disabled"] = true;
      anchorProps["aria-disabled"] = true;
      for (const disabledEvent of disabledEventsOnDisabledButton) {
        disableEventProps[disabledEvent] = (event) => {
          if (event) {
            event.stopPropagation();
            event.preventDefault();
          }
        };
      }
    }
    const shouldShowTooltip = !trulyDisabled && // An explicit tooltip is passed or...
    (showTooltip && !!label || // There's a shortcut or...
    !!shortcut || // There's a label and...
    !!label && // The children are empty and...
    !children?.length && // The tooltip is not explicitly disabled.
    false !== showTooltip);
    const descriptionId = description ? instanceId : void 0;
    const describedById = additionalProps["aria-describedby"] || descriptionId;
    const commonProps = {
      className: classes,
      "aria-label": additionalProps["aria-label"] || label,
      "aria-describedby": describedById,
      ref
    };
    const elementChildren = /* @__PURE__ */ (0, import_jsx_runtime95.jsxs)(import_jsx_runtime95.Fragment, {
      children: [icon && iconPosition === "left" && /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(icon_default3, {
        icon,
        size: iconSize
      }), text && /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(import_jsx_runtime95.Fragment, {
        children: text
      }), children, icon && iconPosition === "right" && /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(icon_default3, {
        icon,
        size: iconSize
      })]
    });
    const element = Tag === "a" ? /* @__PURE__ */ (0, import_jsx_runtime95.jsx)("a", {
      ...anchorProps,
      ...additionalProps,
      ...disableEventProps,
      ...commonProps,
      children: elementChildren
    }) : /* @__PURE__ */ (0, import_jsx_runtime95.jsx)("button", {
      ...buttonProps,
      ...additionalProps,
      ...disableEventProps,
      ...commonProps,
      children: elementChildren
    });
    const tooltipProps = shouldShowTooltip ? {
      text: children?.length && description ? description : label,
      shortcut,
      placement: tooltipPosition && // Convert legacy `position` values to be used with the new `placement` prop
      positionToPlacement(tooltipPosition)
    } : {};
    return /* @__PURE__ */ (0, import_jsx_runtime95.jsxs)(import_jsx_runtime95.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime95.jsx)(tooltip_default, {
        ...tooltipProps,
        children: element
      }), description && /* @__PURE__ */ (0, import_jsx_runtime95.jsx)(component_default2, {
        children: /* @__PURE__ */ (0, import_jsx_runtime95.jsx)("span", {
          id: descriptionId,
          children: description
        })
      })]
    });
  });
  var button_default = Button3;

  // packages/components/build-module/number-control/styles/number-control-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__6() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var _ref3 = false ? {
    name: "euqsgg",
    styles: "input[type='number']::-webkit-outer-spin-button,input[type='number']::-webkit-inner-spin-button{-webkit-appearance:none!important;margin:0!important;}input[type='number']{-moz-appearance:textfield;}"
  } : {
    name: "jl4rev-htmlArrowStyles",
    styles: "input[type='number']::-webkit-outer-spin-button,input[type='number']::-webkit-inner-spin-button{-webkit-appearance:none!important;margin:0!important;}input[type='number']{-moz-appearance:textfield;};label:htmlArrowStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm51bWJlci1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFtQlciLCJmaWxlIjoibnVtYmVyLWNvbnRyb2wtc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgSW5wdXRDb250cm9sIGZyb20gJy4uLy4uL2lucHV0LWNvbnRyb2wnO1xuaW1wb3J0IHsgQ09MT1JTIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuaW1wb3J0IEJ1dHRvbiBmcm9tICcuLi8uLi9idXR0b24nO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmNvbnN0IGh0bWxBcnJvd1N0eWxlcyA9ICggeyBoaWRlSFRNTEFycm93cyB9OiB7IGhpZGVIVE1MQXJyb3dzOiBib29sZWFuIH0gKSA9PiB7XG5cdGlmICggISBoaWRlSFRNTEFycm93cyApIHtcblx0XHRyZXR1cm4gYGA7XG5cdH1cblxuXHRyZXR1cm4gY3NzYFxuXHRcdGlucHV0W3R5cGU9J251bWJlciddOjotd2Via2l0LW91dGVyLXNwaW4tYnV0dG9uLFxuXHRcdGlucHV0W3R5cGU9J251bWJlciddOjotd2Via2l0LWlubmVyLXNwaW4tYnV0dG9uIHtcblx0XHRcdC13ZWJraXQtYXBwZWFyYW5jZTogbm9uZSAhaW1wb3J0YW50O1xuXHRcdFx0bWFyZ2luOiAwICFpbXBvcnRhbnQ7XG5cdFx0fVxuXG5cdFx0aW5wdXRbdHlwZT0nbnVtYmVyJ10ge1xuXHRcdFx0LW1vei1hcHBlYXJhbmNlOiB0ZXh0ZmllbGQ7XG5cdFx0fVxuXHRgO1xufTtcblxuZXhwb3J0IGNvbnN0IElucHV0ID0gc3R5bGVkKCBJbnB1dENvbnRyb2wgKWBcblx0JHsgaHRtbEFycm93U3R5bGVzIH07XG5gO1xuXG5leHBvcnQgY29uc3QgU3BpbkJ1dHRvbiA9IHN0eWxlZCggQnV0dG9uIClgXG5cdCYmJiYmIHtcblx0XHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmFjY2VudCB9O1xuXHR9XG5gO1xuXG5jb25zdCBzbWFsbFNwaW5CdXR0b25zID0gY3NzYFxuXHR3aWR0aDogJHsgc3BhY2UoIDUgKSB9O1xuXHRtaW4td2lkdGg6ICR7IHNwYWNlKCA1ICkgfTtcblx0aGVpZ2h0OiAkeyBzcGFjZSggNSApIH07XG5gO1xuXG5leHBvcnQgY29uc3Qgc3R5bGVzID0geyBzbWFsbFNwaW5CdXR0b25zIH07XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__6
  };
  var htmlArrowStyles = ({
    hideHTMLArrows
  }) => {
    if (!hideHTMLArrows) {
      return ``;
    }
    return _ref3;
  };
  var Input2 = /* @__PURE__ */ createStyled(input_control_default, false ? {
    target: "ep09it41"
  } : {
    target: "ep09it41",
    label: "Input"
  })(htmlArrowStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm51bWJlci1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFnQzJDIiwiZmlsZSI6Im51bWJlci1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IElucHV0Q29udHJvbCBmcm9tICcuLi8uLi9pbnB1dC1jb250cm9sJztcbmltcG9ydCB7IENPTE9SUyB9IGZyb20gJy4uLy4uL3V0aWxzJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IHNwYWNlIH0gZnJvbSAnLi4vLi4vdXRpbHMvc3BhY2UnO1xuXG5jb25zdCBodG1sQXJyb3dTdHlsZXMgPSAoIHsgaGlkZUhUTUxBcnJvd3MgfTogeyBoaWRlSFRNTEFycm93czogYm9vbGVhbiB9ICkgPT4ge1xuXHRpZiAoICEgaGlkZUhUTUxBcnJvd3MgKSB7XG5cdFx0cmV0dXJuIGBgO1xuXHR9XG5cblx0cmV0dXJuIGNzc2Bcblx0XHRpbnB1dFt0eXBlPSdudW1iZXInXTo6LXdlYmtpdC1vdXRlci1zcGluLWJ1dHRvbixcblx0XHRpbnB1dFt0eXBlPSdudW1iZXInXTo6LXdlYmtpdC1pbm5lci1zcGluLWJ1dHRvbiB7XG5cdFx0XHQtd2Via2l0LWFwcGVhcmFuY2U6IG5vbmUgIWltcG9ydGFudDtcblx0XHRcdG1hcmdpbjogMCAhaW1wb3J0YW50O1xuXHRcdH1cblxuXHRcdGlucHV0W3R5cGU9J251bWJlciddIHtcblx0XHRcdC1tb3otYXBwZWFyYW5jZTogdGV4dGZpZWxkO1xuXHRcdH1cblx0YDtcbn07XG5cbmV4cG9ydCBjb25zdCBJbnB1dCA9IHN0eWxlZCggSW5wdXRDb250cm9sIClgXG5cdCR7IGh0bWxBcnJvd1N0eWxlcyB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IFNwaW5CdXR0b24gPSBzdHlsZWQoIEJ1dHRvbiApYFxuXHQmJiYmJiB7XG5cdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5hY2NlbnQgfTtcblx0fVxuYDtcblxuY29uc3Qgc21hbGxTcGluQnV0dG9ucyA9IGNzc2Bcblx0d2lkdGg6ICR7IHNwYWNlKCA1ICkgfTtcblx0bWluLXdpZHRoOiAkeyBzcGFjZSggNSApIH07XG5cdGhlaWdodDogJHsgc3BhY2UoIDUgKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IHN0eWxlcyA9IHsgc21hbGxTcGluQnV0dG9ucyB9O1xuIl19 */"));
  var SpinButton = /* @__PURE__ */ createStyled(button_default, false ? {
    target: "ep09it40"
  } : {
    target: "ep09it40",
    label: "SpinButton"
  })("&&&&&{color:", COLORS.theme.accent, ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm51bWJlci1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFvQzBDIiwiZmlsZSI6Im51bWJlci1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IElucHV0Q29udHJvbCBmcm9tICcuLi8uLi9pbnB1dC1jb250cm9sJztcbmltcG9ydCB7IENPTE9SUyB9IGZyb20gJy4uLy4uL3V0aWxzJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IHNwYWNlIH0gZnJvbSAnLi4vLi4vdXRpbHMvc3BhY2UnO1xuXG5jb25zdCBodG1sQXJyb3dTdHlsZXMgPSAoIHsgaGlkZUhUTUxBcnJvd3MgfTogeyBoaWRlSFRNTEFycm93czogYm9vbGVhbiB9ICkgPT4ge1xuXHRpZiAoICEgaGlkZUhUTUxBcnJvd3MgKSB7XG5cdFx0cmV0dXJuIGBgO1xuXHR9XG5cblx0cmV0dXJuIGNzc2Bcblx0XHRpbnB1dFt0eXBlPSdudW1iZXInXTo6LXdlYmtpdC1vdXRlci1zcGluLWJ1dHRvbixcblx0XHRpbnB1dFt0eXBlPSdudW1iZXInXTo6LXdlYmtpdC1pbm5lci1zcGluLWJ1dHRvbiB7XG5cdFx0XHQtd2Via2l0LWFwcGVhcmFuY2U6IG5vbmUgIWltcG9ydGFudDtcblx0XHRcdG1hcmdpbjogMCAhaW1wb3J0YW50O1xuXHRcdH1cblxuXHRcdGlucHV0W3R5cGU9J251bWJlciddIHtcblx0XHRcdC1tb3otYXBwZWFyYW5jZTogdGV4dGZpZWxkO1xuXHRcdH1cblx0YDtcbn07XG5cbmV4cG9ydCBjb25zdCBJbnB1dCA9IHN0eWxlZCggSW5wdXRDb250cm9sIClgXG5cdCR7IGh0bWxBcnJvd1N0eWxlcyB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IFNwaW5CdXR0b24gPSBzdHlsZWQoIEJ1dHRvbiApYFxuXHQmJiYmJiB7XG5cdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5hY2NlbnQgfTtcblx0fVxuYDtcblxuY29uc3Qgc21hbGxTcGluQnV0dG9ucyA9IGNzc2Bcblx0d2lkdGg6ICR7IHNwYWNlKCA1ICkgfTtcblx0bWluLXdpZHRoOiAkeyBzcGFjZSggNSApIH07XG5cdGhlaWdodDogJHsgc3BhY2UoIDUgKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IHN0eWxlcyA9IHsgc21hbGxTcGluQnV0dG9ucyB9O1xuIl19 */"));
  var smallSpinButtons = /* @__PURE__ */ css("width:", space(5), ";min-width:", space(5), ";height:", space(5), ";" + (false ? "" : ";label:smallSpinButtons;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm51bWJlci1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEwQzRCIiwiZmlsZSI6Im51bWJlci1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IElucHV0Q29udHJvbCBmcm9tICcuLi8uLi9pbnB1dC1jb250cm9sJztcbmltcG9ydCB7IENPTE9SUyB9IGZyb20gJy4uLy4uL3V0aWxzJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IHNwYWNlIH0gZnJvbSAnLi4vLi4vdXRpbHMvc3BhY2UnO1xuXG5jb25zdCBodG1sQXJyb3dTdHlsZXMgPSAoIHsgaGlkZUhUTUxBcnJvd3MgfTogeyBoaWRlSFRNTEFycm93czogYm9vbGVhbiB9ICkgPT4ge1xuXHRpZiAoICEgaGlkZUhUTUxBcnJvd3MgKSB7XG5cdFx0cmV0dXJuIGBgO1xuXHR9XG5cblx0cmV0dXJuIGNzc2Bcblx0XHRpbnB1dFt0eXBlPSdudW1iZXInXTo6LXdlYmtpdC1vdXRlci1zcGluLWJ1dHRvbixcblx0XHRpbnB1dFt0eXBlPSdudW1iZXInXTo6LXdlYmtpdC1pbm5lci1zcGluLWJ1dHRvbiB7XG5cdFx0XHQtd2Via2l0LWFwcGVhcmFuY2U6IG5vbmUgIWltcG9ydGFudDtcblx0XHRcdG1hcmdpbjogMCAhaW1wb3J0YW50O1xuXHRcdH1cblxuXHRcdGlucHV0W3R5cGU9J251bWJlciddIHtcblx0XHRcdC1tb3otYXBwZWFyYW5jZTogdGV4dGZpZWxkO1xuXHRcdH1cblx0YDtcbn07XG5cbmV4cG9ydCBjb25zdCBJbnB1dCA9IHN0eWxlZCggSW5wdXRDb250cm9sIClgXG5cdCR7IGh0bWxBcnJvd1N0eWxlcyB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IFNwaW5CdXR0b24gPSBzdHlsZWQoIEJ1dHRvbiApYFxuXHQmJiYmJiB7XG5cdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5hY2NlbnQgfTtcblx0fVxuYDtcblxuY29uc3Qgc21hbGxTcGluQnV0dG9ucyA9IGNzc2Bcblx0d2lkdGg6ICR7IHNwYWNlKCA1ICkgfTtcblx0bWluLXdpZHRoOiAkeyBzcGFjZSggNSApIH07XG5cdGhlaWdodDogJHsgc3BhY2UoIDUgKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IHN0eWxlcyA9IHsgc21hbGxTcGluQnV0dG9ucyB9O1xuIl19 */");
  var styles = {
    smallSpinButtons
  };

  // packages/components/build-module/utils/math.mjs
  function getNumber(value) {
    const number2 = Number(value);
    return isNaN(number2) ? 0 : number2;
  }
  function add(...args) {
    return args.reduce(
      /** @type {(sum:number, arg: number|string) => number} */
      (sum, arg) => sum + getNumber(arg),
      0
    );
  }
  function subtract(...args) {
    return args.reduce(
      /** @type {(diff:number, arg: number|string, index:number) => number} */
      (diff, arg, index2) => {
        const value = getNumber(arg);
        return index2 === 0 ? value : diff - value;
      },
      0
    );
  }
  function getPrecision(value) {
    const split = (value + "").split(".");
    return split[1] !== void 0 ? split[1].length : 0;
  }
  function clamp4(value, min3, max3) {
    const baseValue = getNumber(value);
    return Math.max(min3, Math.min(baseValue, max3));
  }
  function ensureValidStep(value, min3, step) {
    const baseValue = getNumber(value);
    const minValue = getNumber(min3);
    const stepValue = getNumber(step);
    const precision = Math.max(getPrecision(step), getPrecision(min3));
    const tare = minValue % stepValue ? minValue : 0;
    const rounded3 = Math.round((baseValue - tare) / stepValue) * stepValue;
    const fromMin = rounded3 + tare;
    return precision ? getNumber(fromMin.toFixed(precision)) : fromMin;
  }

  // packages/components/build-module/h-stack/utils.mjs
  var H_ALIGNMENTS = {
    bottom: {
      align: "flex-end",
      justify: "center"
    },
    bottomLeft: {
      align: "flex-end",
      justify: "flex-start"
    },
    bottomRight: {
      align: "flex-end",
      justify: "flex-end"
    },
    center: {
      align: "center",
      justify: "center"
    },
    edge: {
      align: "center",
      justify: "space-between"
    },
    left: {
      align: "center",
      justify: "flex-start"
    },
    right: {
      align: "center",
      justify: "flex-end"
    },
    stretch: {
      align: "stretch"
    },
    top: {
      align: "flex-start",
      justify: "center"
    },
    topLeft: {
      align: "flex-start",
      justify: "flex-start"
    },
    topRight: {
      align: "flex-start",
      justify: "flex-end"
    }
  };
  var V_ALIGNMENTS = {
    bottom: {
      justify: "flex-end",
      align: "center"
    },
    bottomLeft: {
      justify: "flex-end",
      align: "flex-start"
    },
    bottomRight: {
      justify: "flex-end",
      align: "flex-end"
    },
    center: {
      justify: "center",
      align: "center"
    },
    edge: {
      justify: "space-between",
      align: "center"
    },
    left: {
      justify: "center",
      align: "flex-start"
    },
    right: {
      justify: "center",
      align: "flex-end"
    },
    stretch: {
      align: "stretch"
    },
    top: {
      justify: "flex-start",
      align: "center"
    },
    topLeft: {
      justify: "flex-start",
      align: "flex-start"
    },
    topRight: {
      justify: "flex-start",
      align: "flex-end"
    }
  };
  function getAlignmentProps(alignment, direction = "row") {
    if (!isValueDefined(alignment)) {
      return {};
    }
    const isVertical = direction === "column";
    const props = isVertical ? V_ALIGNMENTS : H_ALIGNMENTS;
    const alignmentProps = alignment in props ? props[alignment] : {
      align: alignment
    };
    return alignmentProps;
  }

  // packages/components/build-module/utils/get-valid-children.mjs
  var import_element34 = __toESM(require_element(), 1);
  function getValidChildren(children) {
    if (typeof children === "string") {
      return [children];
    }
    return import_element34.Children.toArray(children).filter((child) => (0, import_element34.isValidElement)(child));
  }

  // packages/components/build-module/h-stack/hook.mjs
  var import_jsx_runtime96 = __toESM(require_jsx_runtime(), 1);
  function useHStack(props) {
    const {
      alignment = "edge",
      children,
      direction,
      spacing = 2,
      ...otherProps
    } = useContextSystem(props, "HStack");
    const align = getAlignmentProps(alignment, direction);
    const validChildren = getValidChildren(children);
    const clonedChildren = validChildren.map((child, index2) => {
      const _isSpacer = hasConnectNamespace(child, ["Spacer"]);
      if (_isSpacer) {
        const childElement = child;
        const _key = childElement.key || `hstack-${index2}`;
        return /* @__PURE__ */ (0, import_jsx_runtime96.jsx)(component_default4, {
          isBlock: true,
          ...childElement.props
        }, _key);
      }
      return child;
    });
    const propsForFlex = {
      children: clonedChildren,
      direction,
      justify: "center",
      ...align,
      ...otherProps,
      gap: spacing
    };
    const {
      isColumn,
      ...flexProps
    } = useFlex(propsForFlex);
    return flexProps;
  }

  // packages/components/build-module/h-stack/component.mjs
  var import_jsx_runtime97 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedHStack(props, forwardedRef) {
    const hStackProps = useHStack(props);
    return /* @__PURE__ */ (0, import_jsx_runtime97.jsx)(component_default, {
      ...hStackProps,
      ref: forwardedRef
    });
  }
  var HStack = contextConnect(UnconnectedHStack, "HStack");
  var component_default9 = HStack;

  // packages/components/build-module/number-control/index.mjs
  var import_jsx_runtime98 = __toESM(require_jsx_runtime(), 1);
  var noop6 = () => {
  };
  function UnforwardedNumberControl(props, forwardedRef) {
    const {
      __unstableStateReducer: stateReducerProp,
      className: className2,
      dragDirection = "n",
      hideHTMLArrows = false,
      spinControls = hideHTMLArrows ? "none" : "native",
      isDragEnabled = true,
      isShiftStepEnabled = true,
      label,
      max: max3 = Infinity,
      min: min3 = -Infinity,
      required = false,
      shiftStep = 10,
      step = 1,
      spinFactor = 1,
      type: typeProp = "number",
      value: valueProp,
      size: size4 = "default",
      suffix,
      onChange = noop6,
      ...restProps
    } = props;
    if (hideHTMLArrows) {
      (0, import_deprecated4.default)("wp.components.NumberControl hideHTMLArrows prop ", {
        alternative: 'spinControls="none"',
        since: "6.2",
        version: "6.3"
      });
    }
    const inputRef = (0, import_element35.useRef)(null);
    const mergedRef = (0, import_compose7.useMergeRefs)([inputRef, forwardedRef]);
    const isStepAny = step === "any";
    const baseStep = isStepAny ? 1 : ensureNumber(step);
    const baseSpin = ensureNumber(spinFactor) * baseStep;
    const constrainValue = (value, stepOverride) => {
      if (!isStepAny) {
        value = ensureValidStep(value, min3, stepOverride ?? baseStep);
      }
      return `${clamp4(value, min3, max3)}`;
    };
    const baseValue = constrainValue(0);
    const autoComplete = typeProp === "number" ? "off" : void 0;
    const classes = clsx_default("components-number-control", className2);
    const cx2 = useCx();
    const spinButtonClasses = cx2(size4 === "small" && styles.smallSpinButtons);
    const spinValue = (value, direction, event) => {
      event?.preventDefault();
      const shift4 = event?.shiftKey && isShiftStepEnabled;
      const delta = shift4 ? ensureNumber(shiftStep) * baseSpin : baseSpin;
      let nextValue = isValueEmpty(value) ? baseValue : value;
      if (direction === "up") {
        nextValue = add(nextValue, delta);
      } else if (direction === "down") {
        nextValue = subtract(nextValue, delta);
      }
      return constrainValue(nextValue, shift4 ? delta : void 0);
    };
    const numberControlStateReducer = (state, action) => {
      const nextState = {
        ...state
      };
      const {
        type,
        payload
      } = action;
      const event = payload.event;
      const currentValue = nextState.value;
      if (type === PRESS_UP || type === PRESS_DOWN) {
        nextState.value = spinValue(currentValue, type === PRESS_UP ? "up" : "down", event);
      }
      if (type === DRAG && isDragEnabled) {
        const [x2, y3] = payload.delta;
        const enableShift = payload.shiftKey && isShiftStepEnabled;
        const modifier = enableShift ? ensureNumber(shiftStep) * baseSpin : baseSpin;
        let directionModifier;
        let delta;
        switch (dragDirection) {
          case "n":
            delta = y3;
            directionModifier = -1;
            break;
          case "e":
            delta = x2;
            directionModifier = (0, import_i18n5.isRTL)() ? -1 : 1;
            break;
          case "s":
            delta = y3;
            directionModifier = 1;
            break;
          case "w":
            delta = x2;
            directionModifier = (0, import_i18n5.isRTL)() ? 1 : -1;
            break;
        }
        if (delta !== 0) {
          delta = Math.ceil(Math.abs(delta)) * Math.sign(delta);
          const distance2 = delta * modifier * directionModifier;
          nextState.value = constrainValue(
            // @ts-expect-error TODO: Investigate if it's ok for currentValue to be undefined
            add(currentValue, distance2),
            enableShift ? modifier : void 0
          );
        }
      }
      if (type === PRESS_ENTER || type === COMMIT) {
        const applyEmptyValue = required === false && currentValue === "";
        nextState.value = applyEmptyValue ? currentValue : (
          // @ts-expect-error TODO: Investigate if it's ok for currentValue to be undefined
          constrainValue(currentValue)
        );
      }
      return stateReducerProp?.(nextState, action) ?? nextState;
    };
    const buildSpinButtonClickHandler = (direction) => (event) => onChange(String(spinValue(valueProp, direction, event)), {
      // Set event.target to the <input> so that consumers can use
      // e.g. event.target.validity.
      event: {
        ...event,
        target: inputRef.current
      }
    });
    return /* @__PURE__ */ (0, import_jsx_runtime98.jsx)(Input2, {
      autoComplete,
      inputMode: "numeric",
      ...restProps,
      className: classes,
      dragDirection,
      hideHTMLArrows: spinControls !== "native",
      isDragEnabled,
      label,
      max: max3 === Infinity ? void 0 : max3,
      min: min3 === -Infinity ? void 0 : min3,
      ref: mergedRef,
      required,
      step,
      type: typeProp,
      value: valueProp,
      __unstableStateReducer: numberControlStateReducer,
      size: size4,
      suffix: spinControls === "custom" ? /* @__PURE__ */ (0, import_jsx_runtime98.jsxs)(import_jsx_runtime98.Fragment, {
        children: [suffix, /* @__PURE__ */ (0, import_jsx_runtime98.jsx)(component_default6, {
          marginBottom: 0,
          marginRight: 2,
          children: /* @__PURE__ */ (0, import_jsx_runtime98.jsxs)(component_default9, {
            spacing: 1,
            children: [/* @__PURE__ */ (0, import_jsx_runtime98.jsx)(SpinButton, {
              className: spinButtonClasses,
              icon: plus_default,
              size: "small",
              label: (0, import_i18n5.__)("Increment"),
              onClick: buildSpinButtonClickHandler("up")
            }), /* @__PURE__ */ (0, import_jsx_runtime98.jsx)(SpinButton, {
              className: spinButtonClasses,
              icon: reset_default,
              size: "small",
              label: (0, import_i18n5.__)("Decrement"),
              onClick: buildSpinButtonClickHandler("down")
            })]
          })
        })]
      }) : suffix,
      onChange
    });
  }
  var NumberControl = (0, import_element35.forwardRef)(UnforwardedNumberControl);
  NumberControl.displayName = "NumberControl";
  var number_control_default = NumberControl;

  // packages/components/build-module/input-control/input-prefix-wrapper.mjs
  var import_jsx_runtime99 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedInputControlPrefixWrapper(props, forwardedRef) {
    const derivedProps = useContextSystem(props, "InputControlPrefixWrapper");
    return /* @__PURE__ */ (0, import_jsx_runtime99.jsx)(PrefixSuffixWrapper, {
      ...derivedProps,
      isPrefix: true,
      ref: forwardedRef
    });
  }
  var InputControlPrefixWrapper = contextConnect(UnconnectedInputControlPrefixWrapper, "InputControlPrefixWrapper");
  var input_prefix_wrapper_default = InputControlPrefixWrapper;

  // packages/components/build-module/input-control/input-suffix-wrapper.mjs
  var import_jsx_runtime100 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedInputControlSuffixWrapper(props, forwardedRef) {
    const derivedProps = useContextSystem(props, "InputControlSuffixWrapper");
    return /* @__PURE__ */ (0, import_jsx_runtime100.jsx)(PrefixSuffixWrapper, {
      ...derivedProps,
      ref: forwardedRef
    });
  }
  var InputControlSuffixWrapper = contextConnect(UnconnectedInputControlSuffixWrapper, "InputControlSuffixWrapper");
  var input_suffix_wrapper_default = InputControlSuffixWrapper;

  // packages/components/build-module/angle-picker-control/angle-circle.mjs
  var import_element36 = __toESM(require_element(), 1);
  var import_compose8 = __toESM(require_compose(), 1);
  var import_jsx_runtime101 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE7 = "data-wp-hash";
  function getRuntime7() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument7(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash7(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE7}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE7) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle7(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime7();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash7(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE7, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument7(targetDocument) {
    const runtime = getRuntime7();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle7(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle7(hash2, css3) {
    const runtime = getRuntime7();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle7(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle7("cbb20ea39f", "._8f57b8d483c51fbe__circle-root{border:1px solid var(--wp-components-color-gray-600,var(--wpds-color-stroke-interactive-neutral,#8d8d8d));border-radius:50%;box-sizing:border-box;cursor:grab;height:32px;overflow:hidden;width:32px}._8f57b8d483c51fbe__circle-root:active{cursor:grabbing}.b1bae984ac10fcc3__circle-indicator-wrapper{box-sizing:border-box;height:100%;position:relative;width:100%}.b1bae984ac10fcc3__circle-indicator-wrapper:focus-visible{outline:none}._6d2fe0a2cbb31bf0__circle-indicator{background:var(--wp-components-color-accent,var(--wp-admin-theme-color,#3858e9));border-radius:50%;box-sizing:border-box;display:block;height:6px;left:50%;position:absolute;top:4px;transform:translateX(-50%);width:6px}");
  }
  var style_module_default7 = { "circle-root": "_8f57b8d483c51fbe__circle-root", "circle-indicator-wrapper": "b1bae984ac10fcc3__circle-indicator-wrapper", "circle-indicator": "_6d2fe0a2cbb31bf0__circle-indicator" };
  function AngleCircle({
    value,
    onChange,
    className: className2,
    ...props
  }) {
    const angleCircleRef = (0, import_element36.useRef)(null);
    const angleCircleCenterRef = (0, import_element36.useRef)(void 0);
    const previousCursorValueRef = (0, import_element36.useRef)(void 0);
    const setAngleCircleCenter = () => {
      if (angleCircleRef.current === null) {
        return;
      }
      const rect = angleCircleRef.current.getBoundingClientRect();
      angleCircleCenterRef.current = {
        x: rect.x + rect.width / 2,
        y: rect.y + rect.height / 2
      };
    };
    const changeAngleToPosition = (event) => {
      if (event === void 0) {
        return;
      }
      event.preventDefault();
      event.target?.focus();
      if (angleCircleCenterRef.current !== void 0 && onChange !== void 0) {
        const {
          x: centerX,
          y: centerY
        } = angleCircleCenterRef.current;
        onChange(getAngle(centerX, centerY, event.clientX, event.clientY));
      }
    };
    const {
      startDrag,
      isDragging: isDragging2
    } = (0, import_compose8.__experimentalUseDragging)({
      onDragStart: (event) => {
        setAngleCircleCenter();
        changeAngleToPosition(event);
      },
      onDragMove: changeAngleToPosition,
      onDragEnd: changeAngleToPosition
    });
    (0, import_element36.useEffect)(() => {
      if (isDragging2) {
        if (previousCursorValueRef.current === void 0) {
          previousCursorValueRef.current = document.body.style.cursor;
        }
        document.body.style.cursor = "grabbing";
      } else {
        document.body.style.cursor = previousCursorValueRef.current || "";
        previousCursorValueRef.current = void 0;
      }
    }, [isDragging2]);
    return (
      // eslint-disable-next-line jsx-a11y/no-static-element-interactions
      /* @__PURE__ */ (0, import_jsx_runtime101.jsx)("div", {
        ref: angleCircleRef,
        onMouseDown: startDrag,
        className: clsx_default("components-angle-picker-control__angle-circle", style_module_default7["circle-root"], className2),
        ...props,
        children: /* @__PURE__ */ (0, import_jsx_runtime101.jsx)("div", {
          style: value ? {
            transform: `rotate(${value}deg)`
          } : void 0,
          className: clsx_default("components-angle-picker-control__angle-circle-indicator-wrapper", style_module_default7["circle-indicator-wrapper"]),
          tabIndex: -1,
          children: /* @__PURE__ */ (0, import_jsx_runtime101.jsx)("div", {
            className: clsx_default("components-angle-picker-control__angle-circle-indicator", style_module_default7["circle-indicator"])
          })
        })
      })
    );
  }
  function getAngle(centerX, centerY, pointX, pointY) {
    const y3 = pointY - centerY;
    const x2 = pointX - centerX;
    const angleInRadians = Math.atan2(y3, x2);
    const angleInDeg = Math.round(angleInRadians * (180 / Math.PI)) + 90;
    if (angleInDeg < 0) {
      return 360 + angleInDeg;
    }
    return angleInDeg;
  }
  var angle_circle_default = AngleCircle;

  // packages/components/build-module/angle-picker-control/index.mjs
  var import_jsx_runtime102 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedAnglePickerControl(props, ref) {
    const {
      className: className2,
      label = (0, import_i18n6.__)("Angle"),
      onChange,
      value,
      ...restProps
    } = props;
    const handleOnNumberChange = (unprocessedValue) => {
      if (onChange === void 0) {
        return;
      }
      const inputValue = unprocessedValue !== void 0 && unprocessedValue !== "" ? parseInt(unprocessedValue, 10) : 0;
      onChange(inputValue);
    };
    const classes = clsx_default("components-angle-picker-control", className2);
    const prefixOrSuffixProp = (0, import_i18n6.isRTL)() ? {
      prefix: /* @__PURE__ */ (0, import_jsx_runtime102.jsx)(input_prefix_wrapper_default, {
        children: "\xB0"
      })
    } : {
      suffix: /* @__PURE__ */ (0, import_jsx_runtime102.jsx)(input_suffix_wrapper_default, {
        children: "\xB0"
      })
    };
    return /* @__PURE__ */ (0, import_jsx_runtime102.jsxs)(component_default3, {
      ...restProps,
      ref,
      className: classes,
      gap: 2,
      children: [/* @__PURE__ */ (0, import_jsx_runtime102.jsx)(component_default5, {
        children: /* @__PURE__ */ (0, import_jsx_runtime102.jsx)(number_control_default, {
          label,
          className: "components-angle-picker-control__input-field",
          max: 360,
          min: 0,
          onChange: handleOnNumberChange,
          step: "1",
          value,
          spinControls: "none",
          ...prefixOrSuffixProp
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime102.jsx)(component_default6, {
        marginBottom: "1",
        marginTop: "auto",
        children: /* @__PURE__ */ (0, import_jsx_runtime102.jsx)(angle_circle_default, {
          "aria-hidden": "true",
          value,
          onChange
        })
      })]
    });
  }
  var AnglePickerControl = (0, import_element37.forwardRef)(UnforwardedAnglePickerControl);
  AnglePickerControl.displayName = "AnglePickerControl";
  var angle_picker_control_default = AnglePickerControl;

  // packages/components/build-module/autocomplete/index.mjs
  var import_element52 = __toESM(require_element(), 1);
  var import_compose18 = __toESM(require_compose(), 1);
  var import_rich_text2 = __toESM(require_rich_text(), 1);
  var import_a11y2 = __toESM(require_a11y(), 1);
  var import_keycodes = __toESM(require_keycodes(), 1);

  // packages/components/build-module/autocomplete/autocompleter-ui.mjs
  var import_react_dom6 = __toESM(require_react_dom(), 1);
  var import_element51 = __toESM(require_element(), 1);
  var import_rich_text = __toESM(require_rich_text(), 1);
  var import_compose17 = __toESM(require_compose(), 1);
  var import_a11y = __toESM(require_a11y(), 1);
  var import_i18n8 = __toESM(require_i18n(), 1);

  // packages/components/build-module/autocomplete/get-default-use-items.mjs
  var import_remove_accents2 = __toESM(require_remove_accents(), 1);
  var import_compose9 = __toESM(require_compose(), 1);
  var import_element38 = __toESM(require_element(), 1);

  // packages/components/build-module/utils/strings.mjs
  var import_remove_accents = __toESM(require_remove_accents(), 1);
  var ALL_UNICODE_DASH_CHARACTERS = new RegExp(/[\u007e\u00ad\u2053\u207b\u208b\u2212\p{Pd}]/gu);
  var normalizeTextString = (value) => {
    return (0, import_remove_accents.default)(value).normalize("NFKC").toLocaleLowerCase().replace(ALL_UNICODE_DASH_CHARACTERS, "-");
  };
  function kebabCase(str) {
    let input = str?.toString?.() ?? "";
    input = input.replace(/['\u2019]/, "");
    return paramCase(input, {
      splitRegexp: [
        /(?!(?:1ST|2ND|3RD|[4-9]TH)(?![a-z]))([a-z0-9])([A-Z])/g,
        // fooBar => foo-bar, 3Bar => 3-bar
        /(?!(?:1st|2nd|3rd|[4-9]th)(?![a-z]))([0-9])([a-z])/g,
        // 3bar => 3-bar
        /([A-Za-z])([0-9])/g,
        // Foo3 => foo-3, foo3 => foo-3
        /([A-Z])([A-Z][a-z])/g
        // FOOBar => foo-bar
      ]
    });
  }
  function escapeRegExp(string) {
    return string.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
  }

  // packages/components/build-module/autocomplete/get-default-use-items.mjs
  function filterOptions(search, options2 = [], maxResults = 10) {
    const filtered = [];
    for (let i3 = 0; i3 < options2.length; i3++) {
      const option = options2[i3];
      let {
        keywords = []
      } = option;
      if ("string" === typeof option.label) {
        keywords = [...keywords, option.label];
      }
      const isMatch = keywords.some((keyword) => search.test((0, import_remove_accents2.default)(keyword)));
      if (!isMatch) {
        continue;
      }
      filtered.push(option);
      if (filtered.length === maxResults) {
        break;
      }
    }
    return filtered;
  }
  function getDefaultUseItems(autocompleter) {
    return (filterValue) => {
      const [items, setItems] = (0, import_element38.useState)([]);
      (0, import_element38.useLayoutEffect)(() => {
        const {
          options: options2,
          isDebounced
        } = autocompleter;
        const loadOptions = (0, import_compose9.debounce)(() => {
          const promise2 = Promise.resolve(typeof options2 === "function" ? options2(filterValue) : options2).then((optionsData) => {
            if (promise2.canceled) {
              return;
            }
            const keyedOptions = optionsData.map((optionData, optionIndex) => ({
              key: `${autocompleter.name}-${optionIndex}`,
              value: optionData,
              label: autocompleter.getOptionLabel(optionData),
              keywords: autocompleter.getOptionKeywords ? autocompleter.getOptionKeywords(optionData) : [],
              isDisabled: autocompleter.isOptionDisabled ? autocompleter.isOptionDisabled(optionData) : false
            }));
            const search = new RegExp("(?:\\b|\\s|^)" + escapeRegExp(filterValue), "i");
            setItems(filterOptions(search, keyedOptions));
          });
          return promise2;
        }, isDebounced ? 250 : 0);
        const promise = loadOptions();
        return () => {
          loadOptions.cancel();
          if (promise) {
            promise.canceled = true;
          }
        };
      }, [filterValue]);
      return [items];
    };
  }

  // node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
  var React10 = __toESM(require_react(), 1);
  var import_react90 = __toESM(require_react(), 1);
  var ReactDOM = __toESM(require_react_dom(), 1);
  var isClient = typeof document !== "undefined";
  var noop7 = function noop8() {
  };
  var index = isClient ? import_react90.useLayoutEffect : noop7;
  function deepEqual(a3, b3) {
    if (a3 === b3) {
      return true;
    }
    if (typeof a3 !== typeof b3) {
      return false;
    }
    if (typeof a3 === "function" && a3.toString() === b3.toString()) {
      return true;
    }
    let length2;
    let i3;
    let keys;
    if (a3 && b3 && typeof a3 === "object") {
      if (Array.isArray(a3)) {
        length2 = a3.length;
        if (length2 !== b3.length) return false;
        for (i3 = length2; i3-- !== 0; ) {
          if (!deepEqual(a3[i3], b3[i3])) {
            return false;
          }
        }
        return true;
      }
      keys = Object.keys(a3);
      length2 = keys.length;
      if (length2 !== Object.keys(b3).length) {
        return false;
      }
      for (i3 = length2; i3-- !== 0; ) {
        if (!{}.hasOwnProperty.call(b3, keys[i3])) {
          return false;
        }
      }
      for (i3 = length2; i3-- !== 0; ) {
        const key = keys[i3];
        if (key === "_owner" && a3.$$typeof) {
          continue;
        }
        if (!deepEqual(a3[key], b3[key])) {
          return false;
        }
      }
      return true;
    }
    return a3 !== a3 && b3 !== b3;
  }
  function getDPR(element) {
    if (typeof window === "undefined") {
      return 1;
    }
    const win = element.ownerDocument.defaultView || window;
    return win.devicePixelRatio || 1;
  }
  function roundByDPR2(element, value) {
    const dpr = getDPR(element);
    return Math.round(value * dpr) / dpr;
  }
  function useLatestRef(value) {
    const ref = React10.useRef(value);
    index(() => {
      ref.current = value;
    });
    return ref;
  }
  function useFloating(options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    const {
      placement = "bottom",
      strategy = "absolute",
      middleware: middleware2 = [],
      platform: platform2,
      elements: {
        reference: externalReference,
        floating: externalFloating
      } = {},
      transform = true,
      whileElementsMounted,
      open
    } = options2;
    const [data, setData] = React10.useState({
      x: 0,
      y: 0,
      strategy,
      placement,
      middlewareData: {},
      isPositioned: false
    });
    const [latestMiddleware, setLatestMiddleware] = React10.useState(middleware2);
    if (!deepEqual(latestMiddleware, middleware2)) {
      setLatestMiddleware(middleware2);
    }
    const [_reference, _setReference] = React10.useState(null);
    const [_floating, _setFloating] = React10.useState(null);
    const setReference = React10.useCallback((node2) => {
      if (node2 !== referenceRef.current) {
        referenceRef.current = node2;
        _setReference(node2);
      }
    }, []);
    const setFloating = React10.useCallback((node2) => {
      if (node2 !== floatingRef.current) {
        floatingRef.current = node2;
        _setFloating(node2);
      }
    }, []);
    const referenceEl = externalReference || _reference;
    const floatingEl = externalFloating || _floating;
    const referenceRef = React10.useRef(null);
    const floatingRef = React10.useRef(null);
    const dataRef = React10.useRef(data);
    const hasWhileElementsMounted = whileElementsMounted != null;
    const whileElementsMountedRef = useLatestRef(whileElementsMounted);
    const platformRef = useLatestRef(platform2);
    const openRef = useLatestRef(open);
    const update = React10.useCallback(() => {
      if (!referenceRef.current || !floatingRef.current) {
        return;
      }
      const config = {
        placement,
        strategy,
        middleware: latestMiddleware
      };
      if (platformRef.current) {
        config.platform = platformRef.current;
      }
      computePosition2(referenceRef.current, floatingRef.current, config).then((data2) => {
        const fullData = {
          ...data2,
          // The floating element's position may be recomputed while it's closed
          // but still mounted (such as when transitioning out). To ensure
          // `isPositioned` will be `false` initially on the next open, avoid
          // setting it to `true` when `open === false` (must be specified).
          isPositioned: openRef.current !== false
        };
        if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
          dataRef.current = fullData;
          ReactDOM.flushSync(() => {
            setData(fullData);
          });
        }
      });
    }, [latestMiddleware, placement, strategy, platformRef, openRef]);
    index(() => {
      if (open === false && dataRef.current.isPositioned) {
        dataRef.current.isPositioned = false;
        setData((data2) => ({
          ...data2,
          isPositioned: false
        }));
      }
    }, [open]);
    const isMountedRef = React10.useRef(false);
    index(() => {
      isMountedRef.current = true;
      return () => {
        isMountedRef.current = false;
      };
    }, []);
    index(() => {
      if (referenceEl) referenceRef.current = referenceEl;
      if (floatingEl) floatingRef.current = floatingEl;
      if (referenceEl && floatingEl) {
        if (whileElementsMountedRef.current) {
          return whileElementsMountedRef.current(referenceEl, floatingEl, update);
        }
        update();
      }
    }, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
    const refs = React10.useMemo(() => ({
      reference: referenceRef,
      floating: floatingRef,
      setReference,
      setFloating
    }), [setReference, setFloating]);
    const elements2 = React10.useMemo(() => ({
      reference: referenceEl,
      floating: floatingEl
    }), [referenceEl, floatingEl]);
    const floatingStyles = React10.useMemo(() => {
      const initialStyles = {
        position: strategy,
        left: 0,
        top: 0
      };
      if (!elements2.floating) {
        return initialStyles;
      }
      const x2 = roundByDPR2(elements2.floating, data.x);
      const y3 = roundByDPR2(elements2.floating, data.y);
      if (transform) {
        return {
          ...initialStyles,
          transform: "translate(" + x2 + "px, " + y3 + "px)",
          ...getDPR(elements2.floating) >= 1.5 && {
            willChange: "transform"
          }
        };
      }
      return {
        position: strategy,
        left: x2,
        top: y3
      };
    }, [strategy, transform, elements2.floating, data.x, data.y]);
    return React10.useMemo(() => ({
      ...data,
      update,
      refs,
      elements: elements2,
      floatingStyles
    }), [data, update, refs, elements2, floatingStyles]);
  }
  var arrow$1 = (options2) => {
    function isRef2(value) {
      return {}.hasOwnProperty.call(value, "current");
    }
    return {
      name: "arrow",
      options: options2,
      fn(state) {
        const {
          element,
          padding: padding2
        } = typeof options2 === "function" ? options2(state) : options2;
        if (element && isRef2(element)) {
          if (element.current != null) {
            return arrow2({
              element: element.current,
              padding: padding2
            }).fn(state);
          }
          return {};
        }
        if (element) {
          return arrow2({
            element,
            padding: padding2
          }).fn(state);
        }
        return {};
      }
    };
  };
  var offset3 = (options2, deps) => {
    const result = offset2(options2);
    return {
      name: result.name,
      fn: result.fn,
      options: [options2, deps]
    };
  };
  var shift3 = (options2, deps) => {
    const result = shift2(options2);
    return {
      name: result.name,
      fn: result.fn,
      options: [options2, deps]
    };
  };
  var limitShift3 = (options2, deps) => {
    const result = limitShift2(options2);
    return {
      fn: result.fn,
      options: [options2, deps]
    };
  };
  var flip3 = (options2, deps) => {
    const result = flip2(options2);
    return {
      name: result.name,
      fn: result.fn,
      options: [options2, deps]
    };
  };
  var size3 = (options2, deps) => {
    const result = size2(options2);
    return {
      name: result.name,
      fn: result.fn,
      options: [options2, deps]
    };
  };
  var arrow3 = (options2, deps) => {
    const result = arrow$1(options2);
    return {
      name: result.name,
      fn: result.fn,
      options: [options2, deps]
    };
  };

  // packages/components/build-module/popover/index.mjs
  var import_element50 = __toESM(require_element(), 1);
  var import_compose16 = __toESM(require_compose(), 1);
  var import_deprecated5 = __toESM(require_deprecated(), 1);
  var import_primitives31 = __toESM(require_primitives(), 1);
  var import_i18n7 = __toESM(require_i18n(), 1);

  // packages/components/build-module/scroll-lock/index.mjs
  var import_element39 = __toESM(require_element(), 1);
  var previousScrollTop = 0;
  function setLocked(locked) {
    const scrollingElement = document.scrollingElement || document.body;
    if (locked) {
      previousScrollTop = scrollingElement.scrollTop;
    }
    const methodName = locked ? "add" : "remove";
    scrollingElement.classList[methodName]("lockscroll");
    document.documentElement.classList[methodName]("lockscroll");
    if (!locked) {
      scrollingElement.scrollTop = previousScrollTop;
    }
  }
  var lockCounter = 0;
  function ScrollLock() {
    (0, import_element39.useEffect)(() => {
      if (lockCounter === 0) {
        setLocked(true);
      }
      ++lockCounter;
      return () => {
        if (lockCounter === 1) {
          setLocked(false);
        }
        --lockCounter;
      };
    }, []);
    return null;
  }
  var scroll_lock_default = ScrollLock;

  // packages/components/build-module/slot-fill/index.mjs
  var import_element48 = __toESM(require_element(), 1);

  // packages/components/build-module/slot-fill/fill.mjs
  var import_compose11 = __toESM(require_compose(), 1);
  var import_element42 = __toESM(require_element(), 1);

  // packages/components/build-module/slot-fill/context.mjs
  var import_compose10 = __toESM(require_compose(), 1);
  var import_element40 = __toESM(require_element(), 1);
  var import_warning4 = __toESM(require_warning(), 1);
  var initialValue = {
    slots: (0, import_compose10.observableMap)(),
    fills: (0, import_compose10.observableMap)(),
    registerSlot: () => {
      true ? (0, import_warning4.default)("Components must be wrapped within `SlotFillProvider`. See https://developer.wordpress.org/block-editor/components/slot-fill/") : void 0;
    },
    unregisterSlot: () => {
    },
    updateSlot: () => {
    },
    registerFill: () => {
    },
    unregisterFill: () => {
    },
    updateFill: () => {
    },
    // This helps the provider know if it's using the default context value or not.
    isDefault: true
  };
  var SlotFillContext = (0, import_element40.createContext)(initialValue);
  SlotFillContext.displayName = "SlotFillContext";
  var context_default = SlotFillContext;

  // node_modules/uuid/dist/stringify.js
  var byteToHex = [];
  for (let i3 = 0; i3 < 256; ++i3) {
    byteToHex.push((i3 + 256).toString(16).slice(1));
  }
  function unsafeStringify(arr, offset4 = 0) {
    return (byteToHex[arr[offset4 + 0]] + byteToHex[arr[offset4 + 1]] + byteToHex[arr[offset4 + 2]] + byteToHex[arr[offset4 + 3]] + "-" + byteToHex[arr[offset4 + 4]] + byteToHex[arr[offset4 + 5]] + "-" + byteToHex[arr[offset4 + 6]] + byteToHex[arr[offset4 + 7]] + "-" + byteToHex[arr[offset4 + 8]] + byteToHex[arr[offset4 + 9]] + "-" + byteToHex[arr[offset4 + 10]] + byteToHex[arr[offset4 + 11]] + byteToHex[arr[offset4 + 12]] + byteToHex[arr[offset4 + 13]] + byteToHex[arr[offset4 + 14]] + byteToHex[arr[offset4 + 15]]).toLowerCase();
  }

  // node_modules/uuid/dist/rng.js
  var rnds8 = new Uint8Array(16);
  function rng() {
    return crypto.getRandomValues(rnds8);
  }

  // node_modules/uuid/dist/v4.js
  function v4(options2, buf, offset4) {
    if (!buf && !options2 && crypto.randomUUID) {
      return crypto.randomUUID();
    }
    return _v4(options2, buf, offset4);
  }
  function _v4(options2, buf, offset4) {
    options2 = options2 || {};
    const rnds = options2.random ?? options2.rng?.() ?? rng();
    if (rnds.length < 16) {
      throw new Error("Random bytes length must be >= 16");
    }
    rnds[6] = rnds[6] & 15 | 64;
    rnds[8] = rnds[8] & 63 | 128;
    if (buf) {
      offset4 = offset4 || 0;
      if (offset4 < 0 || offset4 + 16 > buf.length) {
        throw new RangeError(`UUID byte range ${offset4}:${offset4 + 15} is out of buffer bounds`);
      }
      for (let i3 = 0; i3 < 16; ++i3) {
        buf[offset4 + i3] = rnds[i3];
      }
      return buf;
    }
    return unsafeStringify(rnds);
  }
  var v4_default = v4;

  // packages/components/build-module/style-provider/index.mjs
  var import_element41 = __toESM(require_element(), 1);
  var import_jsx_runtime103 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE8 = "data-wp-hash";
  function getRuntime8() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument8(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash8(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE8}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE8) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle8(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime8();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash8(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE8, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument8(targetDocument) {
    const runtime = getRuntime8();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle8(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  var uuidCache = /* @__PURE__ */ new Set();
  var containerCacheMap = /* @__PURE__ */ new WeakMap();
  var memoizedCreateCacheWithContainer = (container) => {
    if (containerCacheMap.has(container)) {
      return containerCacheMap.get(container);
    }
    let key = v4_default().replace(/[0-9]/g, "");
    while (uuidCache.has(key)) {
      key = v4_default().replace(/[0-9]/g, "");
    }
    uuidCache.add(key);
    const cache2 = createCache({
      container,
      key
    });
    containerCacheMap.set(container, cache2);
    return cache2;
  };
  function StyleProvider(props) {
    const {
      children,
      document: document2
    } = props;
    (0, import_element41.useLayoutEffect)(() => {
      if (!document2) {
        return;
      }
      return registerDocument8(document2);
    }, [document2]);
    if (!document2) {
      return null;
    }
    const cache2 = memoizedCreateCacheWithContainer(document2.head);
    return /* @__PURE__ */ (0, import_jsx_runtime103.jsx)(CacheProvider, {
      value: cache2,
      children
    });
  }
  var style_provider_default = StyleProvider;

  // packages/components/build-module/slot-fill/fill.mjs
  var import_jsx_runtime104 = __toESM(require_jsx_runtime(), 1);
  function Fill({
    name,
    children
  }) {
    const registry = (0, import_element42.useContext)(context_default);
    const instanceRef = (0, import_element42.useRef)({});
    const childrenRef = (0, import_element42.useRef)(children);
    (0, import_element42.useLayoutEffect)(() => {
      childrenRef.current = children;
    }, [children]);
    (0, import_element42.useLayoutEffect)(() => {
      const instance = instanceRef.current;
      registry.registerFill(name, {
        instance,
        children: childrenRef.current
      });
      return () => registry.unregisterFill(name, instance);
    }, [registry, name]);
    (0, import_element42.useLayoutEffect)(() => {
      registry.updateFill(name, {
        instance: instanceRef.current,
        children
      });
    }, [registry, name, children]);
    const slot = (0, import_compose11.useObservableValue)(registry.slots, name);
    if (!slot) {
      return null;
    }
    if (slot.type === "children") {
      return null;
    }
    const portalEl = slot.ref.current;
    if (!portalEl) {
      return null;
    }
    const wrappedChildren = typeof children === "function" ? children(slot.fillProps ?? {}) : children;
    return (0, import_element42.createPortal)(/* @__PURE__ */ (0, import_jsx_runtime104.jsx)(style_provider_default, {
      document: portalEl.ownerDocument,
      children: wrappedChildren
    }), portalEl);
  }

  // packages/components/build-module/slot-fill/slot.mjs
  var import_compose12 = __toESM(require_compose(), 1);
  var import_element43 = __toESM(require_element(), 1);
  var import_jsx_runtime105 = __toESM(require_jsx_runtime(), 1);
  function isFunction(maybeFunc) {
    return typeof maybeFunc === "function";
  }
  function addKeysToChildren(children) {
    return import_element43.Children.map(children, (child, childIndex) => {
      if (!child || typeof child === "string") {
        return child;
      }
      let childKey = childIndex;
      if (typeof child === "object" && "key" in child && child?.key) {
        childKey = child.key;
      }
      return (0, import_element43.cloneElement)(child, {
        key: childKey
      });
    });
  }
  function Slot(props) {
    const {
      name,
      children,
      fillProps = {}
    } = props;
    const registry = (0, import_element43.useContext)(context_default);
    const instanceRef = (0, import_element43.useRef)({});
    (0, import_element43.useLayoutEffect)(() => {
      const instance = instanceRef.current;
      registry.registerSlot(name, {
        type: "children",
        instance
      });
      return () => registry.unregisterSlot(name, instance);
    }, [registry, name]);
    let fills = (0, import_compose12.useObservableValue)(registry.fills, name) ?? [];
    const currentSlot = (0, import_compose12.useObservableValue)(registry.slots, name);
    if (!currentSlot || currentSlot.instance !== instanceRef.current) {
      fills = [];
    }
    const renderedFills = fills.map((fill) => {
      const fillChildren = isFunction(fill.children) ? fill.children(fillProps) : fill.children;
      return addKeysToChildren(fillChildren);
    }).filter(
      // In some cases fills are rendered only when some conditions apply.
      // This ensures that we only use non-empty fills when rendering, i.e.,
      // it allows us to render wrappers only when the fills are actually present.
      (element) => !(0, import_element43.isEmptyElement)(element)
    );
    return /* @__PURE__ */ (0, import_jsx_runtime105.jsx)(import_jsx_runtime105.Fragment, {
      children: isFunction(children) ? children(renderedFills) : renderedFills
    });
  }
  var slot_default = Slot;

  // packages/components/build-module/slot-fill/bubbles-virtually/slot.mjs
  var import_element44 = __toESM(require_element(), 1);
  var import_compose13 = __toESM(require_compose(), 1);
  var import_jsx_runtime106 = __toESM(require_jsx_runtime(), 1);
  function Slot2(props, forwardedRef) {
    const {
      name,
      fillProps = {},
      as,
      // `children` is not allowed. However, if it is passed,
      // it will be displayed as is, so remove `children`.
      children,
      ...restProps
    } = props;
    const registry = (0, import_element44.useContext)(context_default);
    const instanceRef = (0, import_element44.useRef)({});
    const ref = (0, import_element44.useRef)(null);
    const fillPropsRef = (0, import_element44.useRef)(fillProps);
    (0, import_element44.useLayoutEffect)(() => {
      fillPropsRef.current = fillProps;
    }, [fillProps]);
    (0, import_element44.useLayoutEffect)(() => {
      const instance = instanceRef.current;
      registry.registerSlot(name, {
        type: "portal",
        instance,
        ref,
        fillProps: fillPropsRef.current
      });
      return () => registry.unregisterSlot(name, instance);
    }, [registry, name]);
    (0, import_element44.useLayoutEffect)(() => {
      registry.updateSlot(name, {
        type: "portal",
        instance: instanceRef.current,
        ref,
        fillProps: fillPropsRef.current
      });
    });
    return /* @__PURE__ */ (0, import_jsx_runtime106.jsx)(component_default, {
      as,
      ref: (0, import_compose13.useMergeRefs)([forwardedRef, ref]),
      ...restProps
    });
  }
  var slot_default2 = (0, import_element44.forwardRef)(Slot2);

  // packages/components/build-module/slot-fill/provider.mjs
  var import_compose14 = __toESM(require_compose(), 1);
  var import_element45 = __toESM(require_element(), 1);
  var import_is_shallow_equal = __toESM(require_is_shallow_equal(), 1);
  var import_jsx_runtime107 = __toESM(require_jsx_runtime(), 1);
  function createSlotRegistry() {
    const slots = (0, import_compose14.observableMap)();
    const fills = (0, import_compose14.observableMap)();
    function registerSlot(name, slot) {
      slots.set(name, slot);
    }
    function unregisterSlot(name, instance) {
      const currentSlot = slots.get(name);
      if (!currentSlot || currentSlot.instance !== instance) {
        return;
      }
      slots.delete(name);
    }
    function updateSlot(name, slot) {
      if (slot.type !== "portal") {
        return;
      }
      const slotForName = slots.get(name);
      if (!slotForName) {
        return;
      }
      if (slotForName.type !== "portal") {
        return;
      }
      if (slotForName.instance !== slot.instance) {
        return;
      }
      if ((0, import_is_shallow_equal.isShallowEqual)(slotForName.fillProps, slot.fillProps)) {
        return;
      }
      slots.set(name, slot);
    }
    function registerFill(name, fill) {
      fills.set(name, [...fills.get(name) || [], fill]);
    }
    function unregisterFill(name, instance) {
      const fillsForName = fills.get(name);
      if (!fillsForName) {
        return;
      }
      fills.set(name, fillsForName.filter((fill) => fill.instance !== instance));
    }
    function updateFill(name, fill) {
      const fillsForName = fills.get(name);
      if (!fillsForName) {
        return;
      }
      const fillForInstance = fillsForName.find((f3) => f3.instance === fill.instance);
      if (!fillForInstance) {
        return;
      }
      if (fillForInstance.children === fill.children) {
        return;
      }
      fills.set(name, fillsForName.map((f3) => {
        if (f3.instance === fill.instance) {
          return fill;
        }
        return f3;
      }));
    }
    return {
      slots,
      fills,
      registerSlot,
      unregisterSlot,
      updateSlot,
      registerFill,
      unregisterFill,
      updateFill
    };
  }
  function SlotFillProvider({
    children
  }) {
    const [contextValue] = (0, import_element45.useState)(createSlotRegistry);
    return /* @__PURE__ */ (0, import_jsx_runtime107.jsx)(context_default.Provider, {
      value: contextValue,
      children
    });
  }
  var provider_default = SlotFillProvider;

  // packages/components/build-module/slot-fill/index.mjs
  var import_jsx_runtime108 = __toESM(require_jsx_runtime(), 1);

  // packages/components/build-module/slot-fill/bubbles-virtually/use-slot.mjs
  var import_element46 = __toESM(require_element(), 1);
  var import_compose15 = __toESM(require_compose(), 1);
  function useSlot(name) {
    const registry = (0, import_element46.useContext)(context_default);
    const slot = (0, import_compose15.useObservableValue)(registry.slots, name);
    let ref;
    if (slot && slot.type === "portal") {
      ref = slot.ref;
    }
    return {
      ref
    };
  }

  // packages/components/build-module/slot-fill/bubbles-virtually/use-slot-fills.mjs
  var import_element47 = __toESM(require_element(), 1);
  function useObservableValueWithSelector(map, name, selector2) {
    const subscribe2 = (0, import_element47.useMemo)(() => (listener) => map.subscribe(name, listener), [map, name]);
    const getValue3 = () => selector2(map.get(name));
    return (0, import_element47.useSyncExternalStore)(subscribe2, getValue3, getValue3);
  }
  function getLength(array) {
    return array?.length;
  }
  function useSlotFills(name) {
    const registry = (0, import_element47.useContext)(context_default);
    const length2 = useObservableValueWithSelector(registry.fills, name, getLength);
    const fills = (0, import_element47.useMemo)(() => {
      return length2 !== void 0 ? Array.from({
        length: length2
      }) : void 0;
    }, [length2]);
    return fills;
  }

  // packages/components/build-module/slot-fill/index.mjs
  var Slot3 = (0, import_element48.forwardRef)((props, ref) => {
    const {
      bubblesVirtually,
      ...restProps
    } = props;
    if (bubblesVirtually) {
      return /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(slot_default2, {
        ...restProps,
        ref
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(slot_default, {
      ...restProps
    });
  });
  Slot3.displayName = "Slot";
  function Provider({
    children,
    passthrough = false
  }) {
    const parent = (0, import_element48.useContext)(context_default);
    if (!parent.isDefault && passthrough) {
      return /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(import_jsx_runtime108.Fragment, {
        children
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(provider_default, {
      children
    });
  }
  Provider.displayName = "SlotFillProvider";
  function createSlotFill(key) {
    const baseName = typeof key === "symbol" ? key.description : key;
    const FillComponent = (props) => /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(Fill, {
      name: key,
      ...props
    });
    FillComponent.displayName = `${baseName}Fill`;
    const SlotComponent = (0, import_element48.forwardRef)((props, ref) => /* @__PURE__ */ (0, import_jsx_runtime108.jsx)(Slot3, {
      name: key,
      ref,
      ...props
    }));
    SlotComponent.displayName = `${baseName}Slot`;
    SlotComponent.__unstableName = key;
    return {
      name: key,
      Fill: FillComponent,
      Slot: SlotComponent
    };
  }

  // packages/components/build-module/popover/overlay-middlewares.mjs
  function overlayMiddlewares() {
    return [{
      name: "overlay",
      fn({
        rects
      }) {
        return rects.reference;
      }
    }, size3({
      apply({
        rects,
        elements: elements2
      }) {
        const {
          firstElementChild
        } = elements2.floating ?? {};
        if (!(firstElementChild instanceof HTMLElement)) {
          return;
        }
        Object.assign(firstElementChild.style, {
          width: `${rects.reference.width}px`,
          height: `${rects.reference.height}px`
        });
      }
    })];
  }

  // packages/components/build-module/popover/context.mjs
  var import_element49 = __toESM(require_element(), 1);
  var slotNameContext = (0, import_element49.createContext)(void 0);
  slotNameContext.displayName = "__unstableSlotNameContext";

  // packages/components/build-module/popover/index.mjs
  var import_jsx_runtime109 = __toESM(require_jsx_runtime(), 1);
  var SLOT_NAME = "Popover";
  var OVERFLOW_PADDING = 8;
  var ArrowTriangle = () => /* @__PURE__ */ (0, import_jsx_runtime109.jsxs)(import_primitives31.SVG, {
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 100 100",
    className: "components-popover__triangle",
    role: "presentation",
    children: [/* @__PURE__ */ (0, import_jsx_runtime109.jsx)(import_primitives31.Path, {
      className: "components-popover__triangle-bg",
      d: "M 0 0 L 50 50 L 100 0"
    }), /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(import_primitives31.Path, {
      className: "components-popover__triangle-border",
      d: "M 0 0 L 50 50 L 100 0",
      vectorEffect: "non-scaling-stroke"
    })]
  });
  var fallbackContainerClassname = "components-popover__fallback-container";
  var getPopoverFallbackContainer = () => {
    let container = document.body.querySelector("." + fallbackContainerClassname);
    if (!container) {
      container = document.createElement("div");
      container.className = fallbackContainerClassname;
      document.body.append(container);
    }
    return container;
  };
  var UnforwardedPopover = (props, forwardedRef) => {
    const {
      animate = true,
      headerTitle,
      constrainTabbing,
      onClose,
      children,
      className: className2,
      noArrow = true,
      position: position2,
      placement: placementProp = "bottom-start",
      offset: offsetProp = 0,
      focusOnMount = "firstElement",
      anchor,
      expandOnMobile,
      onFocusOutside,
      __unstableSlotName = SLOT_NAME,
      flip: flip4 = true,
      resize = true,
      shift: shift4 = false,
      inline: inline3 = false,
      variant,
      style: contentStyle,
      // Deprecated props
      __unstableForcePosition,
      anchorRef,
      anchorRect,
      getAnchorRect,
      isAlternate,
      // `onKeyDown` is forwarded to `useDialog` so the consumer's handler
      // is merged with the close-on-Escape one (rather than being silently
      // overridden by the spread of `dialogProps` further below).
      onKeyDown,
      // Rest
      ...contentProps
    } = useContextSystem(props, "Popover");
    let computedFlipProp = flip4;
    let computedResizeProp = resize;
    if (__unstableForcePosition !== void 0) {
      (0, import_deprecated5.default)("`__unstableForcePosition` prop in wp.components.Popover", {
        since: "6.1",
        version: "6.3",
        alternative: "`flip={ false }` and  `resize={ false }`"
      });
      computedFlipProp = !__unstableForcePosition;
      computedResizeProp = !__unstableForcePosition;
    }
    if (anchorRef !== void 0) {
      (0, import_deprecated5.default)("`anchorRef` prop in wp.components.Popover", {
        since: "6.1",
        alternative: "`anchor` prop"
      });
    }
    if (anchorRect !== void 0) {
      (0, import_deprecated5.default)("`anchorRect` prop in wp.components.Popover", {
        since: "6.1",
        alternative: "`anchor` prop"
      });
    }
    if (getAnchorRect !== void 0) {
      (0, import_deprecated5.default)("`getAnchorRect` prop in wp.components.Popover", {
        since: "6.1",
        alternative: "`anchor` prop"
      });
    }
    const computedVariant = isAlternate ? "toolbar" : variant;
    if (isAlternate !== void 0) {
      (0, import_deprecated5.default)("`isAlternate` prop in wp.components.Popover", {
        since: "6.2",
        alternative: "`variant` prop with the `'toolbar'` value"
      });
    }
    const arrowRef = (0, import_element50.useRef)(null);
    const [fallbackReferenceElement, setFallbackReferenceElement] = (0, import_element50.useState)(null);
    const anchorRefFallback = (0, import_element50.useCallback)((node2) => {
      setFallbackReferenceElement(node2);
    }, []);
    const isMobileViewport = (0, import_compose16.useViewportMatch)("medium", "<");
    const isExpanded = expandOnMobile && isMobileViewport;
    const hasArrow = !isExpanded && !noArrow;
    const normalizedPlacementFromProps = position2 ? positionToPlacement(position2) : placementProp;
    const middleware2 = [...placementProp === "overlay" ? overlayMiddlewares() : [], offset3(offsetProp), computedFlipProp && flip3(), computedResizeProp && size3({
      padding: OVERFLOW_PADDING,
      apply(sizeProps) {
        const {
          firstElementChild
        } = refs.floating.current ?? {};
        if (!(firstElementChild instanceof HTMLElement)) {
          return;
        }
        Object.assign(firstElementChild.style, {
          maxHeight: `${Math.max(0, sizeProps.availableHeight)}px`,
          overflow: "auto"
        });
      }
    }), shift4 && shift3({
      crossAxis: true,
      limiter: limitShift3(),
      padding: 1
      // Necessary to avoid flickering at the edge of the viewport.
    }), arrow3({
      element: arrowRef
    })];
    const slotName = (0, import_element50.useContext)(slotNameContext) || __unstableSlotName;
    const slot = useSlot(slotName);
    let onDialogClose;
    if (onClose || onFocusOutside) {
      onDialogClose = (type, event) => {
        if (type === "focus-outside") {
          const blurTarget = event?.target;
          const referenceElement = refs.reference.current;
          const floatingElement = refs.floating.current;
          const isBlurFromThisPopover = referenceElement && "contains" in referenceElement && referenceElement.contains(blurTarget) || floatingElement?.contains(blurTarget);
          const ownerDocument = floatingElement?.ownerDocument;
          if (!isBlurFromThisPopover && !("relatedTarget" in event && event.relatedTarget) && ownerDocument?.activeElement === ownerDocument?.body) {
            return;
          }
          const relatedTarget = "relatedTarget" in event ? event.relatedTarget : null;
          if (relatedTarget instanceof Element && relatedTarget.closest("[data-wp-compat-overlay-slot]")) {
            return;
          }
          if (floatingElement && ownerDocument?.activeElement instanceof Element && floatingElement.contains(ownerDocument.activeElement)) {
            return;
          }
          if (onFocusOutside) {
            onFocusOutside(event);
          } else if (onClose) {
            onClose();
          }
        } else if (onClose) {
          onClose();
        }
      };
    }
    const [dialogRef, dialogProps] = (0, import_compose16.__experimentalUseDialog)({
      constrainTabbing,
      focusOnMount,
      onKeyDown,
      __unstableOnClose: onDialogClose,
      // @ts-expect-error The __unstableOnClose property needs to be deprecated first (see https://github.com/WordPress/gutenberg/pull/27675)
      onClose: onDialogClose
    });
    const {
      // Positioning coordinates
      x: x2,
      y: y3,
      // Object with "regular" refs to both "reference" and "floating"
      refs,
      // Type of CSS position property to use (absolute or fixed)
      strategy,
      update,
      placement: computedPlacement,
      middlewareData: {
        arrow: arrowData
      }
    } = useFloating({
      placement: normalizedPlacementFromProps === "overlay" ? void 0 : normalizedPlacementFromProps,
      middleware: middleware2,
      whileElementsMounted: (referenceParam, floatingParam, updateParam) => autoUpdate(referenceParam, floatingParam, updateParam, {
        layoutShift: false,
        animationFrame: true
      })
    });
    const arrowCallbackRef = (0, import_element50.useCallback)((node2) => {
      arrowRef.current = node2;
      update();
    }, [update]);
    const anchorRefTop = anchorRef?.top;
    const anchorRefBottom = anchorRef?.bottom;
    const anchorRefStartContainer = anchorRef?.startContainer;
    const anchorRefCurrent = anchorRef?.current;
    (0, import_element50.useLayoutEffect)(() => {
      const resultingReferenceElement = getReferenceElement({
        anchor,
        anchorRef,
        anchorRect,
        getAnchorRect,
        fallbackReferenceElement
      });
      refs.setReference(resultingReferenceElement);
    }, [anchor, anchorRef, anchorRefTop, anchorRefBottom, anchorRefStartContainer, anchorRefCurrent, anchorRect, getAnchorRect, fallbackReferenceElement, refs]);
    const mergedFloatingRef = (0, import_compose16.useMergeRefs)([refs.setFloating, dialogRef, forwardedRef]);
    const style2 = isExpanded ? void 0 : {
      position: strategy,
      top: 0,
      left: 0,
      // `x` and `y` are framer-motion specific props and are shorthands
      // for `translateX` and `translateY`. Currently it is not possible
      // to use `translateX` and `translateY` because those values would
      // be overridden by the return value of the
      // `placementToMotionAnimationProps` function.
      x: computePopoverPosition(x2),
      y: computePopoverPosition(y3)
    };
    const shouldReduceMotion = (0, import_compose16.useReducedMotion)();
    const shouldAnimate = animate && !isExpanded && !shouldReduceMotion;
    const [animationFinished, setAnimationFinished] = (0, import_element50.useState)(false);
    const {
      style: motionInlineStyles,
      ...otherMotionProps
    } = (0, import_element50.useMemo)(() => placementToMotionAnimationProps(computedPlacement), [computedPlacement]);
    const animationProps = shouldAnimate ? {
      style: {
        ...contentStyle,
        ...motionInlineStyles,
        ...style2
      },
      onAnimationComplete: () => setAnimationFinished(true),
      ...otherMotionProps
    } : {
      animate: false,
      style: {
        ...contentStyle,
        ...style2
      }
    };
    const isPositioned = (!shouldAnimate || animationFinished) && x2 !== null && y3 !== null;
    let content = /* @__PURE__ */ (0, import_jsx_runtime109.jsxs)(motion.div, {
      className: clsx_default(className2, {
        "is-expanded": isExpanded,
        "is-positioned": isPositioned,
        // Use the 'alternate' classname for 'toolbar' variant for back compat.
        [`is-${computedVariant === "toolbar" ? "alternate" : computedVariant}`]: computedVariant
      }),
      ...animationProps,
      ...contentProps,
      ref: mergedFloatingRef,
      ...dialogProps,
      tabIndex: -1,
      children: [isExpanded && /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(scroll_lock_default, {}), isExpanded && /* @__PURE__ */ (0, import_jsx_runtime109.jsxs)("div", {
        className: "components-popover__header",
        children: [/* @__PURE__ */ (0, import_jsx_runtime109.jsx)("span", {
          className: "components-popover__header-title",
          children: headerTitle
        }), /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(button_default, {
          className: "components-popover__close",
          size: "small",
          icon: close_default,
          onClick: onClose,
          label: (0, import_i18n7.__)("Close")
        })]
      }), /* @__PURE__ */ (0, import_jsx_runtime109.jsx)("div", {
        className: "components-popover__content",
        children
      }), hasArrow && /* @__PURE__ */ (0, import_jsx_runtime109.jsx)("div", {
        ref: arrowCallbackRef,
        className: ["components-popover__arrow", `is-${computedPlacement.split("-")[0]}`].join(" "),
        style: {
          left: typeof arrowData?.x !== "undefined" && Number.isFinite(arrowData.x) ? `${arrowData.x}px` : "",
          top: typeof arrowData?.y !== "undefined" && Number.isFinite(arrowData.y) ? `${arrowData.y}px` : ""
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(ArrowTriangle, {})
      })]
    });
    const shouldRenderWithinSlot = slot.ref && !inline3;
    const hasAnchor = anchorRef || anchorRect || anchor;
    if (shouldRenderWithinSlot) {
      content = /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(Fill, {
        name: slotName,
        children: content
      });
    } else if (!inline3) {
      content = (0, import_element50.createPortal)(/* @__PURE__ */ (0, import_jsx_runtime109.jsx)(StyleProvider, {
        document,
        children: content
      }), getPopoverFallbackContainer());
    }
    if (hasAnchor) {
      return content;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime109.jsxs)(import_jsx_runtime109.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime109.jsx)("span", {
        ref: anchorRefFallback
      }), content]
    });
  };
  var PopoverSlot = (0, import_element50.forwardRef)(({
    name = SLOT_NAME
  }, ref) => {
    return /* @__PURE__ */ (0, import_jsx_runtime109.jsx)(Slot3, {
      bubblesVirtually: true,
      name,
      className: "popover-slot",
      ref
    });
  });
  var Popover3 = Object.assign(contextConnect(UnforwardedPopover, "Popover"), {
    /**
     * Renders a slot that is used internally by Popover for rendering content.
     */
    Slot: Object.assign(PopoverSlot, {
      displayName: "Popover.Slot"
    }),
    /**
     * Provides a context to manage popover slot names.
     *
     * This is marked as unstable and should not be used directly.
     */
    __unstableSlotNameProvider: Object.assign(slotNameContext.Provider, {
      displayName: "Popover.__unstableSlotNameProvider"
    })
  });
  var popover_default = Popover3;

  // packages/components/build-module/autocomplete/autocompleter-ui.mjs
  var import_jsx_runtime110 = __toESM(require_jsx_runtime(), 1);
  function ListBox({
    items,
    onSelect,
    selectedIndex,
    instanceId,
    listBoxId,
    className: className2,
    Component: Component7 = "div"
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime110.jsx)(Component7, {
      id: listBoxId,
      role: "listbox",
      className: "components-autocomplete__results",
      children: items.map((option, index2) => /* @__PURE__ */ (0, import_jsx_runtime110.jsx)(button_default, {
        id: `components-autocomplete-item-${instanceId}-${option.key}`,
        role: "option",
        __next40pxDefaultSize: true,
        "aria-selected": index2 === selectedIndex,
        accessibleWhenDisabled: true,
        disabled: option.isDisabled,
        className: clsx_default("components-autocomplete__result", className2, {
          // Unused, for backwards compatibility.
          "is-selected": index2 === selectedIndex
        }),
        variant: index2 === selectedIndex ? "primary" : void 0,
        onClick: () => onSelect(option),
        children: option.label
      }, option.key))
    });
  }
  function AutocompleterUI({
    autocompleter,
    filterValue,
    instanceId,
    listBoxId,
    className: className2,
    selectedIndex,
    onChangeOptions,
    onSelect,
    reset,
    contentRef
  }) {
    const useItems = autocompleter.useItems ?? getDefaultUseItems(autocompleter);
    const [items] = useItems(filterValue);
    const popoverAnchor = (0, import_rich_text.useAnchor)({
      editableContentElement: contentRef.current
    });
    const [needsA11yCompat, setNeedsA11yCompat] = (0, import_element51.useState)(false);
    const popoverRef = (0, import_element51.useRef)(null);
    const popoverRefs = (0, import_compose17.useMergeRefs)([popoverRef, (0, import_compose17.useRefEffect)((node2) => {
      if (!contentRef.current) {
        return;
      }
      setNeedsA11yCompat(node2.ownerDocument !== contentRef.current.ownerDocument);
    }, [contentRef])]);
    useOnClickOutside(popoverRef, reset);
    const debouncedSpeak = (0, import_compose17.useDebounce)(import_a11y.speak, 500);
    function announce(options2) {
      if (!debouncedSpeak) {
        return;
      }
      if (!!options2.length) {
        if (filterValue) {
          debouncedSpeak((0, import_i18n8.sprintf)(
            /* translators: %d: number of results. */
            (0, import_i18n8._n)("%d result found, use up and down arrow keys to navigate.", "%d results found, use up and down arrow keys to navigate.", options2.length),
            options2.length
          ), "assertive");
        } else {
          debouncedSpeak((0, import_i18n8.sprintf)(
            /* translators: %d: number of results. */
            (0, import_i18n8._n)("Initial %d result loaded. Type to filter all available results. Use up and down arrow keys to navigate.", "Initial %d results loaded. Type to filter all available results. Use up and down arrow keys to navigate.", options2.length),
            options2.length
          ), "assertive");
        }
      } else {
        debouncedSpeak((0, import_i18n8.__)("No results."), "assertive");
      }
    }
    (0, import_element51.useLayoutEffect)(() => {
      onChangeOptions(items);
      announce(items);
    }, [items]);
    if (items.length === 0) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime110.jsxs)(import_jsx_runtime110.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime110.jsx)(popover_default, {
        offset: 8,
        focusOnMount: false,
        placement: "top-start",
        className: "components-autocomplete__popover",
        anchor: popoverAnchor,
        ref: popoverRefs,
        children: /* @__PURE__ */ (0, import_jsx_runtime110.jsx)(ListBox, {
          items,
          onSelect,
          selectedIndex,
          instanceId,
          listBoxId,
          className: className2
        })
      }), contentRef.current && needsA11yCompat && (0, import_react_dom6.createPortal)(/* @__PURE__ */ (0, import_jsx_runtime110.jsx)(ListBox, {
        items,
        onSelect,
        selectedIndex,
        instanceId,
        listBoxId,
        className: className2,
        Component: component_default2
      }), contentRef.current.ownerDocument.body)]
    });
  }
  function useOnClickOutside(ref, handler) {
    (0, import_element51.useEffect)(() => {
      const listener = (event) => {
        if (!ref.current || ref.current.contains(event.target)) {
          return;
        }
        handler(event);
      };
      document.addEventListener("mousedown", listener);
      document.addEventListener("touchstart", listener);
      return () => {
        document.removeEventListener("mousedown", listener);
        document.removeEventListener("touchstart", listener);
      };
    }, [handler, ref]);
  }

  // packages/components/build-module/autocomplete/get-autocomplete-match.mjs
  var import_remove_accents3 = __toESM(require_remove_accents(), 1);
  function getAutocompleteMatch(textContent, completers, options2) {
    const {
      matchCount,
      isBackspacing,
      getTextAfterSelection,
      lastCompletion
    } = options2;
    if (!textContent) {
      return null;
    }
    let completer = null;
    let triggerIndex = -1;
    let matchedEndIndex = -1;
    let matchedPrefixLength = 0;
    for (const currentCompleter of completers) {
      const currentIndex = textContent.lastIndexOf(currentCompleter.triggerPrefix);
      if (currentIndex < 0) {
        continue;
      }
      const currentEndIndex = currentIndex + currentCompleter.triggerPrefix.length;
      if (currentEndIndex > matchedEndIndex || currentEndIndex === matchedEndIndex && currentCompleter.triggerPrefix.length > matchedPrefixLength) {
        completer = currentCompleter;
        triggerIndex = currentIndex;
        matchedEndIndex = currentEndIndex;
        matchedPrefixLength = currentCompleter.triggerPrefix.length;
      }
    }
    if (!completer) {
      return null;
    }
    const {
      allowContext,
      triggerPrefix
    } = completer;
    const textWithoutTrigger = textContent.slice(triggerIndex + triggerPrefix.length);
    if (textWithoutTrigger.length > 50) {
      return null;
    }
    const mismatch = matchCount === 0;
    const wordsFromTrigger = textWithoutTrigger.split(/\s/);
    const hasOneTriggerWord = wordsFromTrigger.length === 1;
    const matchingWhileBackspacing = isBackspacing && wordsFromTrigger.length <= 3;
    if (mismatch && !(matchingWhileBackspacing || hasOneTriggerWord)) {
      return null;
    }
    if (allowContext && !allowContext(textContent.slice(0, triggerIndex), getTextAfterSelection())) {
      return null;
    }
    if (/^\s/.test(textWithoutTrigger) || /\s\s+$/.test(textWithoutTrigger)) {
      return null;
    }
    if (lastCompletion && lastCompletion.name === completer.name && textWithoutTrigger.trimEnd() === lastCompletion.value) {
      return null;
    }
    return {
      completer,
      filterValue: (0, import_remove_accents3.default)(textWithoutTrigger)
    };
  }

  // packages/components/build-module/utils/get-node-text.mjs
  var getNodeText = (node2) => {
    if (node2 === null) {
      return "";
    }
    switch (typeof node2) {
      case "string":
      case "number":
        return node2.toString();
      case "object": {
        if (node2 instanceof Array) {
          return node2.map(getNodeText).join("");
        }
        if ("props" in node2) {
          return getNodeText(node2.props.children);
        }
        return "";
      }
      default:
        return "";
    }
  };
  var get_node_text_default = getNodeText;

  // packages/components/build-module/lock-unlock.mjs
  var import_private_apis = __toESM(require_private_apis(), 1);
  var {
    lock,
    unlock
  } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)("I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", "@wordpress/components");

  // packages/components/build-module/autocomplete/index.mjs
  var import_jsx_runtime111 = __toESM(require_jsx_runtime(), 1);
  var {
    subscribeOwnedListener
  } = unlock(import_rich_text2.privateApis);
  var EMPTY_FILTERED_OPTIONS = [];
  var AUTOCOMPLETE_HOOK_REFERENCE = {};
  function getCompletionObject(completion) {
    if (completion !== null && typeof completion === "object" && "action" in completion && completion.action !== void 0 && "value" in completion && completion.value !== void 0) {
      return completion;
    }
    return {
      action: "insert-at-caret",
      value: completion
    };
  }
  var initialState = {
    selectedIndex: 0,
    filteredOptions: EMPTY_FILTERED_OPTIONS,
    filterValue: "",
    autocompleter: null
  };
  function autocompleteReducer(state, action) {
    switch (action.type) {
      case "RESET":
        return initialState;
      case "SELECT":
        return {
          ...state,
          selectedIndex: action.index
        };
      case "OPTIONS":
        return {
          ...state,
          filteredOptions: action.options,
          selectedIndex: action.options.length === state.filteredOptions.length ? state.selectedIndex : 0
        };
      case "MATCH":
        return {
          ...state,
          autocompleter: action.completer,
          filterValue: action.query
        };
    }
  }
  function useAutocomplete({
    record,
    onChange,
    onReplace,
    completers,
    contentRef
  }) {
    const instanceId = (0, import_compose18.useInstanceId)(AUTOCOMPLETE_HOOK_REFERENCE);
    const [state, dispatch] = (0, import_element52.useReducer)(autocompleteReducer, initialState);
    const {
      selectedIndex,
      filteredOptions,
      filterValue,
      autocompleter
    } = state;
    const backspacingRef = (0, import_element52.useRef)(false);
    const prevRecordTextRef = (0, import_element52.useRef)("");
    const lastCompletionRef = (0, import_element52.useRef)(null);
    function insertCompletion(replacement) {
      if (autocompleter === null) {
        return "";
      }
      const end = record.start;
      const start = end - autocompleter.triggerPrefix.length - filterValue.length;
      const toInsert = (0, import_rich_text2.create)({
        html: (0, import_element52.renderToString)(replacement)
      });
      onChange((0, import_rich_text2.insert)(record, toInsert, start, end));
      return (0, import_rich_text2.getTextContent)(toInsert);
    }
    function select(option) {
      if (option.isDisabled || !autocompleter) {
        return;
      }
      const {
        getOptionCompletion
      } = autocompleter;
      if (!getOptionCompletion) {
        dispatch({
          type: "RESET"
        });
        contentRef.current?.focus();
        return;
      }
      const completionObject = getCompletionObject(getOptionCompletion(option.value, filterValue));
      if ("replace" === completionObject.action) {
        onReplace([completionObject.value]);
        return;
      }
      if ("insert-at-caret" === completionObject.action) {
        const completionText = insertCompletion(completionObject.value);
        if (completionText.startsWith(autocompleter.triggerPrefix)) {
          const afterPrefix = completionText.slice(autocompleter.triggerPrefix.length);
          if (afterPrefix) {
            lastCompletionRef.current = {
              name: autocompleter.name,
              value: afterPrefix
            };
          }
        }
      }
      dispatch({
        type: "RESET"
      });
      contentRef.current?.focus();
    }
    function onChangeOptions(options2) {
      dispatch({
        type: "OPTIONS",
        options: options2
      });
    }
    function handleKeyDown(event) {
      backspacingRef.current = event.key === "Backspace";
      if (!autocompleter) {
        return;
      }
      if (filteredOptions.length === 0) {
        return;
      }
      if (event.defaultPrevented) {
        return;
      }
      switch (event.key) {
        case "ArrowUp":
        case "ArrowDown": {
          const offset4 = event.key === "ArrowUp" ? -1 : 1;
          const newIndex = (selectedIndex + offset4 + filteredOptions.length) % filteredOptions.length;
          dispatch({
            type: "SELECT",
            index: newIndex
          });
          if ((0, import_keycodes.isAppleOS)()) {
            (0, import_a11y2.speak)(get_node_text_default(filteredOptions[newIndex].label), "assertive");
          }
          break;
        }
        case "Escape":
          dispatch({
            type: "RESET"
          });
          event.preventDefault();
          break;
        case "Enter":
          select(filteredOptions[selectedIndex]);
          break;
        case "ArrowLeft":
        case "ArrowRight":
          dispatch({
            type: "RESET"
          });
          return;
        default:
          return;
      }
      event.preventDefault();
    }
    const textContent = (0, import_element52.useMemo)(() => {
      if ((0, import_rich_text2.isCollapsed)(record)) {
        return (0, import_rich_text2.getTextContent)((0, import_rich_text2.slice)(record, 0));
      }
      return "";
    }, [record]);
    (0, import_element52.useEffect)(() => {
      const isTextChange = record.text !== prevRecordTextRef.current;
      prevRecordTextRef.current = record.text;
      function getTextAfterSelection() {
        return textContent ? (0, import_rich_text2.getTextContent)((0, import_rich_text2.slice)(record, void 0, (0, import_rich_text2.getTextContent)(record).length)) : "";
      }
      const match4 = getAutocompleteMatch(textContent, completers, {
        matchCount: filteredOptions.length,
        isBackspacing: backspacingRef.current,
        getTextAfterSelection,
        lastCompletion: lastCompletionRef.current
      });
      if (!match4) {
        if (autocompleter) {
          dispatch({
            type: "RESET"
          });
        }
        return;
      }
      const {
        completer,
        filterValue: query
      } = match4;
      if (!autocompleter && !isTextChange) {
        return;
      }
      if (lastCompletionRef.current && lastCompletionRef.current.name === completer.name) {
        lastCompletionRef.current = null;
      }
      dispatch({
        type: "MATCH",
        completer,
        query
      });
    }, [textContent]);
    const {
      key: selectedKey = ""
    } = filteredOptions[selectedIndex] || {};
    const {
      className: className2
    } = autocompleter || {};
    const isExpanded = !!autocompleter && filteredOptions.length > 0;
    const listBoxId = isExpanded ? `components-autocomplete-listbox-${instanceId}` : void 0;
    const activeId = isExpanded ? `components-autocomplete-item-${instanceId}-${selectedKey}` : null;
    const hasSelection = record.start !== void 0;
    const showPopover = !!textContent && hasSelection && !!autocompleter;
    return {
      listBoxId,
      activeId,
      onKeyDown: withIgnoreIMEEvents(handleKeyDown),
      popover: showPopover && /* @__PURE__ */ (0, import_jsx_runtime111.jsx)(AutocompleterUI, {
        autocompleter,
        className: className2,
        filterValue,
        instanceId,
        listBoxId,
        selectedIndex,
        onChangeOptions,
        onSelect: select,
        contentRef,
        reset: () => dispatch({
          type: "RESET"
        })
      }, autocompleter.name + autocompleter.triggerPrefix)
    };
  }
  function recordValuesMatch(a3, b3) {
    return a3.text === b3.text && a3.start === b3.start && a3.end === b3.end;
  }
  function useLastDifferentValue(value) {
    const history = (0, import_element52.useRef)([]);
    const lastEntry = history.current[history.current.length - 1];
    if (!lastEntry || !recordValuesMatch(value, lastEntry)) {
      history.current.push(value);
    }
    if (history.current.length > 2) {
      history.current.shift();
    }
    return history.current[0];
  }
  function useAutocompleteProps(options2) {
    const ref = (0, import_element52.useRef)(null);
    const onKeyDownRef = (0, import_element52.useRef)(void 0);
    const {
      record
    } = options2;
    const previousRecord = useLastDifferentValue(record);
    const {
      popover,
      listBoxId,
      activeId,
      onKeyDown
    } = useAutocomplete({
      ...options2,
      contentRef: ref
    });
    onKeyDownRef.current = onKeyDown;
    const mergedRefs = (0, import_compose18.useMergeRefs)([ref, (0, import_compose18.useRefEffect)((element) => {
      function _onKeyDown(event) {
        onKeyDownRef.current?.(event);
      }
      return subscribeOwnedListener(element, "keydown", _onKeyDown, true);
    }, [])]);
    const didUserInput = record.text !== previousRecord?.text;
    if (!didUserInput) {
      return {
        ref: mergedRefs
      };
    }
    return {
      ref: mergedRefs,
      children: popover,
      "aria-autocomplete": listBoxId ? "list" : void 0,
      "aria-haspopup": listBoxId ? "listbox" : void 0,
      "aria-controls": listBoxId,
      "aria-owns": listBoxId,
      "aria-activedescendant": activeId ?? void 0
    };
  }
  function Autocomplete({
    children,
    isSelected: isSelected2,
    ...options2
  }) {
    const {
      popover,
      ...props
    } = useAutocomplete(options2);
    return /* @__PURE__ */ (0, import_jsx_runtime111.jsxs)(import_jsx_runtime111.Fragment, {
      children: [children(props), isSelected2 && popover]
    });
  }

  // packages/components/build-module/border-box-control/border-box-control/component.mjs
  var import_i18n26 = __toESM(require_i18n(), 1);
  var import_element89 = __toESM(require_element(), 1);
  var import_compose36 = __toESM(require_compose(), 1);

  // packages/components/build-module/border-box-control/border-box-control-linked-button/component.mjs
  var import_i18n9 = __toESM(require_i18n(), 1);

  // packages/components/build-module/border-box-control/border-box-control-linked-button/hook.mjs
  var import_element53 = __toESM(require_element(), 1);

  // packages/components/build-module/border-box-control/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__7() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var borderBoxControl = /* @__PURE__ */ css(false ? "" : ";label:borderBoxControl;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var linkedBorderControl = () => /* @__PURE__ */ css("&&{flex:1;", rtl({
    marginRight: "24px"
  })(), ";}" + (false ? "" : ";label:linkedBorderControl;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var wrapper = false ? {
    name: "bjn8wh",
    styles: "position:relative"
  } : {
    name: "memc06-wrapper",
    styles: "position:relative;label:wrapper;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__7
  };
  var borderBoxControlLinkedButton = /* @__PURE__ */ css("position:absolute;top:8px;", rtl({
    right: 0
  })(), " line-height:0;" + (false ? "" : ";label:borderBoxControlLinkedButton;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var borderBoxStyleWithFallback = (border) => {
    const {
      color: color2 = COLORS.gray[200],
      style: style2 = "solid",
      width = config_values_default.borderWidth
    } = border || {};
    const clampedWidth = width !== config_values_default.borderWidth ? `clamp(1px, ${width}, 10px)` : width;
    const hasVisibleBorder = !!width && width !== "0" || !!color2;
    const borderStyle = hasVisibleBorder ? style2 || "solid" : style2;
    return `${color2} ${borderStyle} ${clampedWidth}`;
  };
  var borderBoxControlVisualizer = (borders2) => /* @__PURE__ */ css("position:absolute;top:20px;right:39px;bottom:20px;left:39px;border-top:", borderBoxStyleWithFallback(borders2?.top), ";border-bottom:", borderBoxStyleWithFallback(borders2?.bottom), ";", rtl({
    borderLeft: borderBoxStyleWithFallback(borders2?.left)
  })(), " ", rtl({
    borderRight: borderBoxStyleWithFallback(borders2?.right)
  })(), ";" + (false ? "" : ";label:borderBoxControlVisualizer;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var borderBoxControlSplitControls = false ? {
    name: "3ldklc",
    styles: "position:relative;flex:1"
  } : {
    name: "1bmnp6g-borderBoxControlSplitControls",
    styles: "position:relative;flex:1;label:borderBoxControlSplitControls;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__7
  };
  var centeredBorderControl = false ? {
    name: "1nwbfnf",
    styles: "grid-column:span 2;margin:0 auto"
  } : {
    name: "gedmrr-centeredBorderControl",
    styles: "grid-column:span 2;margin:0 auto;label:centeredBorderControl;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__7
  };
  var rightBorderControl = () => /* @__PURE__ */ css(rtl({
    marginLeft: "auto"
  })(), ";" + (false ? "" : ";label:rightBorderControl;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");

  // packages/components/build-module/border-box-control/border-box-control-linked-button/hook.mjs
  function useBorderBoxControlLinkedButton(props) {
    const {
      className: className2,
      ...otherProps
    } = useContextSystem(props, "BorderBoxControlLinkedButton");
    const cx2 = useCx();
    const classes = (0, import_element53.useMemo)(() => {
      return cx2(borderBoxControlLinkedButton, className2);
    }, [className2, cx2]);
    return {
      ...otherProps,
      className: classes
    };
  }

  // packages/components/build-module/border-box-control/border-box-control-linked-button/component.mjs
  var import_jsx_runtime112 = __toESM(require_jsx_runtime(), 1);
  var BorderBoxControlLinkedButton = (props, forwardedRef) => {
    const {
      className: className2,
      isLinked,
      ...buttonProps
    } = useBorderBoxControlLinkedButton(props);
    const label = isLinked ? (0, import_i18n9.__)("Unlink sides") : (0, import_i18n9.__)("Link sides");
    return /* @__PURE__ */ (0, import_jsx_runtime112.jsx)(button_default, {
      ...buttonProps,
      size: "small",
      icon: isLinked ? link_default : link_off_default,
      iconSize: 24,
      label,
      ref: forwardedRef,
      className: className2
    });
  };
  var ConnectedBorderBoxControlLinkedButton = contextConnect(BorderBoxControlLinkedButton, "BorderBoxControlLinkedButton");
  var component_default10 = ConnectedBorderBoxControlLinkedButton;

  // packages/components/build-module/border-box-control/border-box-control-split-controls/component.mjs
  var import_i18n25 = __toESM(require_i18n(), 1);
  var import_element87 = __toESM(require_element(), 1);
  var import_compose35 = __toESM(require_compose(), 1);

  // packages/components/build-module/border-box-control/border-box-control-visualizer/hook.mjs
  var import_element54 = __toESM(require_element(), 1);
  function useBorderBoxControlVisualizer(props) {
    const {
      className: className2,
      value,
      ...otherProps
    } = useContextSystem(props, "BorderBoxControlVisualizer");
    const cx2 = useCx();
    const classes = (0, import_element54.useMemo)(() => {
      return cx2(borderBoxControlVisualizer(value), className2);
    }, [cx2, className2, value]);
    return {
      ...otherProps,
      className: classes,
      value
    };
  }

  // packages/components/build-module/border-box-control/border-box-control-visualizer/component.mjs
  var import_jsx_runtime113 = __toESM(require_jsx_runtime(), 1);
  var BorderBoxControlVisualizer = (props, forwardedRef) => {
    const {
      value,
      ...otherProps
    } = useBorderBoxControlVisualizer(props);
    return /* @__PURE__ */ (0, import_jsx_runtime113.jsx)(component_default, {
      ...otherProps,
      ref: forwardedRef
    });
  };
  var ConnectedBorderBoxControlVisualizer = contextConnect(BorderBoxControlVisualizer, "BorderBoxControlVisualizer");
  var component_default11 = ConnectedBorderBoxControlVisualizer;

  // packages/components/build-module/border-control/border-control/component.mjs
  var import_i18n24 = __toESM(require_i18n(), 1);

  // packages/components/build-module/border-control/border-control-dropdown/component.mjs
  var import_i18n22 = __toESM(require_i18n(), 1);

  // packages/components/build-module/border-control/border-control-style-picker/component.mjs
  var import_i18n11 = __toESM(require_i18n(), 1);

  // packages/components/build-module/toggle-group-control/toggle-group-control/component.mjs
  var import_element62 = __toESM(require_element(), 1);
  var import_compose25 = __toESM(require_compose(), 1);

  // packages/components/build-module/toggle-group-control/toggle-group-control/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__8() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var block2 = false ? {
    name: "7whenc",
    styles: "display:flex;width:100%"
  } : {
    name: "2dfrl8-block",
    styles: "display:flex;width:100%;label:block;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__8
  };
  var toggleGroupControl = ({
    isBlock,
    isDeselectable
  }) => /* @__PURE__ */ css("background:", COLORS.ui.background, ";border:1px solid transparent;border-radius:", config_values_default.radiusSmall, ";display:inline-flex;height:40px;min-width:0;position:relative;", !isDeselectable && enclosingBorders(isBlock), " ", isBlock && block2, "@media not ( prefers-reduced-motion ){&[data-indicator-animated]::before{transition-property:transform,border-radius;transition-duration:0.2s;transition-timing-function:ease-out;}}&::before{content:'';position:absolute;pointer-events:none;background:", COLORS.theme.gray[100], ";border:1px solid ", COLORS.theme.gray[700], ";outline:2px solid transparent;outline-offset:-3px;border-radius:", config_values_default.radiusSmall, ";top:-1px;left:-2px;width:calc( calc( var( --selected-width, 0 ) * 1px ) + 2px );height:calc( calc( var( --selected-height, 0 ) * 1px ) + 2px );transform:translateX( calc( var( --selected-left, 0 ) * 1px ) );opacity:min(\n			1,\n			max( 0, var( --selected-width, 0 ), var( --selected-height, 0 ) )\n		);}" + (false ? "" : ";label:toggleGroupControl;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var enclosingBorders = (isBlock) => {
    const enclosingBorder = /* @__PURE__ */ css("border-color:", COLORS.gray[300], ";" + (false ? "" : ";label:enclosingBorder;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
    return /* @__PURE__ */ css(isBlock && enclosingBorder, " &:hover{border-color:", COLORS.gray[400], ";}&:focus-within{z-index:1;outline:", config_values_default.borderWidthFocus, " solid ", COLORS.ui.borderFocus, ";outline-offset:1px;}" + (false ? "" : ";label:enclosingBorders;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  };

  // packages/components/build-module/toggle-group-control/toggle-group-control/as-radio-group.mjs
  var import_compose20 = __toESM(require_compose(), 1);
  var import_element57 = __toESM(require_element(), 1);
  var import_i18n10 = __toESM(require_i18n(), 1);

  // packages/components/build-module/toggle-group-control/context.mjs
  var import_element55 = __toESM(require_element(), 1);
  var ToggleGroupControlContext = (0, import_element55.createContext)({});
  ToggleGroupControlContext.displayName = "ToggleGroupControlContext";
  var useToggleGroupControlContext = () => (0, import_element55.useContext)(ToggleGroupControlContext);
  var context_default2 = ToggleGroupControlContext;

  // packages/components/build-module/toggle-group-control/toggle-group-control/utils.mjs
  var import_compose19 = __toESM(require_compose(), 1);
  var import_element56 = __toESM(require_element(), 1);
  function useComputeControlledOrUncontrolledValue(valueProp) {
    const isInitialRenderRef = (0, import_element56.useRef)(true);
    const prevValueProp = (0, import_compose19.usePrevious)(valueProp);
    const prevIsControlledRef = (0, import_element56.useRef)(false);
    (0, import_element56.useEffect)(() => {
      if (isInitialRenderRef.current) {
        isInitialRenderRef.current = false;
      }
    }, []);
    const isControlled = prevIsControlledRef.current || !isInitialRenderRef.current && prevValueProp !== valueProp;
    (0, import_element56.useEffect)(() => {
      prevIsControlledRef.current = isControlled;
    }, [isControlled]);
    if (isControlled) {
      return {
        value: valueProp ?? "",
        defaultValue: void 0
      };
    }
    return {
      value: void 0,
      defaultValue: valueProp
    };
  }

  // packages/components/build-module/toggle-group-control/toggle-group-control/as-radio-group.mjs
  var import_jsx_runtime114 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToggleGroupControlAsRadioGroup({
    children,
    isAdaptiveWidth,
    label,
    onChange: onChangeProp,
    value: valueProp,
    id: idProp,
    setSelectedElement,
    ...otherProps
  }, forwardedRef) {
    const generatedId = (0, import_compose20.useInstanceId)(ToggleGroupControlAsRadioGroup, "toggle-group-control-as-radio-group");
    const baseId = idProp || generatedId;
    const {
      value,
      defaultValue: defaultValue2
    } = useComputeControlledOrUncontrolledValue(valueProp);
    const wrappedOnChangeProp = onChangeProp ? (v3) => {
      onChangeProp(v3 ?? void 0);
    } : void 0;
    const radio = useRadioStore({
      defaultValue: defaultValue2,
      value,
      setValue: wrappedOnChangeProp,
      rtl: (0, import_i18n10.isRTL)()
    });
    const selectedValue = useStoreState(radio, "value");
    const setValue = radio.setValue;
    (0, import_element57.useEffect)(() => {
      if (selectedValue === "") {
        radio.setActiveId(void 0);
      }
    }, [radio, selectedValue]);
    const groupContextValue = (0, import_element57.useMemo)(() => ({
      activeItemIsNotFirstItem: () => radio.getState().activeId !== radio.first(),
      baseId,
      isBlock: !isAdaptiveWidth,
      // @ts-expect-error - This is wrong and we should fix it.
      value: selectedValue,
      // @ts-expect-error - This is wrong and we should fix it.
      setValue,
      setSelectedElement
    }), [baseId, isAdaptiveWidth, radio, selectedValue, setSelectedElement, setValue]);
    return /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(context_default2.Provider, {
      value: groupContextValue,
      children: /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(RadioGroup, {
        store: radio,
        "aria-label": label,
        render: /* @__PURE__ */ (0, import_jsx_runtime114.jsx)(component_default, {}),
        ...otherProps,
        id: baseId,
        ref: forwardedRef,
        children
      })
    });
  }
  var ToggleGroupControlAsRadioGroup = (0, import_element57.forwardRef)(UnforwardedToggleGroupControlAsRadioGroup);
  ToggleGroupControlAsRadioGroup.displayName = "ToggleGroupControlAsRadioGroup";

  // packages/components/build-module/toggle-group-control/toggle-group-control/as-button-group.mjs
  var import_compose21 = __toESM(require_compose(), 1);
  var import_element58 = __toESM(require_element(), 1);
  var import_jsx_runtime115 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToggleGroupControlAsButtonGroup({
    children,
    isAdaptiveWidth,
    label,
    onChange,
    value: valueProp,
    id: idProp,
    setSelectedElement,
    ...otherProps
  }, forwardedRef) {
    const generatedId = (0, import_compose21.useInstanceId)(ToggleGroupControlAsButtonGroup, "toggle-group-control-as-button-group");
    const baseId = idProp || generatedId;
    const {
      value,
      defaultValue: defaultValue2
    } = useComputeControlledOrUncontrolledValue(valueProp);
    const [selectedValue, setSelectedValue] = useControlledValue({
      defaultValue: defaultValue2,
      value,
      onChange
    });
    const groupContextValue = (0, import_element58.useMemo)(() => ({
      baseId,
      value: selectedValue,
      setValue: setSelectedValue,
      isBlock: !isAdaptiveWidth,
      isDeselectable: true,
      setSelectedElement
    }), [baseId, selectedValue, setSelectedValue, isAdaptiveWidth, setSelectedElement]);
    return /* @__PURE__ */ (0, import_jsx_runtime115.jsx)(context_default2.Provider, {
      value: groupContextValue,
      children: /* @__PURE__ */ (0, import_jsx_runtime115.jsx)(component_default, {
        "aria-label": label,
        ...otherProps,
        ref: forwardedRef,
        role: "group",
        id: baseId,
        children
      })
    });
  }
  var ToggleGroupControlAsButtonGroup = (0, import_element58.forwardRef)(UnforwardedToggleGroupControlAsButtonGroup);
  ToggleGroupControlAsButtonGroup.displayName = "ToggleGroupControlAsButtonGroup";

  // packages/components/build-module/utils/element-rect.mjs
  var import_element59 = __toESM(require_element(), 1);
  var import_compose22 = __toESM(require_compose(), 1);
  var NULL_ELEMENT_OFFSET_RECT = {
    element: void 0,
    top: 0,
    right: 0,
    bottom: 0,
    left: 0,
    width: 0,
    height: 0
  };
  function getElementOffsetRect(element) {
    const rect = element.getBoundingClientRect();
    if (rect.width === 0 || rect.height === 0) {
      return;
    }
    const offsetParent = element.offsetParent;
    const offsetParentRect = offsetParent?.getBoundingClientRect() ?? NULL_ELEMENT_OFFSET_RECT;
    const offsetParentScrollX = offsetParent?.scrollLeft ?? 0;
    const offsetParentScrollY = offsetParent?.scrollTop ?? 0;
    const computedWidth = parseFloat(getComputedStyle(element).width);
    const computedHeight = parseFloat(getComputedStyle(element).height);
    const scaleX = computedWidth / rect.width;
    const scaleY = computedHeight / rect.height;
    return {
      element,
      // To obtain the adjusted values for the position:
      // 1. Compute the element's position relative to the offset parent.
      // 2. Correct for the scale factor.
      // 3. Adjust for the scroll position of the offset parent.
      top: (rect.top - offsetParentRect?.top) * scaleY + offsetParentScrollY,
      right: (offsetParentRect?.right - rect.right) * scaleX - offsetParentScrollX,
      bottom: (offsetParentRect?.bottom - rect.bottom) * scaleY - offsetParentScrollY,
      left: (rect.left - offsetParentRect?.left) * scaleX + offsetParentScrollX,
      // Computed dimensions don't need any adjustments.
      width: computedWidth,
      height: computedHeight
    };
  }
  var POLL_RATE = 100;
  function useTrackElementOffsetRect(targetElement, deps = []) {
    const [indicatorPosition, setIndicatorPosition] = (0, import_element59.useState)(NULL_ELEMENT_OFFSET_RECT);
    const intervalRef = (0, import_element59.useRef)(void 0);
    const measure = (0, import_compose22.useEvent)(() => {
      if (targetElement && targetElement.isConnected) {
        const elementOffsetRect = getElementOffsetRect(targetElement);
        if (elementOffsetRect) {
          setIndicatorPosition(elementOffsetRect);
          clearInterval(intervalRef.current);
          return true;
        }
      } else {
        clearInterval(intervalRef.current);
      }
      return false;
    });
    const setElement = (0, import_compose22.useResizeObserver)(() => {
      if (!measure()) {
        requestAnimationFrame(() => {
          if (!measure()) {
            intervalRef.current = setInterval(measure, POLL_RATE);
          }
        });
      }
    });
    (0, import_element59.useLayoutEffect)(() => {
      setElement(targetElement);
      if (!targetElement) {
        setIndicatorPosition(NULL_ELEMENT_OFFSET_RECT);
      }
    }, [setElement, targetElement]);
    (0, import_element59.useLayoutEffect)(() => {
      measure();
    }, deps);
    return indicatorPosition;
  }

  // packages/components/build-module/utils/hooks/use-animated-offset-rect.mjs
  var import_compose24 = __toESM(require_compose(), 1);
  var import_element61 = __toESM(require_element(), 1);

  // packages/components/build-module/utils/hooks/use-on-value-update.mjs
  var import_compose23 = __toESM(require_compose(), 1);
  var import_element60 = __toESM(require_element(), 1);
  function useOnValueUpdate(value, onUpdate) {
    const previousValueRef = (0, import_element60.useRef)(value);
    const updateCallbackEvent = (0, import_compose23.useEvent)(onUpdate);
    (0, import_element60.useLayoutEffect)(() => {
      if (previousValueRef.current !== value) {
        updateCallbackEvent({
          previousValue: previousValueRef.current
        });
        previousValueRef.current = value;
      }
    }, [updateCallbackEvent, value]);
  }

  // packages/components/build-module/utils/hooks/use-animated-offset-rect.mjs
  function useAnimatedOffsetRect(container, rect, {
    prefix: prefix2 = "subelement",
    dataAttribute = `${prefix2}-animated`,
    transitionEndFilter = () => true,
    roundRect = false
  } = {}) {
    const setProperties = (0, import_compose24.useEvent)(() => {
      Object.keys(rect).forEach((property) => property !== "element" && container?.style.setProperty(`--${prefix2}-${property}`, String(roundRect ? Math.floor(rect[property]) : rect[property])));
    });
    (0, import_element61.useLayoutEffect)(() => {
      setProperties();
    }, [rect, setProperties]);
    useOnValueUpdate(rect.element, ({
      previousValue
    }) => {
      if (rect.element && previousValue) {
        container?.setAttribute(`data-${dataAttribute}`, "");
      }
    });
    (0, import_element61.useLayoutEffect)(() => {
      function onTransitionEnd(event) {
        if (transitionEndFilter(event)) {
          container?.removeAttribute(`data-${dataAttribute}`);
        }
      }
      container?.addEventListener("transitionend", onTransitionEnd);
      return () => container?.removeEventListener("transitionend", onTransitionEnd);
    }, [dataAttribute, container, transitionEndFilter]);
  }

  // packages/components/build-module/toggle-group-control/toggle-group-control/component.mjs
  var import_jsx_runtime116 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedToggleGroupControl(props, forwardedRef) {
    const {
      // Prevent passing legacy props to internal component.
      __nextHasNoMarginBottom: _2,
      size: _size,
      __next40pxDefaultSize: _next40pxDefaultSize,
      __shouldNotWarnDeprecated36pxSize: _shouldNotWarnDeprecated36pxSize,
      className: className2,
      isAdaptiveWidth = false,
      isBlock = false,
      isDeselectable = false,
      id: id3,
      label,
      hideLabelFromVision = false,
      help,
      onChange,
      value,
      children,
      ...otherProps
    } = useContextSystem(props, "ToggleGroupControl");
    const {
      baseControlProps,
      controlProps
    } = useBaseControlProps({
      id: id3,
      help,
      label,
      hideLabelFromVision
    });
    const [selectedElement, setSelectedElement] = (0, import_element62.useState)();
    const [controlElement, setControlElement] = (0, import_element62.useState)();
    const refs = (0, import_compose25.useMergeRefs)([setControlElement, forwardedRef]);
    const selectedRect = useTrackElementOffsetRect(value !== null && value !== void 0 ? selectedElement : void 0);
    useAnimatedOffsetRect(controlElement, selectedRect, {
      prefix: "selected",
      dataAttribute: "indicator-animated",
      transitionEndFilter: (event) => event.pseudoElement === "::before",
      roundRect: false
    });
    const cx2 = useCx();
    const classes = (0, import_element62.useMemo)(() => cx2(toggleGroupControl({
      isBlock,
      isDeselectable
    }), className2), [className2, cx2, isBlock, isDeselectable]);
    const MainControl = isDeselectable ? ToggleGroupControlAsButtonGroup : ToggleGroupControlAsRadioGroup;
    return /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(base_control_default, {
      ...baseControlProps,
      children: /* @__PURE__ */ (0, import_jsx_runtime116.jsx)(MainControl, {
        ...otherProps,
        ...controlProps,
        setSelectedElement,
        className: classes,
        isAdaptiveWidth,
        label,
        onChange,
        ref: refs,
        value,
        children
      })
    });
  }
  var ToggleGroupControl = contextConnect(UnconnectedToggleGroupControl, "ToggleGroupControl");
  var component_default12 = ToggleGroupControl;

  // packages/components/build-module/toggle-group-control/toggle-group-control-option/component.mjs
  var import_element64 = __toESM(require_element(), 1);

  // packages/components/build-module/toggle-group-control/toggle-group-control-option-base/component.mjs
  var import_compose26 = __toESM(require_compose(), 1);
  var import_element63 = __toESM(require_element(), 1);

  // packages/components/build-module/toggle-group-control/toggle-group-control-option-base/styles.mjs
  var styles_exports4 = {};
  __export(styles_exports4, {
    ButtonContentView: () => ButtonContentView,
    LabelView: () => LabelView,
    buttonView: () => buttonView,
    labelBlock: () => labelBlock
  });
  function _EMOTION_STRINGIFIED_CSS_ERROR__9() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var LabelView = /* @__PURE__ */ createStyled("div", false ? {
    target: "et6ln9s1"
  } : {
    target: "et6ln9s1",
    label: "LabelView"
  })(false ? {
    name: "sln1fl",
    styles: "display:inline-flex;max-width:100%;min-width:0;position:relative"
  } : {
    name: "sln1fl",
    styles: "display:inline-flex;max-width:100%;min-width:0;position:relative/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__9
  });
  var labelBlock = false ? {
    name: "82a6rk",
    styles: "flex:1"
  } : {
    name: "1sypmw-labelBlock",
    styles: "flex:1;label:labelBlock;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQjZCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHLCBDT0xPUlMgfSBmcm9tICcuLi8uLi91dGlscyc7XG5pbXBvcnQgdHlwZSB7XG5cdFRvZ2dsZUdyb3VwQ29udHJvbFByb3BzLFxuXHRUb2dnbGVHcm91cENvbnRyb2xPcHRpb25CYXNlUHJvcHMsXG59IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IGNvbnN0IExhYmVsVmlldyA9IHN0eWxlZC5kaXZgXG5cdGRpc3BsYXk6IGlubGluZS1mbGV4O1xuXHRtYXgtd2lkdGg6IDEwMCU7XG5cdG1pbi13aWR0aDogMDtcblx0cG9zaXRpb246IHJlbGF0aXZlO1xuYDtcblxuZXhwb3J0IGNvbnN0IGxhYmVsQmxvY2sgPSBjc3NgXG5cdGZsZXg6IDE7XG5gO1xuXG5leHBvcnQgY29uc3QgYnV0dG9uVmlldyA9ICgge1xuXHRpc0Rlc2VsZWN0YWJsZSxcblx0aXNJY29uLFxuXHRpc1ByZXNzZWQsXG59OiBQaWNrPCBUb2dnbGVHcm91cENvbnRyb2xQcm9wcywgJ2lzRGVzZWxlY3RhYmxlJyA+ICZcblx0UGljazwgVG9nZ2xlR3JvdXBDb250cm9sT3B0aW9uQmFzZVByb3BzLCAnaXNJY29uJyA+ICYge1xuXHRcdGlzUHJlc3NlZD86IGJvb2xlYW47XG5cdH0gKSA9PiBjc3NgXG5cdGFsaWduLWl0ZW1zOiBjZW50ZXI7XG5cdGFwcGVhcmFuY2U6IG5vbmU7XG5cdGJhY2tncm91bmQ6IHRyYW5zcGFyZW50O1xuXHRib3JkZXI6IG5vbmU7XG5cdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNYU21hbGwgfTtcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5ncmF5WyA3MDAgXSB9O1xuXHRmaWxsOiBjdXJyZW50Q29sb3I7XG5cdGN1cnNvcjogcG9pbnRlcjtcblx0ZGlzcGxheTogZmxleDtcblx0Zm9udC1mYW1pbHk6IGluaGVyaXQ7XG5cdGhlaWdodDogMTAwJTtcblx0anVzdGlmeS1jb250ZW50OiBjZW50ZXI7XG5cdGxpbmUtaGVpZ2h0OiAxMDAlO1xuXHRvdXRsaW5lOiBub25lO1xuXHRwYWRkaW5nOiAwIDEycHg7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0dGV4dC1hbGlnbjogY2VudGVyO1xuXHRAbWVkaWEgbm90ICggcHJlZmVycy1yZWR1Y2VkLW1vdGlvbiApIHtcblx0XHR0cmFuc2l0aW9uOlxuXHRcdFx0Y29sb3IgJHsgQ09ORklHLnRyYW5zaXRpb25EdXJhdGlvbkZhc3QgfSBsaW5lYXIsXG5cdFx0XHRmb250LXdlaWdodCA2MG1zIGxpbmVhcjtcblx0fVxuXHR1c2VyLXNlbGVjdDogbm9uZTtcblx0d2lkdGg6IDEwMCU7XG5cdHotaW5kZXg6IDI7XG5cblx0Jjo6LW1vei1mb2N1cy1pbm5lciB7XG5cdFx0Ym9yZGVyOiAwO1xuXHR9XG5cblx0JltkaXNhYmxlZF0sXG5cdCZbYXJpYS1kaXNhYmxlZD0ndHJ1ZSddIHtcblx0XHRvcGFjaXR5OiAwLjQ7XG5cdFx0Y3Vyc29yOiBkZWZhdWx0O1xuXHR9XG5cblx0Jjpob3Zlcjpub3QoIFtkaXNhYmxlZF0gKTpub3QoIFthcmlhLWRpc2FibGVkPSd0cnVlJ10gKSB7XG5cdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5mb3JlZ3JvdW5kIH07XG5cdH1cblxuXHQkeyBpc0Rlc2VsZWN0YWJsZSAmJiBkZXNlbGVjdGFibGUgfVxuXHQkeyBpc0ljb24gJiYgaXNJY29uU3R5bGVzIH1cblx0JHsgaXNQcmVzc2VkICYmIHByZXNzZWQgfVxuYDtcblxuY29uc3QgcHJlc3NlZCA9IGNzc2Bcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5mb3JlZ3JvdW5kIH07XG5cdGZvbnQtd2VpZ2h0OiAkeyBDT05GSUcuZm9udFdlaWdodEVtcGhhc2lzIH07XG5gO1xuXG5jb25zdCBkZXNlbGVjdGFibGUgPSBjc3NgXG5cdCY6Zm9jdXMge1xuXHRcdG91dGxpbmU6ICR7IENPTkZJRy5ib3JkZXJXaWR0aEZvY3VzIH0gc29saWQgJHsgQ09MT1JTLnVpLmJvcmRlckZvY3VzIH07XG5cdFx0b3V0bGluZS1vZmZzZXQ6IDJweDtcblxuXHRcdC8vIEhpZGUgb3ZlcmxhcHBpbmcgYm9yZGVyXG5cdFx0JlthcmlhLXByZXNzZWQ9J2ZhbHNlJ10ge1xuXHRcdFx0YmFja2dyb3VuZDogJHsgQ09MT1JTLnVpLmJhY2tncm91bmQgfTtcblx0XHRcdGJveC1zaGFkb3c6IDAgMCAwIDJweCAkeyBDT0xPUlMudWkuYmFja2dyb3VuZCB9O1xuXHRcdH1cblx0fVxuYDtcblxuZXhwb3J0IGNvbnN0IEJ1dHRvbkNvbnRlbnRWaWV3ID0gc3R5bGVkLmRpdmBcblx0ZGlzcGxheTogZmxleDtcblx0Zm9udC1zaXplOiAkeyBDT05GSUcuZm9udFNpemUgfTtcblx0bGluZS1oZWlnaHQ6IDE7XG5gO1xuXG5jb25zdCBpc0ljb25TdHlsZXMgPSBjc3NgXG5cdGhlaWdodDogMzhweDtcblx0YXNwZWN0LXJhdGlvOiAxO1xuXHRwYWRkaW5nLWxlZnQ6IDA7XG5cdHBhZGRpbmctcmlnaHQ6IDA7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__9
  };
  var buttonView = ({
    isDeselectable,
    isIcon,
    isPressed
  }) => /* @__PURE__ */ css("align-items:center;appearance:none;background:transparent;border:none;border-radius:", config_values_default.radiusXSmall, ";color:", COLORS.theme.gray[700], ";fill:currentColor;cursor:pointer;display:flex;font-family:inherit;height:100%;justify-content:center;line-height:100%;outline:none;padding:0 12px;position:relative;text-align:center;@media not ( prefers-reduced-motion ){transition:color ", config_values_default.transitionDurationFast, " linear,font-weight 60ms linear;}user-select:none;width:100%;z-index:2;&::-moz-focus-inner{border:0;}&[disabled],&[aria-disabled='true']{opacity:0.4;cursor:default;}&:hover:not( [disabled] ):not( [aria-disabled='true'] ){color:", COLORS.theme.foreground, ";}", isDeselectable && deselectable, " ", isIcon && isIconStyles, " ", isPressed && pressed, ";" + (false ? "" : ";label:buttonView;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFpQ1ciLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBDT05GSUcsIENPTE9SUyB9IGZyb20gJy4uLy4uL3V0aWxzJztcbmltcG9ydCB0eXBlIHtcblx0VG9nZ2xlR3JvdXBDb250cm9sUHJvcHMsXG5cdFRvZ2dsZUdyb3VwQ29udHJvbE9wdGlvbkJhc2VQcm9wcyxcbn0gZnJvbSAnLi4vdHlwZXMnO1xuXG5leHBvcnQgY29uc3QgTGFiZWxWaWV3ID0gc3R5bGVkLmRpdmBcblx0ZGlzcGxheTogaW5saW5lLWZsZXg7XG5cdG1heC13aWR0aDogMTAwJTtcblx0bWluLXdpZHRoOiAwO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5gO1xuXG5leHBvcnQgY29uc3QgbGFiZWxCbG9jayA9IGNzc2Bcblx0ZmxleDogMTtcbmA7XG5cbmV4cG9ydCBjb25zdCBidXR0b25WaWV3ID0gKCB7XG5cdGlzRGVzZWxlY3RhYmxlLFxuXHRpc0ljb24sXG5cdGlzUHJlc3NlZCxcbn06IFBpY2s8IFRvZ2dsZUdyb3VwQ29udHJvbFByb3BzLCAnaXNEZXNlbGVjdGFibGUnID4gJlxuXHRQaWNrPCBUb2dnbGVHcm91cENvbnRyb2xPcHRpb25CYXNlUHJvcHMsICdpc0ljb24nID4gJiB7XG5cdFx0aXNQcmVzc2VkPzogYm9vbGVhbjtcblx0fSApID0+IGNzc2Bcblx0YWxpZ24taXRlbXM6IGNlbnRlcjtcblx0YXBwZWFyYW5jZTogbm9uZTtcblx0YmFja2dyb3VuZDogdHJhbnNwYXJlbnQ7XG5cdGJvcmRlcjogbm9uZTtcblx0Ym9yZGVyLXJhZGl1czogJHsgQ09ORklHLnJhZGl1c1hTbWFsbCB9O1xuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmdyYXlbIDcwMCBdIH07XG5cdGZpbGw6IGN1cnJlbnRDb2xvcjtcblx0Y3Vyc29yOiBwb2ludGVyO1xuXHRkaXNwbGF5OiBmbGV4O1xuXHRmb250LWZhbWlseTogaW5oZXJpdDtcblx0aGVpZ2h0OiAxMDAlO1xuXHRqdXN0aWZ5LWNvbnRlbnQ6IGNlbnRlcjtcblx0bGluZS1oZWlnaHQ6IDEwMCU7XG5cdG91dGxpbmU6IG5vbmU7XG5cdHBhZGRpbmc6IDAgMTJweDtcblx0cG9zaXRpb246IHJlbGF0aXZlO1xuXHR0ZXh0LWFsaWduOiBjZW50ZXI7XG5cdEBtZWRpYSBub3QgKCBwcmVmZXJzLXJlZHVjZWQtbW90aW9uICkge1xuXHRcdHRyYW5zaXRpb246XG5cdFx0XHRjb2xvciAkeyBDT05GSUcudHJhbnNpdGlvbkR1cmF0aW9uRmFzdCB9IGxpbmVhcixcblx0XHRcdGZvbnQtd2VpZ2h0IDYwbXMgbGluZWFyO1xuXHR9XG5cdHVzZXItc2VsZWN0OiBub25lO1xuXHR3aWR0aDogMTAwJTtcblx0ei1pbmRleDogMjtcblxuXHQmOjotbW96LWZvY3VzLWlubmVyIHtcblx0XHRib3JkZXI6IDA7XG5cdH1cblxuXHQmW2Rpc2FibGVkXSxcblx0JlthcmlhLWRpc2FibGVkPSd0cnVlJ10ge1xuXHRcdG9wYWNpdHk6IDAuNDtcblx0XHRjdXJzb3I6IGRlZmF1bHQ7XG5cdH1cblxuXHQmOmhvdmVyOm5vdCggW2Rpc2FibGVkXSApOm5vdCggW2FyaWEtZGlzYWJsZWQ9J3RydWUnXSApIHtcblx0XHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0fVxuXG5cdCR7IGlzRGVzZWxlY3RhYmxlICYmIGRlc2VsZWN0YWJsZSB9XG5cdCR7IGlzSWNvbiAmJiBpc0ljb25TdHlsZXMgfVxuXHQkeyBpc1ByZXNzZWQgJiYgcHJlc3NlZCB9XG5gO1xuXG5jb25zdCBwcmVzc2VkID0gY3NzYFxuXHRjb2xvcjogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0Zm9udC13ZWlnaHQ6ICR7IENPTkZJRy5mb250V2VpZ2h0RW1waGFzaXMgfTtcbmA7XG5cbmNvbnN0IGRlc2VsZWN0YWJsZSA9IGNzc2Bcblx0Jjpmb2N1cyB7XG5cdFx0b3V0bGluZTogJHsgQ09ORklHLmJvcmRlcldpZHRoRm9jdXMgfSBzb2xpZCAkeyBDT0xPUlMudWkuYm9yZGVyRm9jdXMgfTtcblx0XHRvdXRsaW5lLW9mZnNldDogMnB4O1xuXG5cdFx0Ly8gSGlkZSBvdmVybGFwcGluZyBib3JkZXJcblx0XHQmW2FyaWEtcHJlc3NlZD0nZmFsc2UnXSB7XG5cdFx0XHRiYWNrZ3JvdW5kOiAkeyBDT0xPUlMudWkuYmFja2dyb3VuZCB9O1xuXHRcdFx0Ym94LXNoYWRvdzogMCAwIDAgMnB4ICR7IENPTE9SUy51aS5iYWNrZ3JvdW5kIH07XG5cdFx0fVxuXHR9XG5gO1xuXG5leHBvcnQgY29uc3QgQnV0dG9uQ29udGVudFZpZXcgPSBzdHlsZWQuZGl2YFxuXHRkaXNwbGF5OiBmbGV4O1xuXHRmb250LXNpemU6ICR7IENPTkZJRy5mb250U2l6ZSB9O1xuXHRsaW5lLWhlaWdodDogMTtcbmA7XG5cbmNvbnN0IGlzSWNvblN0eWxlcyA9IGNzc2Bcblx0aGVpZ2h0OiAzOHB4O1xuXHRhc3BlY3QtcmF0aW86IDE7XG5cdHBhZGRpbmctbGVmdDogMDtcblx0cGFkZGluZy1yaWdodDogMDtcbmA7XG4iXX0= */");
  var pressed = /* @__PURE__ */ css("color:", COLORS.theme.foreground, ";font-weight:", config_values_default.fontWeightEmphasis, ";" + (false ? "" : ";label:pressed;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var deselectable = /* @__PURE__ */ css("&:focus{outline:", config_values_default.borderWidthFocus, " solid ", COLORS.ui.borderFocus, ";outline-offset:2px;&[aria-pressed='false']{background:", COLORS.ui.background, ";box-shadow:0 0 0 2px ", COLORS.ui.background, ";}}" + (false ? "" : ";label:deselectable;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var ButtonContentView = /* @__PURE__ */ createStyled("div", false ? {
    target: "et6ln9s0"
  } : {
    target: "et6ln9s0",
    label: "ButtonContentView"
  })("display:flex;font-size:", config_values_default.fontSize, ";line-height:1;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var isIconStyles = false ? {
    name: "1yqg1by",
    styles: "height:38px;aspect-ratio:1;padding-left:0;padding-right:0"
  } : {
    name: "s0i912-isIconStyles",
    styles: "height:38px;aspect-ratio:1;padding-left:0;padding-right:0;label:isIconStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__9
  };

  // packages/components/build-module/toggle-group-control/toggle-group-control-option-base/component.mjs
  var import_jsx_runtime117 = __toESM(require_jsx_runtime(), 1);
  var {
    ButtonContentView: ButtonContentView2,
    LabelView: LabelView2
  } = styles_exports4;
  var WithToolTip = ({
    showTooltip,
    text,
    children
  }) => {
    if (showTooltip && text) {
      return /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(tooltip_default, {
        text,
        placement: "top",
        children
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(import_jsx_runtime117.Fragment, {
      children
    });
  };
  function ToggleGroupControlOptionBase(props, forwardedRef) {
    const toggleGroupControlContext = useToggleGroupControlContext();
    const id3 = (0, import_compose26.useInstanceId)(ToggleGroupControlOptionBase, toggleGroupControlContext.baseId || "toggle-group-control-option-base");
    const buttonProps = useContextSystem({
      ...props,
      id: id3
    }, "ToggleGroupControlOptionBase");
    const {
      isBlock = false,
      isDeselectable = false
    } = toggleGroupControlContext;
    const {
      className: className2,
      isIcon = false,
      value,
      children,
      showTooltip = false,
      disabled,
      ...otherButtonProps
    } = buttonProps;
    const isPressed = toggleGroupControlContext.value === value;
    const cx2 = useCx();
    const labelViewClasses = (0, import_element63.useMemo)(() => cx2(isBlock && labelBlock), [cx2, isBlock]);
    const itemClasses = (0, import_element63.useMemo)(() => cx2(buttonView({
      isDeselectable,
      isIcon,
      isPressed
    }), className2), [cx2, isDeselectable, isIcon, isPressed, className2]);
    const buttonOnClick = () => {
      if (isDeselectable && isPressed) {
        toggleGroupControlContext.setValue(void 0);
      } else {
        toggleGroupControlContext.setValue(value);
      }
    };
    const commonProps = {
      ...otherButtonProps,
      className: itemClasses,
      "data-value": value,
      ref: forwardedRef
    };
    const labelRef = (0, import_element63.useRef)(null);
    (0, import_element63.useLayoutEffect)(() => {
      if (isPressed && labelRef.current) {
        toggleGroupControlContext.setSelectedElement(labelRef.current);
      }
    }, [isPressed, toggleGroupControlContext]);
    return /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(LabelView2, {
      ref: labelRef,
      className: labelViewClasses,
      children: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(WithToolTip, {
        showTooltip,
        text: otherButtonProps["aria-label"],
        children: isDeselectable ? /* @__PURE__ */ (0, import_jsx_runtime117.jsx)("button", {
          ...commonProps,
          disabled,
          "aria-pressed": isPressed,
          type: "button",
          onClick: buttonOnClick,
          children: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(ButtonContentView2, {
            children
          })
        }) : /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(Radio, {
          disabled,
          onFocusVisible: () => {
            const selectedValueIsEmpty = toggleGroupControlContext.value === null || toggleGroupControlContext.value === "";
            if (!selectedValueIsEmpty || toggleGroupControlContext.activeItemIsNotFirstItem?.()) {
              toggleGroupControlContext.setValue(value);
            }
          },
          render: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)("button", {
            type: "button",
            ...commonProps
          }),
          value,
          children: /* @__PURE__ */ (0, import_jsx_runtime117.jsx)(ButtonContentView2, {
            children
          })
        })
      })
    });
  }
  var ConnectedToggleGroupControlOptionBase = contextConnect(ToggleGroupControlOptionBase, "ToggleGroupControlOptionBase");
  var component_default13 = ConnectedToggleGroupControlOptionBase;

  // packages/components/build-module/toggle-group-control/toggle-group-control-option/component.mjs
  var import_jsx_runtime118 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToggleGroupControlOption(props, ref) {
    const {
      label,
      ...restProps
    } = props;
    const optionLabel = restProps["aria-label"] || label;
    return /* @__PURE__ */ (0, import_jsx_runtime118.jsx)(component_default13, {
      ...restProps,
      "aria-label": optionLabel,
      ref,
      children: label
    });
  }
  var ToggleGroupControlOption = (0, import_element64.forwardRef)(UnforwardedToggleGroupControlOption);
  ToggleGroupControlOption.displayName = "ToggleGroupControlOption";
  var component_default14 = ToggleGroupControlOption;

  // packages/components/build-module/toggle-group-control/toggle-group-control-option-icon/component.mjs
  var import_element65 = __toESM(require_element(), 1);
  var import_jsx_runtime119 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToggleGroupControlOptionIcon(props, ref) {
    const {
      icon,
      label,
      ...restProps
    } = props;
    return /* @__PURE__ */ (0, import_jsx_runtime119.jsx)(component_default13, {
      ...restProps,
      isIcon: true,
      "aria-label": label,
      showTooltip: true,
      ref,
      children: /* @__PURE__ */ (0, import_jsx_runtime119.jsx)(icon_default3, {
        icon
      })
    });
  }
  var ToggleGroupControlOptionIcon = (0, import_element65.forwardRef)(UnforwardedToggleGroupControlOptionIcon);
  ToggleGroupControlOptionIcon.displayName = "ToggleGroupControlOptionIcon";
  var component_default15 = ToggleGroupControlOptionIcon;

  // packages/components/build-module/border-control/border-control-style-picker/component.mjs
  var import_jsx_runtime120 = __toESM(require_jsx_runtime(), 1);
  var BORDER_STYLES = [{
    label: (0, import_i18n11.__)("Solid"),
    icon: line_solid_default,
    value: "solid"
  }, {
    label: (0, import_i18n11.__)("Dashed"),
    icon: line_dashed_default,
    value: "dashed"
  }, {
    label: (0, import_i18n11.__)("Dotted"),
    icon: line_dotted_default,
    value: "dotted"
  }];
  function UnconnectedBorderControlStylePicker({
    onChange,
    ...restProps
  }, forwardedRef) {
    return /* @__PURE__ */ (0, import_jsx_runtime120.jsx)(component_default12, {
      ref: forwardedRef,
      isDeselectable: true,
      onChange: (value) => {
        onChange?.(value);
      },
      ...restProps,
      children: BORDER_STYLES.map((borderStyle) => /* @__PURE__ */ (0, import_jsx_runtime120.jsx)(component_default15, {
        value: borderStyle.value,
        icon: borderStyle.icon,
        label: borderStyle.label
      }, borderStyle.value))
    });
  }
  var BorderControlStylePicker = contextConnect(UnconnectedBorderControlStylePicker, "BorderControlStylePicker");
  var component_default16 = BorderControlStylePicker;

  // packages/components/build-module/color-indicator/index.mjs
  var import_element66 = __toESM(require_element(), 1);
  var import_jsx_runtime121 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedColorIndicator(props, forwardedRef) {
    const {
      className: className2,
      colorValue,
      ...additionalProps
    } = props;
    return /* @__PURE__ */ (0, import_jsx_runtime121.jsx)("span", {
      className: clsx_default("component-color-indicator", className2),
      style: {
        background: colorValue
      },
      ref: forwardedRef,
      ...additionalProps
    });
  }
  var ColorIndicator = (0, import_element66.forwardRef)(UnforwardedColorIndicator);
  ColorIndicator.displayName = "ColorIndicator";
  var color_indicator_default = ColorIndicator;

  // node_modules/colord/plugins/a11y.mjs
  var o2 = function(o4) {
    var t4 = o4 / 255;
    return t4 < 0.04045 ? t4 / 12.92 : Math.pow((t4 + 0.055) / 1.055, 2.4);
  };
  var t2 = function(t4) {
    return 0.2126 * o2(t4.r) + 0.7152 * o2(t4.g) + 0.0722 * o2(t4.b);
  };
  function a11y_default(o4) {
    o4.prototype.luminance = function() {
      return o5 = t2(this.rgba), void 0 === (r4 = 2) && (r4 = 0), void 0 === n3 && (n3 = Math.pow(10, r4)), Math.round(n3 * o5) / n3 + 0;
      var o5, r4, n3;
    }, o4.prototype.contrast = function(r4) {
      void 0 === r4 && (r4 = "#FFF");
      var n3, a3, i3, e3, v3, u3, d3, c3 = r4 instanceof o4 ? r4 : new o4(r4);
      return e3 = this.rgba, v3 = c3.toRgb(), u3 = t2(e3), d3 = t2(v3), n3 = u3 > d3 ? (u3 + 0.05) / (d3 + 0.05) : (d3 + 0.05) / (u3 + 0.05), void 0 === (a3 = 2) && (a3 = 0), void 0 === i3 && (i3 = Math.pow(10, a3)), Math.floor(i3 * n3) / i3 + 0;
    }, o4.prototype.isReadable = function(o5, t4) {
      return void 0 === o5 && (o5 = "#FFF"), void 0 === t4 && (t4 = {}), this.contrast(o5) >= (e3 = void 0 === (i3 = (r4 = t4).size) ? "normal" : i3, "AAA" === (a3 = void 0 === (n3 = r4.level) ? "AA" : n3) && "normal" === e3 ? 7 : "AA" === a3 && "large" === e3 ? 3 : 4.5);
      var r4, n3, a3, i3, e3;
    };
  }

  // packages/components/build-module/color-palette/index.mjs
  var import_compose34 = __toESM(require_compose(), 1);
  var import_i18n20 = __toESM(require_i18n(), 1);
  var import_element80 = __toESM(require_element(), 1);

  // packages/components/build-module/dropdown/index.mjs
  var import_element67 = __toESM(require_element(), 1);
  var import_compose27 = __toESM(require_compose(), 1);
  var import_deprecated6 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime122 = __toESM(require_jsx_runtime(), 1);
  var UnconnectedDropdown = (props, forwardedRef) => {
    const {
      renderContent,
      renderToggle,
      className: className2,
      contentClassName,
      expandOnMobile,
      headerTitle,
      focusOnMount,
      popoverProps,
      onClose,
      onToggle,
      style: style2,
      open,
      defaultOpen,
      // Deprecated props
      position: position2,
      // From context system
      variant
    } = useContextSystem(props, "Dropdown");
    if (position2 !== void 0) {
      (0, import_deprecated6.default)("`position` prop in wp.components.Dropdown", {
        since: "6.2",
        alternative: "`popoverProps.placement` prop",
        hint: "Note that the `position` prop will override any values passed through the `popoverProps.placement` prop."
      });
    }
    const [fallbackPopoverAnchor, setFallbackPopoverAnchor] = (0, import_element67.useState)(null);
    const containerRef = (0, import_element67.useRef)(null);
    const [isOpen, setIsOpen] = useControlledValue({
      defaultValue: defaultOpen,
      value: open,
      onChange: onToggle
    });
    function closeIfFocusOutside() {
      if (!containerRef.current) {
        return;
      }
      const {
        ownerDocument
      } = containerRef.current;
      const dialog = ownerDocument?.activeElement?.closest('[role="dialog"]');
      if (!containerRef.current.contains(ownerDocument.activeElement) && (!dialog || dialog.contains(containerRef.current))) {
        close();
      }
    }
    function close() {
      onClose?.();
      setIsOpen(false);
    }
    const args = {
      isOpen: !!isOpen,
      onToggle: () => setIsOpen(!isOpen),
      onClose: close
    };
    const popoverPropsHaveAnchor = !!popoverProps?.anchor || // Note: `anchorRef`, `getAnchorRect` and `anchorRect` are deprecated and
    // be removed from `Popover` from WordPress 6.3
    !!popoverProps?.anchorRef || !!popoverProps?.getAnchorRect || !!popoverProps?.anchorRect;
    return /* @__PURE__ */ (0, import_jsx_runtime122.jsxs)("div", {
      className: className2,
      ref: (0, import_compose27.useMergeRefs)([containerRef, forwardedRef, setFallbackPopoverAnchor]),
      tabIndex: -1,
      style: style2,
      children: [renderToggle(args), isOpen && /* @__PURE__ */ (0, import_jsx_runtime122.jsx)(popover_default, {
        position: position2,
        onClose: close,
        onFocusOutside: closeIfFocusOutside,
        expandOnMobile,
        headerTitle,
        focusOnMount,
        offset: 13,
        anchor: !popoverPropsHaveAnchor ? fallbackPopoverAnchor : void 0,
        variant,
        ...popoverProps,
        className: clsx_default("components-dropdown__content", popoverProps?.className, contentClassName),
        children: renderContent(args)
      })]
    });
  };
  var Dropdown = contextConnect(UnconnectedDropdown, "Dropdown");
  var dropdown_default = Dropdown;

  // packages/components/build-module/color-picker/component.mjs
  var import_element75 = __toESM(require_element(), 1);
  var import_compose31 = __toESM(require_compose(), 1);
  var import_i18n16 = __toESM(require_i18n(), 1);

  // packages/components/build-module/select-control/index.mjs
  var import_compose28 = __toESM(require_compose(), 1);
  var import_element68 = __toESM(require_element(), 1);

  // packages/components/build-module/select-control/styles/select-control-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__10() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var disabledStyles2 = ({
    disabled
  }) => {
    if (!disabled) {
      return "";
    }
    return /* @__PURE__ */ css("color:", COLORS.ui.textDisabled, ";cursor:default;" + (false ? "" : ";label:disabledStyles;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var _ref22 = false ? {
    name: "1lv1yo7",
    styles: "display:inline-flex"
  } : {
    name: "siqiia-inputBaseVariantStyles",
    styles: "display:inline-flex;label:inputBaseVariantStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__10
  };
  var inputBaseVariantStyles = ({
    variant
  }) => {
    if (variant === "minimal") {
      return _ref22;
    }
    return "";
  };
  var StyledInputBase = /* @__PURE__ */ createStyled(input_base_default, false ? {
    target: "e1mv6sxx3"
  } : {
    target: "e1mv6sxx3",
    label: "StyledInputBase"
  })("color:", COLORS.theme.foreground, ";cursor:pointer;", disabledStyles2, " ", inputBaseVariantStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var sizeStyles2 = ({
    multiple,
    selectSize = "default"
  }) => {
    if (multiple) {
      return;
    }
    const sizes = {
      default: {
        height: 40,
        minHeight: 40,
        paddingTop: 0,
        paddingBottom: 0
      },
      small: {
        height: 24,
        minHeight: 24,
        paddingTop: 0,
        paddingBottom: 0
      },
      compact: {
        height: 32,
        minHeight: 32,
        paddingTop: 0,
        paddingBottom: 0
      },
      "__unstable-large": {
        height: 40,
        minHeight: 40,
        paddingTop: 0,
        paddingBottom: 0
      }
    };
    const style2 = sizes[selectSize] || sizes.default;
    return /* @__PURE__ */ css(style2, false ? "" : ";label:sizeStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var chevronIconSize = 18;
  var sizePaddings = ({
    multiple,
    selectSize = "default"
  }) => {
    const padding2 = {
      default: config_values_default.controlPaddingX,
      small: config_values_default.controlPaddingXSmall,
      compact: config_values_default.controlPaddingXSmall,
      "__unstable-large": config_values_default.controlPaddingX
    };
    const selectedPadding = padding2[selectSize] || padding2.default;
    return rtl({
      paddingLeft: selectedPadding,
      paddingRight: selectedPadding + chevronIconSize,
      ...multiple ? {
        paddingTop: selectedPadding,
        paddingBottom: selectedPadding
      } : {}
    });
  };
  var overflowStyles = ({
    multiple
  }) => {
    return {
      overflow: multiple ? "auto" : "hidden"
    };
  };
  var _ref4 = false ? {
    name: "n1jncc",
    styles: "field-sizing:content"
  } : {
    name: "1n00qi9-variantStyles",
    styles: "field-sizing:content;label:variantStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__10
  };
  var variantStyles = ({
    variant
  }) => {
    if (variant === "minimal") {
      return _ref4;
    }
    return "";
  };
  var Select3 = /* @__PURE__ */ createStyled("select", false ? {
    target: "e1mv6sxx2"
  } : {
    target: "e1mv6sxx2",
    label: "Select"
  })("&&&{appearance:none;background:transparent;box-sizing:border-box;border:none;box-shadow:none!important;color:currentColor;cursor:inherit;display:block;font-family:inherit;line-height:1.3;margin:0;width:100%;max-width:none;white-space:nowrap;text-overflow:ellipsis;", fontSizeStyles, ";", sizeStyles2, ";", sizePaddings, ";", overflowStyles, " ", variantStyles, ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var DownArrowWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1mv6sxx1"
  } : {
    target: "e1mv6sxx1",
    label: "DownArrowWrapper"
  })("margin-inline-end:", space(-1), ";line-height:0;path{fill:currentColor;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var InputControlSuffixWrapperWithClickThrough = /* @__PURE__ */ createStyled(input_suffix_wrapper_default, false ? {
    target: "e1mv6sxx0"
  } : {
    target: "e1mv6sxx0",
    label: "InputControlSuffixWrapperWithClickThrough"
  })("position:absolute;pointer-events:none;", rtl({
    right: 0
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // packages/components/build-module/select-control/chevron-down.mjs
  var import_jsx_runtime123 = __toESM(require_jsx_runtime(), 1);
  var SelectControlChevronDown = () => {
    return /* @__PURE__ */ (0, import_jsx_runtime123.jsx)(InputControlSuffixWrapperWithClickThrough, {
      children: /* @__PURE__ */ (0, import_jsx_runtime123.jsx)(DownArrowWrapper, {
        children: /* @__PURE__ */ (0, import_jsx_runtime123.jsx)(icon_default2, {
          icon: chevron_down_default,
          size: chevronIconSize
        })
      })
    });
  };
  var chevron_down_default2 = SelectControlChevronDown;

  // packages/components/build-module/select-control/index.mjs
  var import_jsx_runtime124 = __toESM(require_jsx_runtime(), 1);
  function useUniqueId3(idProp) {
    const instanceId = (0, import_compose28.useInstanceId)(SelectControl);
    const id3 = `inspector-select-control-${instanceId}`;
    return idProp || id3;
  }
  function SelectOptions({
    options: options2
  }) {
    return options2.map(({
      id: id3,
      label,
      value,
      ...optionProps
    }, index2) => {
      const key = id3 || `${label}-${value}-${index2}`;
      return /* @__PURE__ */ (0, import_jsx_runtime124.jsx)("option", {
        value,
        ...optionProps,
        children: label
      }, key);
    });
  }
  function UnforwardedSelectControl(props, ref) {
    const {
      // Prevent passing legacy props to internal components.
      __nextHasNoMarginBottom: _2,
      __next40pxDefaultSize: _next40pxDefaultSize,
      __next36pxDefaultSize: _next36pxDefaultSize,
      __shouldNotWarnDeprecated36pxSize: _shouldNotWarnDeprecated36pxSize,
      className: className2,
      disabled = false,
      help,
      hideLabelFromVision,
      id: idProp,
      label,
      multiple = false,
      onChange,
      options: options2 = [],
      size: size4 = "default",
      value: valueProp,
      labelPosition = "top",
      children,
      prefix: prefix2,
      suffix,
      variant = "default",
      ...restProps
    } = props;
    const id3 = useUniqueId3(idProp);
    const helpId = help ? `${id3}__help` : void 0;
    if (!options2?.length && !children) {
      return null;
    }
    const handleOnChange = (event) => {
      if (props.multiple) {
        const selectedOptions = Array.from(event.target.options).filter(({
          selected
        }) => selected);
        const newValues = selectedOptions.map(({
          value
        }) => value);
        props.onChange?.(newValues, {
          event
        });
        return;
      }
      props.onChange?.(event.target.value, {
        event
      });
    };
    const classes = clsx_default("components-select-control", className2);
    return /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(base_control_default, {
      help,
      id: id3,
      className: classes,
      children: /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(StyledInputBase, {
        disabled,
        hideLabelFromVision,
        id: id3,
        isBorderless: variant === "minimal",
        label,
        size: size4,
        suffix: suffix || !multiple && /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(chevron_down_default2, {}),
        prefix: prefix2,
        labelPosition,
        __unstableInputWidth: variant === "minimal" ? "auto" : void 0,
        variant,
        children: /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(Select3, {
          ...restProps,
          "aria-describedby": helpId,
          className: "components-select-control__input",
          disabled,
          id: id3,
          multiple,
          onChange: handleOnChange,
          ref,
          selectSize: size4,
          value: valueProp,
          variant,
          children: children || /* @__PURE__ */ (0, import_jsx_runtime124.jsx)(SelectOptions, {
            options: options2
          })
        })
      })
    });
  }
  var SelectControl = (0, import_element68.forwardRef)(UnforwardedSelectControl);
  SelectControl.displayName = "SelectControl";
  var select_control_default = SelectControl;

  // packages/components/build-module/range-control/index.mjs
  var import_i18n13 = __toESM(require_i18n(), 1);
  var import_element72 = __toESM(require_element(), 1);
  var import_compose29 = __toESM(require_compose(), 1);

  // packages/components/build-module/range-control/utils.mjs
  var import_element69 = __toESM(require_element(), 1);
  function floatClamp(value, min3, max3) {
    if (typeof value !== "number") {
      return null;
    }
    return parseFloat(`${clamp4(value, min3, max3)}`);
  }
  function useControlledRangeValue(settings) {
    const {
      min: min3,
      max: max3,
      value: valueProp,
      initial
    } = settings;
    const [state, setInternalState] = use_controlled_state_default(floatClamp(valueProp, min3, max3), {
      initial: floatClamp(initial ?? null, min3, max3),
      fallback: null
    });
    const setState = (0, import_element69.useCallback)((nextValue) => {
      if (nextValue === null) {
        setInternalState(null);
      } else {
        setInternalState(floatClamp(nextValue, min3, max3));
      }
    }, [min3, max3, setInternalState]);
    return [state, setState];
  }

  // packages/components/build-module/range-control/input-range.mjs
  var import_element70 = __toESM(require_element(), 1);

  // packages/components/build-module/range-control/styles/range-control-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__11() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var rangeHeightValue = 30;
  var railHeight = 4;
  var rangeHeight = () => /* @__PURE__ */ css({
    height: rangeHeightValue,
    minHeight: rangeHeightValue
  }, false ? "" : ";label:rangeHeight;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var thumbSize = 12;
  var Root2 = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1epgpqk14"
  } : {
    target: "e1epgpqk14",
    label: "Root"
  })(false ? {
    name: "1ryrvza",
    styles: "-webkit-tap-highlight-color:transparent;align-items:center;display:flex;justify-content:flex-start;padding:0;position:relative;touch-action:none;width:100%;min-height:40px"
  } : {
    name: "1ryrvza",
    styles: "-webkit-tap-highlight-color:transparent;align-items:center;display:flex;justify-content:flex-start;padding:0;position:relative;touch-action:none;width:100%;min-height:40px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__11
  });
  var wrapperColor = ({
    color: color2 = COLORS.ui.borderFocus
  }) => /* @__PURE__ */ css({
    color: color2
  }, false ? "" : ";label:wrapperColor;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var Wrapper2 = /* @__PURE__ */ createStyled("div", false ? {
    shouldForwardProp: (prop) => !["color", "marks"].includes(prop),
    target: "e1epgpqk13"
  } : {
    shouldForwardProp: (prop) => !["color", "marks"].includes(prop),
    target: "e1epgpqk13",
    label: "Wrapper"
  })("display:block;flex:1;position:relative;width:100%;", wrapperColor, ";", rangeHeight, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var BeforeIconWrapper = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk12"
  } : {
    target: "e1epgpqk12",
    label: "BeforeIconWrapper"
  })("display:flex;margin-top:", railHeight, "px;", rtl({
    marginRight: 6
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var AfterIconWrapper = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk11"
  } : {
    target: "e1epgpqk11",
    label: "AfterIconWrapper"
  })("display:flex;margin-top:", railHeight, "px;", rtl({
    marginLeft: 6
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var railBackgroundColor = ({
    disabled,
    railColor
  }) => {
    return /* @__PURE__ */ css("background:", disabled ? COLORS.ui.backgroundDisabled : railColor || COLORS.theme.gray[300], ";@media ( forced-colors: active ){background:GrayText;}" + (false ? "" : ";label:railBackgroundColor;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var Rail = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk10"
  } : {
    target: "e1epgpqk10",
    label: "Rail"
  })("left:0;pointer-events:none;right:0;display:block;height:", railHeight, "px;position:absolute;margin-top:", (rangeHeightValue - railHeight) / 2, "px;top:0;border-radius:", config_values_default.radiusFull, ";", railBackgroundColor, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var trackBackgroundColor = ({
    disabled,
    trackColor
  }) => {
    return /* @__PURE__ */ css("background:", disabled ? COLORS.theme.gray[400] : trackColor || "currentColor", ";@media ( forced-colors: active ){background:", disabled ? "GrayText" : "CanvasText", ";}" + (false ? "" : ";label:trackBackgroundColor;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var Track = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk9"
  } : {
    target: "e1epgpqk9",
    label: "Track"
  })("border-radius:", config_values_default.radiusFull, ";height:", railHeight, "px;pointer-events:none;display:block;position:absolute;margin-top:", (rangeHeightValue - railHeight) / 2, "px;top:0;.is-marked &{@media not ( prefers-reduced-motion ){transition:width ease 0.1s;}}", trackBackgroundColor, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var MarksWrapper = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk8"
  } : {
    target: "e1epgpqk8",
    label: "MarksWrapper"
  })(false ? {
    name: "g5kg28",
    styles: "display:block;pointer-events:none;position:relative;width:100%;user-select:none;margin-top:17px"
  } : {
    name: "g5kg28",
    styles: "display:block;pointer-events:none;position:relative;width:100%;user-select:none;margin-top:17px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__11
  });
  var Mark = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk7"
  } : {
    target: "e1epgpqk7",
    label: "Mark"
  })("position:absolute;left:0;top:-4px;height:4px;width:2px;transform:translateX( -50% );background-color:", COLORS.ui.background, ";z-index:1;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var markLabelFill = ({
    isFilled
  }) => {
    return /* @__PURE__ */ css({
      color: isFilled ? COLORS.theme.gray[700] : COLORS.theme.gray[300]
    }, false ? "" : ";label:markLabelFill;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var MarkLabel = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk6"
  } : {
    target: "e1epgpqk6",
    label: "MarkLabel"
  })("color:", COLORS.theme.gray[300], ";font-size:11px;position:absolute;top:8px;white-space:nowrap;", rtl({
    left: 0
  }), ";", rtl({
    transform: "translateX( -50% )"
  }, {
    transform: "translateX( 50% )"
  }), ";", markLabelFill, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var thumbColor = ({
    disabled
  }) => {
    return /* @__PURE__ */ css("background:", disabled ? COLORS.theme.gray[400] : COLORS.theme.accent, ";@media ( forced-colors: active ){background:", disabled ? "GrayText" : "CanvasText", ";}" + (false ? "" : ";label:thumbColor;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var ThumbWrapper = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk5"
  } : {
    target: "e1epgpqk5",
    label: "ThumbWrapper"
  })("align-items:center;display:flex;height:", thumbSize, "px;justify-content:center;margin-top:", (rangeHeightValue - thumbSize) / 2, "px;outline:0;pointer-events:none;position:absolute;top:0;user-select:none;width:", thumbSize, "px;border-radius:", config_values_default.radiusRound, ";z-index:3;.is-marked &{@media not ( prefers-reduced-motion ){transition:left ease 0.1s;}}", thumbColor, ";", rtl({
    marginLeft: -10
  }), ";", rtl({
    transform: "translateX( 4.5px )"
  }, {
    transform: "translateX( -4.5px )"
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var thumbFocus = ({
    isFocused
  }) => {
    return isFocused ? /* @__PURE__ */ css("&::before{content:' ';position:absolute;background-color:", COLORS.theme.accent, ";opacity:0.4;border-radius:", config_values_default.radiusRound, ";height:", thumbSize + 8, "px;width:", thumbSize + 8, "px;top:-4px;left:-4px;@media ( forced-colors: active ){background:GrayText;}}" + (false ? "" : ";label:thumbFocus;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */") : "";
  };
  var Thumb = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk4"
  } : {
    target: "e1epgpqk4",
    label: "Thumb"
  })("align-items:center;border-radius:", config_values_default.radiusRound, ";height:100%;outline:0;position:absolute;user-select:none;width:100%;box-shadow:", config_values_default.elevationXSmall, ";", thumbColor, ";", thumbFocus, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var InputRange = /* @__PURE__ */ createStyled("input", false ? {
    target: "e1epgpqk3"
  } : {
    target: "e1epgpqk3",
    label: "InputRange"
  })("box-sizing:border-box;cursor:pointer;display:block;height:100%;left:0;margin:0 -", thumbSize / 2, "px;opacity:0;outline:none;position:absolute;right:0;top:0;width:calc( 100% + ", thumbSize, "px );" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var tooltipShow = ({
    show
  }) => {
    return /* @__PURE__ */ css("display:", show ? "inline-block" : "none", ";opacity:", show ? 1 : 0, ";@media not ( prefers-reduced-motion ){transition:opacity 120ms ease,display 120ms ease allow-discrete;}@starting-style{opacity:0;}" + (false ? "" : ";label:tooltipShow;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var _ref5 = false ? {
    name: "1cypxip",
    styles: "top:-80%"
  } : {
    name: "1g4vnux-tooltipPlacement",
    styles: "top:-80%;label:tooltipPlacement;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__11
  };
  var _ref23 = false ? {
    name: "1lr98c4",
    styles: "bottom:-80%"
  } : {
    name: "1g13zjq-tooltipPlacement",
    styles: "bottom:-80%;label:tooltipPlacement;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__11
  };
  var tooltipPlacement = ({
    placement
  }) => {
    const isBottom = placement === "bottom";
    if (isBottom) {
      return _ref23;
    }
    return _ref5;
  };
  var Tooltip3 = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk2"
  } : {
    target: "e1epgpqk2",
    label: "Tooltip"
  })("background:rgba( 0, 0, 0, 0.8 );border-radius:", config_values_default.radiusSmall, ";color:white;font-size:12px;min-width:32px;padding:4px 8px;pointer-events:none;position:absolute;text-align:center;user-select:none;line-height:1.4;", tooltipShow, ";", tooltipPlacement, ";", rtl({
    transform: "translateX(-50%)"
  }, {
    transform: "translateX(50%)"
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var InputNumber = /* @__PURE__ */ createStyled(number_control_default, false ? {
    target: "e1epgpqk1"
  } : {
    target: "e1epgpqk1",
    label: "InputNumber"
  })("display:inline-block;font-size:13px;margin-top:0;input[type='number']&{", rangeHeight, ";}", rtl({
    marginLeft: `${space(4)} !important`
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ActionRightWrapper = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1epgpqk0"
  } : {
    target: "e1epgpqk0",
    label: "ActionRightWrapper"
  })("display:block;margin-top:0;button,button.is-small{margin-left:0;", rangeHeight, ";}", rtl({
    marginLeft: 8
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // packages/components/build-module/range-control/input-range.mjs
  var import_jsx_runtime125 = __toESM(require_jsx_runtime(), 1);
  function InputRange2(props, ref) {
    const {
      describedBy,
      label,
      value,
      ...otherProps
    } = props;
    return /* @__PURE__ */ (0, import_jsx_runtime125.jsx)(InputRange, {
      ...otherProps,
      "aria-describedby": describedBy,
      "aria-label": label,
      "aria-hidden": false,
      ref,
      tabIndex: 0,
      type: "range",
      value
    });
  }
  var ForwardedComponent2 = (0, import_element70.forwardRef)(InputRange2);
  var input_range_default = ForwardedComponent2;

  // packages/components/build-module/range-control/rail.mjs
  var import_i18n12 = __toESM(require_i18n(), 1);

  // packages/components/build-module/range-control/mark.mjs
  var import_jsx_runtime126 = __toESM(require_jsx_runtime(), 1);
  function RangeMark(props) {
    const {
      className: className2,
      isFilled = false,
      label,
      style: style2 = {},
      ...otherProps
    } = props;
    const classes = clsx_default("components-range-control__mark", isFilled && "is-filled", className2);
    const labelClasses = clsx_default("components-range-control__mark-label", isFilled && "is-filled");
    return /* @__PURE__ */ (0, import_jsx_runtime126.jsxs)(import_jsx_runtime126.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime126.jsx)(Mark, {
        ...otherProps,
        "aria-hidden": "true",
        className: classes,
        style: style2
      }), label && /* @__PURE__ */ (0, import_jsx_runtime126.jsx)(MarkLabel, {
        "aria-hidden": "true",
        className: labelClasses,
        isFilled,
        style: style2,
        children: label
      })]
    });
  }

  // packages/components/build-module/range-control/rail.mjs
  var import_jsx_runtime127 = __toESM(require_jsx_runtime(), 1);
  var import_react97 = __toESM(require_react(), 1);
  function RangeRail(props) {
    const {
      disabled = false,
      marks = false,
      min: min3 = 0,
      max: max3 = 100,
      step = 1,
      value = 0,
      ...restProps
    } = props;
    return /* @__PURE__ */ (0, import_jsx_runtime127.jsxs)(import_jsx_runtime127.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime127.jsx)(Rail, {
        disabled,
        ...restProps
      }), marks && /* @__PURE__ */ (0, import_jsx_runtime127.jsx)(Marks, {
        disabled,
        marks,
        min: min3,
        max: max3,
        step,
        value
      })]
    });
  }
  function Marks(props) {
    const {
      disabled = false,
      marks = false,
      min: min3 = 0,
      max: max3 = 100,
      step: stepProp = 1,
      value = 0
    } = props;
    const step = stepProp === "any" ? 1 : stepProp;
    const marksData = useMarks({
      marks,
      min: min3,
      max: max3,
      step,
      value
    });
    return /* @__PURE__ */ (0, import_jsx_runtime127.jsx)(MarksWrapper, {
      "aria-hidden": "true",
      className: "components-range-control__marks",
      children: marksData.map((mark) => /* @__PURE__ */ (0, import_react97.createElement)(RangeMark, {
        ...mark,
        key: mark.key,
        "aria-hidden": "true",
        disabled
      }))
    });
  }
  function useMarks({
    marks,
    min: min3 = 0,
    max: max3 = 100,
    step = 1,
    value = 0
  }) {
    if (!marks) {
      return [];
    }
    const range = max3 - min3;
    if (!Array.isArray(marks)) {
      marks = [];
      const count = 1 + Math.round(range / step);
      while (count > marks.push({
        value: step * marks.length + min3
      })) {
      }
    }
    const placedMarks = [];
    marks.forEach((mark, index2) => {
      if (mark.value < min3 || mark.value > max3) {
        return;
      }
      const key = `mark-${index2}`;
      const isFilled = mark.value <= value;
      const offset4 = `${(mark.value - min3) / range * 100}%`;
      const offsetStyle = {
        [(0, import_i18n12.isRTL)() ? "right" : "left"]: offset4
      };
      placedMarks.push({
        ...mark,
        isFilled,
        key,
        style: offsetStyle
      });
    });
    return placedMarks;
  }

  // packages/components/build-module/range-control/tooltip.mjs
  var import_element71 = __toESM(require_element(), 1);
  var import_jsx_runtime128 = __toESM(require_jsx_runtime(), 1);
  function SimpleTooltip(props) {
    const {
      className: className2,
      inputRef,
      tooltipPlacement: tooltipPlacement2,
      show = false,
      style: style2 = {},
      value = 0,
      renderTooltipContent = (v3) => v3,
      zIndex = 100,
      ...restProps
    } = props;
    const placement = useTooltipPlacement({
      inputRef,
      tooltipPlacement: tooltipPlacement2
    });
    const classes = clsx_default("components-simple-tooltip", className2);
    const styles3 = {
      ...style2,
      zIndex
    };
    return /* @__PURE__ */ (0, import_jsx_runtime128.jsx)(Tooltip3, {
      ...restProps,
      "aria-hidden": "false",
      className: classes,
      placement,
      show,
      role: "tooltip",
      style: styles3,
      children: renderTooltipContent(value)
    });
  }
  function useTooltipPlacement({
    inputRef,
    tooltipPlacement: tooltipPlacement2
  }) {
    const [placement, setPlacement] = (0, import_element71.useState)();
    const setTooltipPlacement = (0, import_element71.useCallback)(() => {
      if (inputRef && inputRef.current) {
        setPlacement(tooltipPlacement2);
      }
    }, [tooltipPlacement2, inputRef]);
    (0, import_element71.useEffect)(() => {
      setTooltipPlacement();
    }, [setTooltipPlacement]);
    (0, import_element71.useEffect)(() => {
      window.addEventListener("resize", setTooltipPlacement);
      return () => {
        window.removeEventListener("resize", setTooltipPlacement);
      };
    });
    return placement;
  }

  // packages/components/build-module/range-control/index.mjs
  var import_jsx_runtime129 = __toESM(require_jsx_runtime(), 1);
  var noop9 = () => {
  };
  function computeResetValue({
    resetFallbackValue,
    initialPosition
  }) {
    if (resetFallbackValue !== void 0) {
      return !Number.isNaN(resetFallbackValue) ? resetFallbackValue : null;
    }
    if (initialPosition !== void 0) {
      return !Number.isNaN(initialPosition) ? initialPosition : null;
    }
    return null;
  }
  function UnforwardedRangeControl(props, forwardedRef) {
    const {
      // Prevent passing legacy props to internal component.
      __nextHasNoMarginBottom: _2,
      __next40pxDefaultSize: _next40pxDefaultSize,
      __shouldNotWarnDeprecated36pxSize: _shouldNotWarnDeprecated36pxSize,
      afterIcon,
      allowReset = false,
      beforeIcon,
      className: className2,
      color: colorProp = COLORS.theme.accent,
      currentInput,
      disabled = false,
      help,
      hideLabelFromVision = false,
      initialPosition,
      isShiftStepEnabled = true,
      label,
      marks = false,
      max: max3 = 100,
      min: min3 = 0,
      onBlur = noop9,
      onChange = noop9,
      onFocus = noop9,
      onMouseLeave = noop9,
      onMouseMove = noop9,
      railColor,
      renderTooltipContent = (v3) => v3,
      resetFallbackValue,
      shiftStep = 10,
      showTooltip: showTooltipProp,
      step = 1,
      trackColor,
      value: valueProp,
      withInputField = true,
      ...otherProps
    } = props;
    const [value, setValue] = useControlledRangeValue({
      min: min3,
      max: max3,
      value: valueProp ?? null,
      initial: initialPosition
    });
    const isResetPendent = (0, import_element72.useRef)(false);
    let hasTooltip = showTooltipProp;
    let hasInputField = withInputField;
    if (step === "any") {
      hasTooltip = false;
      hasInputField = false;
    }
    const [showTooltip, setShowTooltip] = (0, import_element72.useState)(hasTooltip);
    const [isFocused, setIsFocused] = (0, import_element72.useState)(false);
    const inputRef = (0, import_element72.useRef)(null);
    const isCurrentlyFocused = inputRef.current?.matches(":focus");
    const isThumbFocused = !disabled && isFocused;
    const isValueReset = value === null;
    const currentValue = value !== void 0 ? value : currentInput;
    const inputSliderValue = isValueReset ? "" : currentValue;
    const rangeFillValue = isValueReset ? (max3 - min3) / 2 + min3 : value;
    const fillValue = isValueReset ? 50 : (value - min3) / (max3 - min3) * 100;
    const fillValueOffset = `${clamp4(fillValue, 0, 100)}%`;
    const classes = clsx_default("components-range-control", className2);
    const wrapperClasses = clsx_default("components-range-control__wrapper", !!marks && "is-marked");
    const id3 = (0, import_compose29.useInstanceId)(UnforwardedRangeControl, "inspector-range-control");
    const describedBy = !!help ? `${id3}__help` : void 0;
    const enableTooltip = hasTooltip !== false && Number.isFinite(value);
    const handleOnRangeChange = (event) => {
      const nextValue = parseFloat(event.target.value);
      setValue(nextValue);
      onChange(nextValue);
    };
    const handleOnChange = (next2) => {
      let nextValue = parseFloat(next2);
      setValue(nextValue);
      if (!isNaN(nextValue)) {
        if (nextValue < min3 || nextValue > max3) {
          nextValue = floatClamp(nextValue, min3, max3);
        }
        onChange(nextValue);
        isResetPendent.current = false;
      } else if (allowReset) {
        isResetPendent.current = true;
      }
    };
    const handleOnInputNumberBlur = () => {
      if (isResetPendent.current) {
        handleOnReset();
        isResetPendent.current = false;
      }
    };
    const handleOnReset = () => {
      const resetValue = Number.isNaN(resetFallbackValue) ? null : resetFallbackValue ?? null;
      setValue(resetValue);
      onChange(resetValue ?? void 0);
    };
    const handleShowTooltip = () => setShowTooltip(true);
    const handleHideTooltip = () => setShowTooltip(false);
    const handleOnBlur = (event) => {
      onBlur(event);
      setIsFocused(false);
      handleHideTooltip();
    };
    const handleOnFocus = (event) => {
      onFocus(event);
      setIsFocused(true);
      handleShowTooltip();
    };
    const offsetStyle = {
      [(0, import_i18n13.isRTL)() ? "right" : "left"]: fillValueOffset
    };
    return /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(base_control_default, {
      className: classes,
      label,
      hideLabelFromVision,
      id: `${id3}`,
      help,
      children: /* @__PURE__ */ (0, import_jsx_runtime129.jsxs)(Root2, {
        className: "components-range-control__root",
        children: [beforeIcon && /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(BeforeIconWrapper, {
          children: /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(icon_default3, {
            icon: beforeIcon
          })
        }), /* @__PURE__ */ (0, import_jsx_runtime129.jsxs)(Wrapper2, {
          className: wrapperClasses,
          color: colorProp,
          marks: !!marks,
          children: [/* @__PURE__ */ (0, import_jsx_runtime129.jsx)(input_range_default, {
            ...otherProps,
            className: "components-range-control__slider",
            describedBy,
            disabled,
            id: `${id3}`,
            label,
            max: max3,
            min: min3,
            onBlur: handleOnBlur,
            onChange: handleOnRangeChange,
            onFocus: handleOnFocus,
            onMouseMove,
            onMouseLeave,
            ref: (0, import_compose29.useMergeRefs)([inputRef, forwardedRef]),
            step,
            value: inputSliderValue ?? void 0
          }), /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(RangeRail, {
            "aria-hidden": true,
            disabled,
            marks,
            max: max3,
            min: min3,
            railColor,
            step,
            value: rangeFillValue
          }), /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(Track, {
            "aria-hidden": true,
            className: "components-range-control__track",
            disabled,
            style: {
              width: fillValueOffset
            },
            trackColor
          }), /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(ThumbWrapper, {
            className: "components-range-control__thumb-wrapper",
            style: offsetStyle,
            disabled,
            children: /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(Thumb, {
              "aria-hidden": true,
              isFocused: isThumbFocused,
              disabled
            })
          }), enableTooltip && /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(SimpleTooltip, {
            className: "components-range-control__tooltip",
            inputRef,
            tooltipPlacement: "bottom",
            renderTooltipContent,
            show: isCurrentlyFocused || showTooltip,
            style: offsetStyle,
            value
          })]
        }), afterIcon && /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(AfterIconWrapper, {
          children: /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(icon_default3, {
            icon: afterIcon
          })
        }), hasInputField && /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(InputNumber, {
          "aria-label": label,
          className: "components-range-control__number",
          disabled,
          inputMode: "decimal",
          isShiftStepEnabled,
          max: max3,
          min: min3,
          onBlur: handleOnInputNumberBlur,
          onChange: handleOnChange,
          shiftStep,
          __unstableInputWidth: space(20),
          step,
          value: inputSliderValue
        }), allowReset && /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(ActionRightWrapper, {
          children: /* @__PURE__ */ (0, import_jsx_runtime129.jsx)(button_default, {
            className: "components-range-control__reset",
            accessibleWhenDisabled: !disabled,
            disabled: disabled || value === computeResetValue({
              resetFallbackValue,
              initialPosition
            }),
            variant: "secondary",
            size: "small",
            onClick: handleOnReset,
            children: (0, import_i18n13.__)("Reset")
          })
        })]
      })
    });
  }
  var RangeControl = (0, import_element72.forwardRef)(UnforwardedRangeControl);
  RangeControl.displayName = "RangeControl";
  var range_control_default = RangeControl;

  // packages/components/build-module/color-picker/styles.mjs
  var NumberControlWrapper = /* @__PURE__ */ createStyled(number_control_default, false ? {
    target: "ez9hsf46"
  } : {
    target: "ez9hsf46",
    label: "NumberControlWrapper"
  })("width:", space(24), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var SelectControl2 = /* @__PURE__ */ createStyled(select_control_default, false ? {
    target: "ez9hsf45"
  } : {
    target: "ez9hsf45",
    label: "SelectControl"
  })("margin-left:", space(-2), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var RangeControl2 = /* @__PURE__ */ createStyled(range_control_default, false ? {
    target: "ez9hsf44"
  } : {
    target: "ez9hsf44",
    label: "RangeControl"
  })("flex:1;margin-right:", space(2), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var interactiveHueStyles = `
.react-colorful__interactive {
	width: calc( 100% - ${space(2)} );
	margin-left: ${space(1)};
}`;
  var AuxiliaryColorArtefactWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "ez9hsf43"
  } : {
    target: "ez9hsf43",
    label: "AuxiliaryColorArtefactWrapper"
  })("padding-top:", space(2), ";padding-right:0;padding-left:0;padding-bottom:0;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var AuxiliaryColorArtefactHStackHeader = /* @__PURE__ */ createStyled(component_default9, false ? {
    target: "ez9hsf42"
  } : {
    target: "ez9hsf42",
    label: "AuxiliaryColorArtefactHStackHeader"
  })("padding-left:", space(4), ";padding-right:", space(4), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var ColorInputWrapper = /* @__PURE__ */ createStyled(component_default3, false ? {
    target: "ez9hsf41"
  } : {
    target: "ez9hsf41",
    label: "ColorInputWrapper"
  })("padding-top:", space(4), ";padding-left:", space(4), ";padding-right:", space(3), ";padding-bottom:", space(5), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var ColorfulWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "ez9hsf40"
  } : {
    target: "ez9hsf40",
    label: "ColorfulWrapper"
  })(boxSizingReset, ";width:216px;.react-colorful{display:flex;flex-direction:column;align-items:center;width:216px;height:auto;}.react-colorful__saturation{width:100%;border-radius:0;height:216px;margin-bottom:", space(4), ";border-bottom:none;}.react-colorful__hue,.react-colorful__alpha{width:184px;height:16px;border-radius:", config_values_default.radiusFull, ";margin-bottom:", space(2), ";}.react-colorful__pointer{height:16px;width:16px;border:none;box-shadow:0 0 2px 0 rgba( 0, 0, 0, 0.25 );outline:2px solid transparent;@media not ( prefers-reduced-motion ){transition:transform ", config_values_default.transitionDurationFast, " ease-in-out;}}.react-colorful__interactive:focus .react-colorful__pointer{box-shadow:0 0 0 ", config_values_default.borderWidthFocus, " ", config_values_default.surfaceColor, ";border:", config_values_default.borderWidthFocus, " solid black;transform:translate( -50%, -50% ) scale( 1.5 );}.react-colorful__pointer-fill{box-shadow:inset 0 0 0 ", config_values_default.borderWidthFocus, " #fff;}", interactiveHueStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));

  // packages/components/build-module/color-picker/color-copy-button.mjs
  var import_compose30 = __toESM(require_compose(), 1);
  var import_element73 = __toESM(require_element(), 1);
  var import_i18n14 = __toESM(require_i18n(), 1);
  var import_jsx_runtime130 = __toESM(require_jsx_runtime(), 1);
  var ColorCopyButton = (props) => {
    const {
      color: color2,
      colorType
    } = props;
    const [copiedColor, setCopiedColor] = (0, import_element73.useState)(null);
    const copyTimerRef = (0, import_element73.useRef)(void 0);
    const copyRef = (0, import_compose30.useCopyToClipboard)(() => {
      switch (colorType) {
        case "hsl": {
          return color2.toHslString();
        }
        case "rgb": {
          return color2.toRgbString();
        }
        default:
        case "hex": {
          return color2.toHex();
        }
      }
    }, () => {
      if (copyTimerRef.current) {
        clearTimeout(copyTimerRef.current);
      }
      setCopiedColor(color2.toHex());
      copyTimerRef.current = setTimeout(() => {
        setCopiedColor(null);
        copyTimerRef.current = void 0;
      }, 3e3);
    });
    (0, import_element73.useEffect)(() => {
      return () => {
        if (copyTimerRef.current) {
          clearTimeout(copyTimerRef.current);
        }
      };
    }, []);
    const isCopied = copiedColor === color2.toHex();
    const label = isCopied ? (0, import_i18n14.__)("Copied!") : (0, import_i18n14.__)("Copy");
    return /* @__PURE__ */ (0, import_jsx_runtime130.jsx)(tooltip_default, {
      delay: 0,
      hideOnClick: false,
      text: label,
      children: /* @__PURE__ */ (0, import_jsx_runtime130.jsx)(Button3, {
        size: "compact",
        "aria-label": label,
        ref: copyRef,
        icon: isCopied ? check_default : copy_default,
        showTooltip: false
      })
    });
  };

  // packages/components/build-module/color-picker/input-with-slider.mjs
  var import_jsx_runtime131 = __toESM(require_jsx_runtime(), 1);
  var InputWithSlider = ({
    min: min3,
    max: max3,
    label,
    abbreviation,
    onChange,
    value
  }) => {
    const onNumberControlChange = (newValue) => {
      if (!newValue) {
        onChange(0);
        return;
      }
      if (typeof newValue === "string") {
        onChange(parseInt(newValue, 10));
        return;
      }
      onChange(newValue);
    };
    return /* @__PURE__ */ (0, import_jsx_runtime131.jsxs)(component_default9, {
      spacing: 4,
      children: [/* @__PURE__ */ (0, import_jsx_runtime131.jsx)(NumberControlWrapper, {
        min: min3,
        max: max3,
        label,
        hideLabelFromVision: true,
        value,
        onChange: onNumberControlChange,
        prefix: /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(input_prefix_wrapper_default, {
          children: /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(component_default8, {
            color: COLORS.theme.accent,
            lineHeight: 1,
            children: abbreviation
          })
        }),
        spinControls: "none"
      }), /* @__PURE__ */ (0, import_jsx_runtime131.jsx)(RangeControl2, {
        label,
        hideLabelFromVision: true,
        min: min3,
        max: max3,
        value,
        onChange,
        withInputField: false
      })]
    });
  };

  // packages/components/build-module/color-picker/rgb-input.mjs
  var import_jsx_runtime132 = __toESM(require_jsx_runtime(), 1);
  var RgbInput = ({
    color: color2,
    onChange,
    enableAlpha
  }) => {
    const {
      r: r4,
      g: g3,
      b: b3,
      a: a3
    } = color2.toRgb();
    return /* @__PURE__ */ (0, import_jsx_runtime132.jsxs)(import_jsx_runtime132.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime132.jsx)(InputWithSlider, {
        min: 0,
        max: 255,
        label: "Red",
        abbreviation: "R",
        value: r4,
        onChange: (nextR) => onChange(w({
          r: nextR,
          g: g3,
          b: b3,
          a: a3
        }))
      }), /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(InputWithSlider, {
        min: 0,
        max: 255,
        label: "Green",
        abbreviation: "G",
        value: g3,
        onChange: (nextG) => onChange(w({
          r: r4,
          g: nextG,
          b: b3,
          a: a3
        }))
      }), /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(InputWithSlider, {
        min: 0,
        max: 255,
        label: "Blue",
        abbreviation: "B",
        value: b3,
        onChange: (nextB) => onChange(w({
          r: r4,
          g: g3,
          b: nextB,
          a: a3
        }))
      }), enableAlpha && /* @__PURE__ */ (0, import_jsx_runtime132.jsx)(InputWithSlider, {
        min: 0,
        max: 100,
        label: "Alpha",
        abbreviation: "A",
        value: Math.trunc(a3 * 100),
        onChange: (nextA) => onChange(w({
          r: r4,
          g: g3,
          b: b3,
          a: nextA / 100
        }))
      })]
    });
  };

  // packages/components/build-module/color-picker/hsl-input.mjs
  var import_jsx_runtime133 = __toESM(require_jsx_runtime(), 1);
  var HslInput = ({
    hsla: hsla2,
    onChange,
    enableAlpha
  }) => {
    const updateHSLAValue = (partialNewValue) => {
      onChange({
        ...hsla2,
        ...partialNewValue
      });
    };
    return /* @__PURE__ */ (0, import_jsx_runtime133.jsxs)(import_jsx_runtime133.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime133.jsx)(InputWithSlider, {
        min: 0,
        max: 359,
        label: "Hue",
        abbreviation: "H",
        value: hsla2.h,
        onChange: (nextH) => {
          updateHSLAValue({
            h: nextH
          });
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime133.jsx)(InputWithSlider, {
        min: 0,
        max: 100,
        label: "Saturation",
        abbreviation: "S",
        value: hsla2.s,
        onChange: (nextS) => {
          updateHSLAValue({
            s: nextS
          });
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime133.jsx)(InputWithSlider, {
        min: 0,
        max: 100,
        label: "Lightness",
        abbreviation: "L",
        value: hsla2.l,
        onChange: (nextL) => {
          updateHSLAValue({
            l: nextL
          });
        }
      }), enableAlpha && /* @__PURE__ */ (0, import_jsx_runtime133.jsx)(InputWithSlider, {
        min: 0,
        max: 100,
        label: "Alpha",
        abbreviation: "A",
        value: Math.trunc(100 * hsla2.a),
        onChange: (nextA) => {
          updateHSLAValue({
            a: nextA / 100
          });
        }
      })]
    });
  };

  // packages/components/build-module/color-picker/hex-input.mjs
  var import_i18n15 = __toESM(require_i18n(), 1);
  var import_jsx_runtime134 = __toESM(require_jsx_runtime(), 1);
  var HexInput = ({
    color: color2,
    onChange,
    enableAlpha
  }) => {
    const handleChange = (nextValue) => {
      if (nextValue === void 0) {
        return;
      }
      const hexValue = nextValue.startsWith("#") ? nextValue : "#" + nextValue;
      onChange(w(hexValue));
    };
    const stateReducer = (state, action) => {
      const nativeEvent = action.payload?.event?.nativeEvent;
      if ("insertFromPaste" !== nativeEvent?.inputType) {
        return {
          ...state
        };
      }
      const value = state.value?.startsWith("#") ? state.value.slice(1).toUpperCase() : state.value?.toUpperCase();
      return {
        ...state,
        value
      };
    };
    return /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(InputControl, {
      prefix: /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(input_prefix_wrapper_default, {
        children: /* @__PURE__ */ (0, import_jsx_runtime134.jsx)(component_default8, {
          color: COLORS.theme.accent,
          lineHeight: 1,
          children: "#"
        })
      }),
      value: color2.toHex().slice(1).toUpperCase(),
      onChange: handleChange,
      maxLength: enableAlpha ? 9 : 7,
      label: (0, import_i18n15.__)("Hex color"),
      hideLabelFromVision: true,
      __unstableStateReducer: stateReducer,
      __unstableInputWidth: "9em"
    });
  };

  // packages/components/build-module/color-picker/color-input.mjs
  var import_jsx_runtime135 = __toESM(require_jsx_runtime(), 1);
  var ColorInput = ({
    colorType,
    color: color2,
    hsla: hsla2,
    onChange,
    onHSLChange,
    enableAlpha
  }) => {
    switch (colorType) {
      case "hsl":
        return /* @__PURE__ */ (0, import_jsx_runtime135.jsx)(HslInput, {
          hsla: hsla2,
          onChange: onHSLChange,
          enableAlpha
        });
      case "rgb":
        return /* @__PURE__ */ (0, import_jsx_runtime135.jsx)(RgbInput, {
          color: color2,
          onChange,
          enableAlpha
        });
      default:
      case "hex":
        return /* @__PURE__ */ (0, import_jsx_runtime135.jsx)(HexInput, {
          color: color2,
          onChange,
          enableAlpha
        });
    }
  };

  // packages/components/build-module/color-picker/picker.mjs
  var import_element74 = __toESM(require_element(), 1);

  // packages/components/node_modules/react-colorful/dist/index.mjs
  var import_react98 = __toESM(require_react(), 1);
  function u2() {
    return (u2 = Object.assign || function(e3) {
      for (var r4 = 1; r4 < arguments.length; r4++) {
        var t4 = arguments[r4];
        for (var n3 in t4) Object.prototype.hasOwnProperty.call(t4, n3) && (e3[n3] = t4[n3]);
      }
      return e3;
    }).apply(this, arguments);
  }
  function c2(e3, r4) {
    if (null == e3) return {};
    var t4, n3, o4 = {}, a3 = Object.keys(e3);
    for (n3 = 0; n3 < a3.length; n3++) r4.indexOf(t4 = a3[n3]) >= 0 || (o4[t4] = e3[t4]);
    return o4;
  }
  function i2(e3) {
    var t4 = (0, import_react98.useRef)(e3), n3 = (0, import_react98.useRef)(function(e4) {
      t4.current && t4.current(e4);
    });
    return t4.current = e3, n3.current;
  }
  var s2 = function(e3, r4, t4) {
    return void 0 === r4 && (r4 = 0), void 0 === t4 && (t4 = 1), e3 > t4 ? t4 : e3 < r4 ? r4 : e3;
  };
  var f2 = function(e3) {
    return "touches" in e3;
  };
  var v2 = function(e3) {
    return e3 && e3.ownerDocument.defaultView || self;
  };
  var d2 = function(e3, r4, t4) {
    var n3 = e3.getBoundingClientRect(), o4 = f2(r4) ? (function(e4, r5) {
      for (var t5 = 0; t5 < e4.length; t5++) if (e4[t5].identifier === r5) return e4[t5];
      return e4[0];
    })(r4.touches, t4) : r4;
    return { left: s2((o4.pageX - (n3.left + v2(e3).pageXOffset)) / n3.width), top: s2((o4.pageY - (n3.top + v2(e3).pageYOffset)) / n3.height) };
  };
  var h2 = function(e3) {
    !f2(e3) && e3.preventDefault();
  };
  var m2 = import_react98.default.memo(function(o4) {
    var a3 = o4.onMove, l3 = o4.onKey, s3 = c2(o4, ["onMove", "onKey"]), m3 = (0, import_react98.useRef)(null), g3 = i2(a3), p3 = i2(l3), b3 = (0, import_react98.useRef)(null), _2 = (0, import_react98.useRef)(false), x2 = (0, import_react98.useMemo)(function() {
      var e3 = function(e4) {
        h2(e4), (f2(e4) ? e4.touches.length > 0 : e4.buttons > 0) && m3.current ? g3(d2(m3.current, e4, b3.current)) : t4(false);
      }, r4 = function() {
        return t4(false);
      };
      function t4(t5) {
        var n3 = _2.current, o5 = v2(m3.current), a4 = t5 ? o5.addEventListener : o5.removeEventListener;
        a4(n3 ? "touchmove" : "mousemove", e3), a4(n3 ? "touchend" : "mouseup", r4);
      }
      return [function(e4) {
        var r5 = e4.nativeEvent, n3 = m3.current;
        if (n3 && (h2(r5), !(function(e5, r6) {
          return r6 && !f2(e5);
        })(r5, _2.current) && n3)) {
          if (f2(r5)) {
            _2.current = true;
            var o5 = r5.changedTouches || [];
            o5.length && (b3.current = o5[0].identifier);
          }
          n3.focus(), g3(d2(n3, r5, b3.current)), t4(true);
        }
      }, function(e4) {
        var r5 = e4.which || e4.keyCode;
        r5 < 37 || r5 > 40 || (e4.preventDefault(), p3({ left: 39 === r5 ? 0.05 : 37 === r5 ? -0.05 : 0, top: 40 === r5 ? 0.05 : 38 === r5 ? -0.05 : 0 }));
      }, t4];
    }, [p3, g3]), C = x2[0], E = x2[1], H2 = x2[2];
    return (0, import_react98.useEffect)(function() {
      return H2;
    }, [H2]), import_react98.default.createElement("div", u2({}, s3, { onTouchStart: C, onMouseDown: C, className: "react-colorful__interactive", ref: m3, onKeyDown: E, tabIndex: 0, role: "slider" }));
  });
  var g2 = function(e3) {
    return e3.filter(Boolean).join(" ");
  };
  var p2 = function(r4) {
    var t4 = r4.color, n3 = r4.left, o4 = r4.top, a3 = void 0 === o4 ? 0.5 : o4, l3 = g2(["react-colorful__pointer", r4.className]);
    return import_react98.default.createElement("div", { className: l3, style: { top: 100 * a3 + "%", left: 100 * n3 + "%" } }, import_react98.default.createElement("div", { className: "react-colorful__pointer-fill", style: { backgroundColor: t4 } }));
  };
  var b2 = function(e3, r4, t4) {
    return void 0 === r4 && (r4 = 0), void 0 === t4 && (t4 = Math.pow(10, r4)), Math.round(t4 * e3) / t4;
  };
  var _ = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) };
  var y2 = function(e3) {
    var r4 = e3.s, t4 = e3.v, n3 = e3.a, o4 = (200 - r4) * t4 / 100;
    return { h: b2(e3.h), s: b2(o4 > 0 && o4 < 200 ? r4 * t4 / 100 / (o4 <= 100 ? o4 : 200 - o4) * 100 : 0), l: b2(o4 / 2), a: b2(n3, 2) };
  };
  var q = function(e3) {
    var r4 = y2(e3);
    return "hsl(" + r4.h + ", " + r4.s + "%, " + r4.l + "%)";
  };
  var k2 = function(e3) {
    var r4 = y2(e3);
    return "hsla(" + r4.h + ", " + r4.s + "%, " + r4.l + "%, " + r4.a + ")";
  };
  var A = function(e3) {
    return { h: b2(e3.h), s: b2(e3.s), v: b2(e3.v), a: b2(e3.a, 2) };
  };
  var S2 = import_react98.default.memo(function(r4) {
    var t4 = r4.hue, n3 = r4.onChange, o4 = g2(["react-colorful__hue", r4.className]);
    return import_react98.default.createElement("div", { className: o4 }, import_react98.default.createElement(m2, { onMove: function(e3) {
      n3({ h: 360 * e3.left });
    }, onKey: function(e3) {
      n3({ h: s2(t4 + 360 * e3.left, 0, 360) });
    }, "aria-label": "Hue", "aria-valuenow": b2(t4), "aria-valuemax": "360", "aria-valuemin": "0" }, import_react98.default.createElement(p2, { className: "react-colorful__hue-pointer", left: t4 / 360, color: q({ h: t4, s: 100, v: 100, a: 1 }) })));
  });
  var T = import_react98.default.memo(function(r4) {
    var t4 = r4.hsva, n3 = r4.onChange, o4 = { backgroundColor: q({ h: t4.h, s: 100, v: 100, a: 1 }) };
    return import_react98.default.createElement("div", { className: "react-colorful__saturation", style: o4 }, import_react98.default.createElement(m2, { onMove: function(e3) {
      n3({ s: 100 * e3.left, v: 100 - 100 * e3.top });
    }, onKey: function(e3) {
      n3({ s: s2(t4.s + 100 * e3.left, 0, 100), v: s2(t4.v - 100 * e3.top, 0, 100) });
    }, "aria-label": "Color", "aria-valuetext": "Saturation " + b2(t4.s) + "%, Brightness " + b2(t4.v) + "%" }, import_react98.default.createElement(p2, { className: "react-colorful__saturation-pointer", top: 1 - t4.v / 100, left: t4.s / 100, color: q(t4) })));
  });
  var F = function(e3, r4) {
    if (e3 === r4) return true;
    for (var t4 in e3) if (e3[t4] !== r4[t4]) return false;
    return true;
  };
  function Y(e3, t4, l3) {
    var u3 = i2(l3), c3 = (0, import_react98.useState)(function() {
      return e3.toHsva(t4);
    }), s3 = c3[0], f3 = c3[1], v3 = (0, import_react98.useRef)({ color: t4, hsva: s3 });
    (0, import_react98.useEffect)(function() {
      if (!e3.equal(t4, v3.current.color)) {
        var r4 = e3.toHsva(t4);
        v3.current = { hsva: r4, color: t4 }, f3(r4);
      }
    }, [t4, e3]), (0, import_react98.useEffect)(function() {
      var r4;
      F(s3, v3.current.hsva) || e3.equal(r4 = e3.fromHsva(s3), v3.current.color) || (v3.current = { hsva: s3, color: r4 }, u3(r4));
    }, [s3, e3, u3]);
    var d3 = (0, import_react98.useCallback)(function(e4) {
      f3(function(r4) {
        return Object.assign({}, r4, e4);
      });
    }, []);
    return [s3, d3];
  }
  var R;
  var V2 = "undefined" != typeof window ? import_react98.useLayoutEffect : import_react98.useEffect;
  var $2 = function() {
    return R || ("undefined" != typeof __webpack_nonce__ ? __webpack_nonce__ : void 0);
  };
  var J = /* @__PURE__ */ new Map();
  var Q = function(e3) {
    V2(function() {
      var r4 = e3.current ? e3.current.ownerDocument : document;
      if (void 0 !== r4 && !J.has(r4)) {
        var t4 = r4.createElement("style");
        t4.innerHTML = `.react-colorful{position:relative;display:flex;flex-direction:column;width:200px;height:200px;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.react-colorful__saturation{position:relative;flex-grow:1;border-color:transparent;border-bottom:12px solid #000;border-radius:8px 8px 0 0;background-image:linear-gradient(0deg,#000,transparent),linear-gradient(90deg,#fff,hsla(0,0%,100%,0))}.react-colorful__alpha-gradient,.react-colorful__pointer-fill{content:"";position:absolute;left:0;top:0;right:0;bottom:0;pointer-events:none;border-radius:inherit}.react-colorful__alpha-gradient,.react-colorful__saturation{box-shadow:inset 0 0 0 1px rgba(0,0,0,.05)}.react-colorful__alpha,.react-colorful__hue{position:relative;height:24px}.react-colorful__hue{background:linear-gradient(90deg,red 0,#ff0 17%,#0f0 33%,#0ff 50%,#00f 67%,#f0f 83%,red)}.react-colorful__last-control{border-radius:0 0 8px 8px}.react-colorful__interactive{position:absolute;left:0;top:0;right:0;bottom:0;border-radius:inherit;outline:none;touch-action:none}.react-colorful__pointer{position:absolute;z-index:1;box-sizing:border-box;width:28px;height:28px;transform:translate(-50%,-50%);background-color:#fff;border:2px solid #fff;border-radius:50%;box-shadow:0 2px 4px rgba(0,0,0,.2)}.react-colorful__interactive:focus .react-colorful__pointer{transform:translate(-50%,-50%) scale(1.1)}.react-colorful__alpha,.react-colorful__alpha-pointer{background-color:#fff;background-image:url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill-opacity=".05"><path d="M8 0h8v8H8zM0 8h8v8H0z"/></svg>')}.react-colorful__saturation-pointer{z-index:3}.react-colorful__hue-pointer{z-index:2}`, J.set(r4, t4);
        var n3 = $2();
        n3 && t4.setAttribute("nonce", n3), r4.head.appendChild(t4);
      }
    }, []);
  };
  var U = function(t4) {
    var n3 = t4.className, o4 = t4.colorModel, a3 = t4.color, l3 = void 0 === a3 ? o4.defaultColor : a3, i3 = t4.onChange, s3 = c2(t4, ["className", "colorModel", "color", "onChange"]), f3 = (0, import_react98.useRef)(null);
    Q(f3);
    var v3 = Y(o4, l3, i3), d3 = v3[0], h3 = v3[1], m3 = g2(["react-colorful", n3]);
    return import_react98.default.createElement("div", u2({}, s3, { ref: f3, className: m3 }), import_react98.default.createElement(T, { hsva: d3, onChange: h3 }), import_react98.default.createElement(S2, { hue: d3.h, onChange: h3, className: "react-colorful__last-control" }));
  };
  var ee = function(r4) {
    var t4 = r4.className, n3 = r4.hsva, o4 = r4.onChange, a3 = { backgroundImage: "linear-gradient(90deg, " + k2(Object.assign({}, n3, { a: 0 })) + ", " + k2(Object.assign({}, n3, { a: 1 })) + ")" }, l3 = g2(["react-colorful__alpha", t4]), u3 = b2(100 * n3.a);
    return import_react98.default.createElement("div", { className: l3 }, import_react98.default.createElement("div", { className: "react-colorful__alpha-gradient", style: a3 }), import_react98.default.createElement(m2, { onMove: function(e3) {
      o4({ a: e3.left });
    }, onKey: function(e3) {
      o4({ a: s2(n3.a + e3.left) });
    }, "aria-label": "Alpha", "aria-valuetext": u3 + "%", "aria-valuenow": u3, "aria-valuemin": "0", "aria-valuemax": "100" }, import_react98.default.createElement(p2, { className: "react-colorful__alpha-pointer", left: n3.a, color: k2(n3) })));
  };
  var re = function(t4) {
    var n3 = t4.className, o4 = t4.colorModel, a3 = t4.color, l3 = void 0 === a3 ? o4.defaultColor : a3, i3 = t4.onChange, s3 = c2(t4, ["className", "colorModel", "color", "onChange"]), f3 = (0, import_react98.useRef)(null);
    Q(f3);
    var v3 = Y(o4, l3, i3), d3 = v3[0], h3 = v3[1], m3 = g2(["react-colorful", n3]);
    return import_react98.default.createElement("div", u2({}, s3, { ref: f3, className: m3 }), import_react98.default.createElement(T, { hsva: d3, onChange: h3 }), import_react98.default.createElement(S2, { hue: d3.h, onChange: h3 }), import_react98.default.createElement(ee, { hsva: d3, onChange: h3, className: "react-colorful__last-control" }));
  };
  var ve = { defaultColor: { h: 0, s: 0, v: 0, a: 1 }, toHsva: function(e3) {
    return e3;
  }, fromHsva: A, equal: F };
  var de = function(r4) {
    return import_react98.default.createElement(re, u2({}, r4, { colorModel: ve }));
  };
  var ge = { defaultColor: { h: 0, s: 0, v: 0 }, toHsva: function(e3) {
    return { h: e3.h, s: e3.s, v: e3.v, a: 1 };
  }, fromHsva: function(e3) {
    var r4 = A(e3);
    return { h: r4.h, s: r4.s, v: r4.v };
  }, equal: F };
  var pe = function(r4) {
    return import_react98.default.createElement(U, u2({}, r4, { colorModel: ge }));
  };

  // packages/components/build-module/color-picker/picker.mjs
  var import_jsx_runtime136 = __toESM(require_jsx_runtime(), 1);
  function toHsva(hsla2) {
    return {
      ...w(hsla2).toHsv(),
      // HSL and HSV share the hue angle. Color conversion collapses achromatic
      // hue to 0, but HSLA retains the user's latent hue.
      h: hsla2.h,
      a: hsla2.a
    };
  }
  function isSameHsla(a3, b3) {
    return a3.h === b3.h && a3.s === b3.s && a3.l === b3.l && a3.a === b3.a;
  }
  function toHsvaFromHsla(hsla2, prevHsva, prevHsla) {
    const converted = toHsva(hsla2);
    if (hsla2.l !== 0) {
      return converted;
    }
    const saturationChanged = prevHsla !== null && prevHsla.s !== hsla2.s;
    return {
      h: hsla2.h,
      s: saturationChanged ? hsla2.s : prevHsva.s,
      v: 0,
      a: hsla2.a
    };
  }
  var Picker = ({
    hsla: hsla2,
    enableAlpha,
    onChange,
    onInteractionStart,
    onInteractionEnd
  }) => {
    const [hsva, setHsva] = (0, import_element74.useState)(() => toHsva(hsla2));
    const pickerOriginHslaRef = (0, import_element74.useRef)(null);
    const prevHslaRef = (0, import_element74.useRef)(hsla2);
    const isPointerInteractingRef = (0, import_element74.useRef)(false);
    (0, import_element74.useEffect)(() => {
      if (isPointerInteractingRef.current) {
        prevHslaRef.current = hsla2;
        return;
      }
      if (pickerOriginHslaRef.current && isSameHsla(pickerOriginHslaRef.current, hsla2)) {
        prevHslaRef.current = hsla2;
        return;
      }
      pickerOriginHslaRef.current = null;
      setHsva((prev2) => toHsvaFromHsla(hsla2, prev2, prevHslaRef.current));
      prevHslaRef.current = hsla2;
    }, [hsla2]);
    const pointerCaptureProps = {
      onPointerDown({
        currentTarget,
        pointerId: pointerId2
      }) {
        isPointerInteractingRef.current = true;
        onInteractionStart?.();
        currentTarget.setPointerCapture(pointerId2);
      },
      onPointerUp({
        currentTarget,
        pointerId: pointerId2
      }) {
        currentTarget.releasePointerCapture(pointerId2);
        isPointerInteractingRef.current = false;
        onInteractionEnd?.();
      },
      onPointerCancel({
        currentTarget,
        pointerId: pointerId2
      }) {
        currentTarget.releasePointerCapture(pointerId2);
        isPointerInteractingRef.current = false;
        onInteractionEnd?.();
      }
    };
    const handleChange = (next2) => {
      setHsva(next2);
      const nextHsla = {
        ...w(next2).toHsl(),
        a: next2.a
      };
      pickerOriginHslaRef.current = nextHsla;
      onChange(nextHsla);
    };
    if (enableAlpha) {
      return /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(de, {
        color: hsva,
        onChange: handleChange,
        ...pointerCaptureProps
      });
    }
    const hsv = {
      h: hsva.h,
      s: hsva.s,
      v: hsva.v
    };
    return /* @__PURE__ */ (0, import_jsx_runtime136.jsx)(pe, {
      color: hsv,
      onChange: (next2) => {
        handleChange({
          ...next2,
          a: hsva.a
        });
      },
      ...pointerCaptureProps
    });
  };

  // packages/components/build-module/color-picker/component.mjs
  var import_jsx_runtime137 = __toESM(require_jsx_runtime(), 1);
  k([names_default]);
  function mergeHSLA(nextHSLA, prevHSLA) {
    if (nextHSLA.s === 0) {
      if (nextHSLA.l === 0 || nextHSLA.l === 100) {
        return {
          ...nextHSLA,
          h: prevHSLA.h,
          s: prevHSLA.s
        };
      }
      return {
        ...nextHSLA,
        h: prevHSLA.h
      };
    }
    return nextHSLA;
  }
  var options = [{
    label: "RGB",
    value: "rgb"
  }, {
    label: "HSL",
    value: "hsl"
  }, {
    label: "Hex",
    value: "hex"
  }];
  var UnconnectedColorPicker = (props, forwardedRef) => {
    const {
      enableAlpha = false,
      color: colorProp,
      onChange,
      defaultValue: defaultValue2 = "#fff",
      copyFormat,
      ...divProps
    } = useContextSystem(props, "ColorPicker");
    const [color2, setColor] = useControlledValue({
      onChange,
      value: colorProp,
      defaultValue: defaultValue2
    });
    const safeColordColor = (0, import_element75.useMemo)(() => {
      return w(color2 || "");
    }, [color2]);
    const debouncedSetColor = (0, import_compose31.useDebounce)(setColor);
    const [internalHSLA, setInternalHSLA] = (0, import_element75.useState)(() => ({
      ...safeColordColor.toHsl()
    }));
    const lastProducedHexRef = (0, import_element75.useRef)(safeColordColor.toHex());
    const isPickerInteractingRef = (0, import_element75.useRef)(false);
    (0, import_element75.useEffect)(() => {
      if (isPickerInteractingRef.current) {
        return;
      }
      if (safeColordColor.isEqual(lastProducedHexRef.current)) {
        return;
      }
      lastProducedHexRef.current = safeColordColor.toHex();
      const externalHSLA = safeColordColor.toHsl();
      setInternalHSLA((prev2) => mergeHSLA(externalHSLA, prev2));
    }, [safeColordColor]);
    const handleHSLAChange = (0, import_element75.useCallback)((nextHSLA) => {
      setInternalHSLA(nextHSLA);
      const previousHex = lastProducedHexRef.current;
      const nextHex = w(nextHSLA).toHex();
      if (!w(nextHex).isEqual(previousHex)) {
        lastProducedHexRef.current = nextHex;
        setColor(nextHex);
      }
    }, [setColor]);
    const handleChange = (0, import_element75.useCallback)((nextValue) => {
      const nextHSLA = nextValue.toHsl();
      setInternalHSLA((prev2) => mergeHSLA(nextHSLA, prev2));
      const nextHex = nextValue.toHex();
      lastProducedHexRef.current = nextHex;
      debouncedSetColor(nextHex);
    }, [debouncedSetColor]);
    const [colorType, setColorType] = (0, import_element75.useState)(copyFormat || "hex");
    const maybeHandlePaste = (0, import_element75.useCallback)((event) => {
      const pastedText = event.clipboardData?.getData("text")?.trim();
      if (!pastedText) {
        return;
      }
      const parsedColor = w(pastedText);
      if (!parsedColor.isValid()) {
        return;
      }
      handleChange(parsedColor);
      const supportedFormats = {
        hex: "hex",
        rgb: "rgb",
        hsl: "hsl"
      };
      const detectedFormat = String(I(pastedText));
      const newColorType = supportedFormats[detectedFormat];
      if (newColorType) {
        setColorType(newColorType);
      }
      event.stopPropagation();
      event.preventDefault();
    }, [handleChange, setColorType]);
    return /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)(ColorfulWrapper, {
      ref: forwardedRef,
      ...divProps,
      onPasteCapture: maybeHandlePaste,
      children: [/* @__PURE__ */ (0, import_jsx_runtime137.jsx)(Picker, {
        onChange: handleHSLAChange,
        hsla: internalHSLA,
        enableAlpha,
        onInteractionStart: () => {
          isPickerInteractingRef.current = true;
        },
        onInteractionEnd: () => {
          isPickerInteractingRef.current = false;
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime137.jsxs)(AuxiliaryColorArtefactWrapper, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime137.jsxs)(AuxiliaryColorArtefactHStackHeader, {
          justify: "space-between",
          children: [/* @__PURE__ */ (0, import_jsx_runtime137.jsx)(SelectControl2, {
            size: "compact",
            options,
            value: colorType,
            onChange: (nextColorType) => setColorType(nextColorType),
            label: (0, import_i18n16.__)("Color format"),
            hideLabelFromVision: true,
            variant: "minimal"
          }), /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(ColorCopyButton, {
            color: safeColordColor,
            colorType: copyFormat || colorType
          })]
        }), /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(ColorInputWrapper, {
          direction: "column",
          gap: 2,
          children: /* @__PURE__ */ (0, import_jsx_runtime137.jsx)(ColorInput, {
            colorType,
            color: safeColordColor,
            hsla: internalHSLA,
            onChange: handleChange,
            onHSLChange: handleHSLAChange,
            enableAlpha
          })
        })]
      })]
    });
  };
  var ColorPicker = contextConnect(UnconnectedColorPicker, "ColorPicker");
  var component_default17 = ColorPicker;

  // packages/components/build-module/color-picker/use-deprecated-props.mjs
  var import_element76 = __toESM(require_element(), 1);
  function isLegacyProps(props) {
    return typeof props.onChangeComplete !== "undefined" || typeof props.disableAlpha !== "undefined" || typeof props.color?.hex === "string";
  }
  function getColorFromLegacyProps(color2) {
    if (color2 === void 0) {
      return;
    }
    if (typeof color2 === "string") {
      return color2;
    }
    if (color2.hex) {
      return color2.hex;
    }
    return void 0;
  }
  var transformColorStringToLegacyColor = memize((color2) => {
    const colordColor = w(color2);
    const hex2 = colordColor.toHex();
    const rgb = colordColor.toRgb();
    const hsv = colordColor.toHsv();
    const hsl = colordColor.toHsl();
    return {
      hex: hex2,
      rgb,
      hsv,
      hsl,
      source: "hex",
      oldHue: hsl.h
    };
  });
  function useDeprecatedProps3(props) {
    const {
      onChangeComplete
    } = props;
    const legacyChangeHandler = (0, import_element76.useCallback)((color2) => {
      onChangeComplete(transformColorStringToLegacyColor(color2));
    }, [onChangeComplete]);
    if (isLegacyProps(props)) {
      return {
        color: getColorFromLegacyProps(props.color),
        enableAlpha: !props.disableAlpha,
        onChange: legacyChangeHandler
      };
    }
    return {
      ...props,
      color: props.color,
      enableAlpha: props.enableAlpha,
      onChange: props.onChange
    };
  }

  // packages/components/build-module/color-picker/legacy-adapter.mjs
  var import_jsx_runtime138 = __toESM(require_jsx_runtime(), 1);
  var LegacyAdapter = (props) => {
    return /* @__PURE__ */ (0, import_jsx_runtime138.jsx)(component_default17, {
      ...useDeprecatedProps3(props)
    });
  };

  // packages/components/build-module/circular-option-picker/circular-option-picker.mjs
  var import_compose33 = __toESM(require_compose(), 1);
  var import_i18n17 = __toESM(require_i18n(), 1);
  var import_element79 = __toESM(require_element(), 1);

  // packages/components/build-module/circular-option-picker/circular-option-picker-context.mjs
  var import_element77 = __toESM(require_element(), 1);
  var CircularOptionPickerContext = (0, import_element77.createContext)({});
  CircularOptionPickerContext.displayName = "CircularOptionPickerContext";

  // packages/components/build-module/circular-option-picker/circular-option-picker-option.mjs
  var import_compose32 = __toESM(require_compose(), 1);
  var import_element78 = __toESM(require_element(), 1);
  var import_jsx_runtime139 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedOptionAsButton(props, forwardedRef) {
    const {
      isPressed,
      label,
      ...additionalProps
    } = props;
    return /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(button_default, {
      __next40pxDefaultSize: true,
      ...additionalProps,
      "aria-pressed": isPressed,
      ref: forwardedRef,
      label
    });
  }
  var OptionAsButton = (0, import_element78.forwardRef)(UnforwardedOptionAsButton);
  function UnforwardedOptionAsOption(props, forwardedRef) {
    const {
      id: id3,
      isSelected: isSelected2,
      label,
      ...additionalProps
    } = props;
    const {
      setActiveId,
      activeId
    } = (0, import_element78.useContext)(CircularOptionPickerContext);
    (0, import_element78.useEffect)(() => {
      if (isSelected2 && !activeId) {
        window.setTimeout(() => setActiveId?.(id3), 0);
      }
    }, [isSelected2, setActiveId, activeId, id3]);
    return /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(Composite22.Item, {
      render: /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(button_default, {
        __next40pxDefaultSize: true,
        ...additionalProps,
        role: "option",
        "aria-selected": !!isSelected2,
        ref: forwardedRef,
        label
      }),
      id: id3
    });
  }
  var OptionAsOption = (0, import_element78.forwardRef)(UnforwardedOptionAsOption);
  function Option({
    className: className2,
    isSelected: isSelected2,
    selectedIconProps = {},
    tooltipText,
    ...additionalProps
  }) {
    const {
      baseId,
      setActiveId
    } = (0, import_element78.useContext)(CircularOptionPickerContext);
    const id3 = (0, import_compose32.useInstanceId)(Option, baseId || "components-circular-option-picker__option");
    const commonProps = {
      id: id3,
      className: "components-circular-option-picker__option",
      ...additionalProps
    };
    const isListbox = setActiveId !== void 0;
    const optionControl = isListbox ? /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(OptionAsOption, {
      ...commonProps,
      label: tooltipText,
      isSelected: isSelected2
    }) : /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(OptionAsButton, {
      ...commonProps,
      label: tooltipText,
      isPressed: isSelected2
    });
    return /* @__PURE__ */ (0, import_jsx_runtime139.jsxs)("div", {
      className: clsx_default(className2, "components-circular-option-picker__option-wrapper"),
      children: [optionControl, isSelected2 && /* @__PURE__ */ (0, import_jsx_runtime139.jsx)(icon_default2, {
        icon: check_default,
        ...selectedIconProps
      })]
    });
  }

  // packages/components/build-module/circular-option-picker/circular-option-picker-option-group.mjs
  var import_jsx_runtime140 = __toESM(require_jsx_runtime(), 1);
  function OptionGroup({
    className: className2,
    options: options2,
    ...additionalProps
  }) {
    const role = "aria-label" in additionalProps || "aria-labelledby" in additionalProps ? "group" : void 0;
    return /* @__PURE__ */ (0, import_jsx_runtime140.jsx)("div", {
      ...additionalProps,
      role,
      className: clsx_default("components-circular-option-picker__option-group", "components-circular-option-picker__swatches", className2),
      children: options2
    });
  }

  // packages/components/build-module/circular-option-picker/circular-option-picker-actions.mjs
  var import_jsx_runtime141 = __toESM(require_jsx_runtime(), 1);
  function DropdownLinkAction({
    buttonProps,
    className: className2,
    dropdownProps,
    linkText
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime141.jsx)(dropdown_default, {
      className: clsx_default("components-circular-option-picker__dropdown-link-action", className2),
      renderToggle: ({
        isOpen,
        onToggle
      }) => /* @__PURE__ */ (0, import_jsx_runtime141.jsx)(button_default, {
        "aria-expanded": isOpen,
        "aria-haspopup": "true",
        onClick: onToggle,
        variant: "link",
        ...buttonProps,
        children: linkText
      }),
      ...dropdownProps
    });
  }
  function ButtonAction({
    className: className2,
    children,
    ...additionalProps
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime141.jsx)(button_default, {
      __next40pxDefaultSize: true,
      className: clsx_default("components-circular-option-picker__clear", className2),
      variant: "tertiary",
      ...additionalProps,
      children
    });
  }

  // packages/components/build-module/circular-option-picker/circular-option-picker.mjs
  var import_jsx_runtime142 = __toESM(require_jsx_runtime(), 1);
  function ListboxCircularOptionPicker(props) {
    const {
      actions,
      options: options2,
      baseId,
      className: className2,
      loop = true,
      children,
      ...additionalProps
    } = props;
    const [activeId, setActiveId] = (0, import_element79.useState)(void 0);
    const contextValue = (0, import_element79.useMemo)(() => ({
      baseId,
      activeId,
      setActiveId
    }), [baseId, activeId, setActiveId]);
    return /* @__PURE__ */ (0, import_jsx_runtime142.jsx)("div", {
      className: className2,
      children: /* @__PURE__ */ (0, import_jsx_runtime142.jsxs)(CircularOptionPickerContext.Provider, {
        value: contextValue,
        children: [/* @__PURE__ */ (0, import_jsx_runtime142.jsx)(Composite22, {
          ...additionalProps,
          id: baseId,
          focusLoop: loop,
          rtl: (0, import_i18n17.isRTL)(),
          role: "listbox",
          activeId,
          setActiveId,
          children: options2
        }), children, actions]
      })
    });
  }
  function ButtonsCircularOptionPicker(props) {
    const {
      actions,
      options: options2,
      children,
      baseId,
      ...additionalProps
    } = props;
    const contextValue = (0, import_element79.useMemo)(() => ({
      baseId
    }), [baseId]);
    return /* @__PURE__ */ (0, import_jsx_runtime142.jsx)("div", {
      ...additionalProps,
      role: "group",
      id: baseId,
      children: /* @__PURE__ */ (0, import_jsx_runtime142.jsxs)(CircularOptionPickerContext.Provider, {
        value: contextValue,
        children: [options2, children, actions]
      })
    });
  }
  function CircularOptionPicker(props) {
    const {
      asButtons,
      actions: actionsProp,
      options: optionsProp,
      children,
      className: className2,
      ...additionalProps
    } = props;
    const baseId = (0, import_compose33.useInstanceId)(CircularOptionPicker, "components-circular-option-picker", additionalProps.id);
    const OptionPickerImplementation = asButtons ? ButtonsCircularOptionPicker : ListboxCircularOptionPicker;
    const actions = actionsProp ? /* @__PURE__ */ (0, import_jsx_runtime142.jsx)("div", {
      className: "components-circular-option-picker__custom-clear-wrapper",
      children: actionsProp
    }) : void 0;
    const options2 = /* @__PURE__ */ (0, import_jsx_runtime142.jsx)("div", {
      className: "components-circular-option-picker__swatches",
      children: optionsProp
    });
    return /* @__PURE__ */ (0, import_jsx_runtime142.jsx)(OptionPickerImplementation, {
      ...additionalProps,
      baseId,
      className: clsx_default("components-circular-option-picker", className2),
      actions,
      options: options2,
      children
    });
  }
  CircularOptionPicker.Option = Option;
  CircularOptionPicker.OptionGroup = OptionGroup;
  CircularOptionPicker.ButtonAction = ButtonAction;
  CircularOptionPicker.DropdownLinkAction = DropdownLinkAction;
  CircularOptionPicker.displayName = "CircularOptionPicker";
  var circular_option_picker_default = CircularOptionPicker;

  // packages/components/build-module/circular-option-picker/utils.mjs
  var import_i18n18 = __toESM(require_i18n(), 1);
  function getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby) {
    const metaProps = asButtons ? {
      asButtons: true
    } : {
      asButtons: false,
      loop
    };
    const labelProps = {
      "aria-labelledby": ariaLabelledby,
      "aria-label": ariaLabelledby ? void 0 : ariaLabel || (0, import_i18n18.__)("Custom color picker")
    };
    return {
      metaProps,
      labelProps
    };
  }

  // packages/components/build-module/circular-option-picker/index.mjs
  var circular_option_picker_default2 = circular_option_picker_default;

  // packages/components/build-module/v-stack/hook.mjs
  function useVStack(props) {
    const {
      expanded = false,
      alignment = "stretch",
      ...otherProps
    } = useContextSystem(props, "VStack");
    const hStackProps = useHStack({
      direction: "column",
      expanded,
      alignment,
      ...otherProps
    });
    return hStackProps;
  }

  // packages/components/build-module/v-stack/component.mjs
  var import_jsx_runtime143 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedVStack(props, forwardedRef) {
    const vStackProps = useVStack(props);
    return /* @__PURE__ */ (0, import_jsx_runtime143.jsx)(component_default, {
      ...vStackProps,
      ref: forwardedRef
    });
  }
  var VStack = contextConnect(UnconnectedVStack, "VStack");
  var component_default18 = VStack;

  // packages/components/build-module/heading/hook.mjs
  function useHeading(props) {
    const {
      as: asProp,
      level = 2,
      color: color2 = COLORS.theme.foreground,
      isBlock = true,
      weight = config_values_default.fontWeightEmphasis,
      ...otherProps
    } = useContextSystem(props, "Heading");
    const as = asProp || `h${level}`;
    const a11yProps = {};
    if (typeof as === "string" && as[0] !== "h") {
      a11yProps.role = "heading";
      a11yProps["aria-level"] = typeof level === "string" ? parseInt(level) : level;
    }
    const textProps = useText({
      color: color2,
      isBlock,
      weight,
      size: getHeadingFontSize(level),
      ...otherProps
    });
    return {
      ...textProps,
      ...a11yProps,
      as
    };
  }

  // packages/components/build-module/heading/component.mjs
  var import_jsx_runtime144 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedHeading(props, forwardedRef) {
    const headerProps = useHeading(props);
    return /* @__PURE__ */ (0, import_jsx_runtime144.jsx)(component_default, {
      ...headerProps,
      ref: forwardedRef
    });
  }
  var Heading = contextConnect(UnconnectedHeading, "Heading");
  var component_default19 = Heading;

  // packages/components/build-module/color-palette/styles.mjs
  var ColorHeading = /* @__PURE__ */ createStyled(component_default19, false ? {
    target: "ev9wop70"
  } : {
    target: "ev9wop70",
    label: "ColorHeading"
  })("text-transform:uppercase;line-height:24px;font-weight:", config_values_default.fontWeightEmphasis, ";&&&{font-size:11px;margin-bottom:0;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXNkMiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBIZWFkaW5nIH0gZnJvbSAnLi4vaGVhZGluZyc7XG5pbXBvcnQgeyBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBDb2xvckhlYWRpbmcgPSBzdHlsZWQoIEhlYWRpbmcgKWBcblx0dGV4dC10cmFuc2Zvcm06IHVwcGVyY2FzZTtcblx0bGluZS1oZWlnaHQ6IDI0cHg7XG5cdGZvbnQtd2VpZ2h0OiAkeyBDT05GSUcuZm9udFdlaWdodEVtcGhhc2lzIH07XG5cdCYmJiB7XG5cdFx0Zm9udC1zaXplOiAxMXB4O1xuXHRcdG1hcmdpbi1ib3R0b206IDA7XG5cdH1cbmA7XG4iXX0= */"));

  // packages/components/build-module/dropdown/styles.mjs
  var padding = ({
    paddingSize = "small"
  }) => {
    if (paddingSize === "none") {
      return;
    }
    const paddingValues = {
      small: space(2),
      medium: space(4)
    };
    return /* @__PURE__ */ css("padding:", paddingValues[paddingSize] || paddingValues.small, ";" + (false ? "" : ";label:padding;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQlciLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBzcGFjZSB9IGZyb20gJy4uL3V0aWxzL3NwYWNlJztcbmltcG9ydCB0eXBlIHsgRHJvcGRvd25Db250ZW50V3JhcHBlclByb3BzIH0gZnJvbSAnLi90eXBlcyc7XG5cbmNvbnN0IHBhZGRpbmcgPSAoIHsgcGFkZGluZ1NpemUgPSAnc21hbGwnIH06IERyb3Bkb3duQ29udGVudFdyYXBwZXJQcm9wcyApID0+IHtcblx0aWYgKCBwYWRkaW5nU2l6ZSA9PT0gJ25vbmUnICkge1xuXHRcdHJldHVybjtcblx0fVxuXG5cdGNvbnN0IHBhZGRpbmdWYWx1ZXMgPSB7XG5cdFx0c21hbGw6IHNwYWNlKCAyICksXG5cdFx0bWVkaXVtOiBzcGFjZSggNCApLFxuXHR9O1xuXG5cdHJldHVybiBjc3NgXG5cdFx0cGFkZGluZzogJHsgcGFkZGluZ1ZhbHVlc1sgcGFkZGluZ1NpemUgXSB8fCBwYWRkaW5nVmFsdWVzLnNtYWxsIH07XG5cdGA7XG59O1xuXG5leHBvcnQgY29uc3QgRHJvcGRvd25Db250ZW50V3JhcHBlckRpdiA9IHN0eWxlZC5kaXY8IERyb3Bkb3duQ29udGVudFdyYXBwZXJQcm9wcyA+YFxuXHQvLyBOZWdhdGl2ZSBtYXJnaW4gdG8gcmVzZXQgKG9mZnNldCkgdGhlIGRlZmF1bHQgcGFkZGluZyBvbiAuY29tcG9uZW50cy1wb3BvdmVyX19jb250ZW50XG5cdG1hcmdpbi1sZWZ0OiAkeyBzcGFjZSggLTIgKSB9O1xuXHRtYXJnaW4tcmlnaHQ6ICR7IHNwYWNlKCAtMiApIH07XG5cdCY6Zmlyc3Qtb2YtdHlwZSB7XG5cdFx0bWFyZ2luLXRvcDogJHsgc3BhY2UoIC0yICkgfTtcblx0fVxuXHQmOmxhc3Qtb2YtdHlwZSB7XG5cdFx0bWFyZ2luLWJvdHRvbTogJHsgc3BhY2UoIC0yICkgfTtcblx0fVxuXG5cdCR7IHBhZGRpbmcgfTtcbmA7XG4iXX0= */");
  };
  var DropdownContentWrapperDiv = /* @__PURE__ */ createStyled("div", false ? {
    target: "eovvns30"
  } : {
    target: "eovvns30",
    label: "DropdownContentWrapperDiv"
  })("margin-left:", space(-2), ";margin-right:", space(-2), ";&:first-of-type{margin-top:", space(-2), ";}&:last-of-type{margin-bottom:", space(-2), ";}", padding, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEyQmtGIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi91dGlscy9zcGFjZSc7XG5pbXBvcnQgdHlwZSB7IERyb3Bkb3duQ29udGVudFdyYXBwZXJQcm9wcyB9IGZyb20gJy4vdHlwZXMnO1xuXG5jb25zdCBwYWRkaW5nID0gKCB7IHBhZGRpbmdTaXplID0gJ3NtYWxsJyB9OiBEcm9wZG93bkNvbnRlbnRXcmFwcGVyUHJvcHMgKSA9PiB7XG5cdGlmICggcGFkZGluZ1NpemUgPT09ICdub25lJyApIHtcblx0XHRyZXR1cm47XG5cdH1cblxuXHRjb25zdCBwYWRkaW5nVmFsdWVzID0ge1xuXHRcdHNtYWxsOiBzcGFjZSggMiApLFxuXHRcdG1lZGl1bTogc3BhY2UoIDQgKSxcblx0fTtcblxuXHRyZXR1cm4gY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdWYWx1ZXNbIHBhZGRpbmdTaXplIF0gfHwgcGFkZGluZ1ZhbHVlcy5zbWFsbCB9O1xuXHRgO1xufTtcblxuZXhwb3J0IGNvbnN0IERyb3Bkb3duQ29udGVudFdyYXBwZXJEaXYgPSBzdHlsZWQuZGl2PCBEcm9wZG93bkNvbnRlbnRXcmFwcGVyUHJvcHMgPmBcblx0Ly8gTmVnYXRpdmUgbWFyZ2luIHRvIHJlc2V0IChvZmZzZXQpIHRoZSBkZWZhdWx0IHBhZGRpbmcgb24gLmNvbXBvbmVudHMtcG9wb3Zlcl9fY29udGVudFxuXHRtYXJnaW4tbGVmdDogJHsgc3BhY2UoIC0yICkgfTtcblx0bWFyZ2luLXJpZ2h0OiAkeyBzcGFjZSggLTIgKSB9O1xuXHQmOmZpcnN0LW9mLXR5cGUge1xuXHRcdG1hcmdpbi10b3A6ICR7IHNwYWNlKCAtMiApIH07XG5cdH1cblx0JjpsYXN0LW9mLXR5cGUge1xuXHRcdG1hcmdpbi1ib3R0b206ICR7IHNwYWNlKCAtMiApIH07XG5cdH1cblxuXHQkeyBwYWRkaW5nIH07XG5gO1xuIl19 */"));

  // packages/components/build-module/dropdown/dropdown-content-wrapper.mjs
  var import_jsx_runtime145 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedDropdownContentWrapper(props, forwardedRef) {
    const {
      paddingSize = "small",
      ...derivedProps
    } = useContextSystem(props, "DropdownContentWrapper");
    return /* @__PURE__ */ (0, import_jsx_runtime145.jsx)(DropdownContentWrapperDiv, {
      ...derivedProps,
      paddingSize,
      ref: forwardedRef
    });
  }
  var DropdownContentWrapper = contextConnect(UnconnectedDropdownContentWrapper, "DropdownContentWrapper");
  var dropdown_content_wrapper_default = DropdownContentWrapper;

  // packages/components/build-module/color-palette/utils.mjs
  var import_i18n19 = __toESM(require_i18n(), 1);
  k([names_default, a11y_default]);
  var isSimpleCSSColor = (value) => {
    const valueIsCssVariable = /var\(/.test(value ?? "");
    const valueIsColorMix = /color-mix\(/.test(value ?? "");
    return !valueIsCssVariable && !valueIsColorMix;
  };
  var extractColorNameFromCurrentValue = (currentValue, colors = [], showMultiplePalettes = false, selectedSlug) => {
    if (!currentValue) {
      return "";
    }
    const currentValueIsSimpleColor = currentValue ? isSimpleCSSColor(currentValue) : false;
    const normalizedCurrentValue = currentValueIsSimpleColor ? w(currentValue).toHex() : currentValue;
    const colorPalettes = showMultiplePalettes ? colors : [{
      colors
    }];
    for (const {
      colors: paletteColors
    } of colorPalettes) {
      for (const {
        name: colorName,
        color: colorValue,
        slug
      } of paletteColors) {
        if (selectedSlug) {
          if (slug === selectedSlug) {
            return colorName;
          }
          continue;
        }
        const normalizedColorValue = currentValueIsSimpleColor ? w(colorValue).toHex() : colorValue;
        if (normalizedCurrentValue === normalizedColorValue) {
          return colorName;
        }
      }
    }
    return (0, import_i18n19.__)("Custom");
  };
  var isMultiplePaletteObject = (obj) => Array.isArray(obj.colors) && !("color" in obj);
  var isMultiplePaletteArray = (arr) => {
    return arr.length > 0 && arr.every((colorObj) => isMultiplePaletteObject(colorObj));
  };
  var normalizeColorValue = (value, element) => {
    if (!value || !element || isSimpleCSSColor(value)) {
      return value;
    }
    const {
      ownerDocument
    } = element;
    const {
      defaultView
    } = ownerDocument;
    const computedBackgroundColor = defaultView?.getComputedStyle(element).backgroundColor;
    return computedBackgroundColor ? w(computedBackgroundColor).toHex() : value;
  };

  // packages/components/build-module/color-palette/index.mjs
  var import_jsx_runtime146 = __toESM(require_jsx_runtime(), 1);
  k([names_default, a11y_default]);
  function SinglePalette({
    className: className2,
    clearColor,
    colors,
    onChange,
    value,
    selectedSlug,
    ...additionalProps
  }) {
    const colorOptions = (0, import_element80.useMemo)(() => {
      return colors.map(({
        color: color2,
        name,
        slug
      }, index2) => {
        const colordColor = w(color2);
        const isSelected2 = selectedSlug ? slug === selectedSlug : value === color2;
        return /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(circular_option_picker_default2.Option, {
          isSelected: isSelected2,
          selectedIconProps: isSelected2 ? {
            fill: colordColor.contrast() > colordColor.contrast("#000") ? "#fff" : "#000"
          } : {},
          tooltipText: name || // translators: %s: color hex code e.g: "#f00".
          (0, import_i18n20.sprintf)((0, import_i18n20.__)("Color code: %s"), color2),
          style: {
            backgroundColor: color2,
            color: color2
          },
          onClick: isSelected2 ? clearColor : () => onChange(color2, index2, slug)
        }, slug ?? `${color2}-${index2}`);
      });
    }, [colors, value, selectedSlug, onChange, clearColor]);
    return /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(circular_option_picker_default2.OptionGroup, {
      className: className2,
      options: colorOptions,
      ...additionalProps
    });
  }
  function MultiplePalettes({
    className: className2,
    clearColor,
    colors,
    onChange,
    value,
    selectedSlug,
    headingLevel
  }) {
    const instanceId = (0, import_compose34.useInstanceId)(MultiplePalettes, "color-palette");
    if (colors.length === 0) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(component_default18, {
      spacing: 3,
      className: className2,
      children: colors.map(({
        name,
        colors: colorPalette
      }, index2) => {
        const id3 = `${instanceId}-${index2}`;
        return /* @__PURE__ */ (0, import_jsx_runtime146.jsxs)(component_default18, {
          spacing: 2,
          children: [/* @__PURE__ */ (0, import_jsx_runtime146.jsx)(ColorHeading, {
            id: id3,
            level: headingLevel,
            children: name
          }), /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(SinglePalette, {
            clearColor,
            colors: colorPalette,
            onChange: (newColor, _colorIndex, slug) => onChange(newColor, index2, slug),
            value,
            selectedSlug,
            "aria-labelledby": id3
          })]
        }, index2);
      })
    });
  }
  function CustomColorPickerDropdown({
    isRenderedInSidebar,
    popoverProps: receivedPopoverProps,
    ...props
  }) {
    const popoverProps = (0, import_element80.useMemo)(() => ({
      shift: true,
      // Disabling resize as it would otherwise cause the popover to show
      // scrollbars while dragging the color picker's handle close to the
      // popover edge.
      resize: false,
      ...isRenderedInSidebar ? {
        // When in the sidebar: open to the left (stacking),
        // leaving the same gap as the parent popover.
        placement: "left-start",
        offset: 34
      } : {
        // Default behavior: open below the anchor
        placement: "bottom",
        offset: 8
      },
      ...receivedPopoverProps
    }), [isRenderedInSidebar, receivedPopoverProps]);
    return /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(dropdown_default, {
      contentClassName: "components-color-palette__custom-color-dropdown-content",
      popoverProps,
      ...props
    });
  }
  function UnforwardedColorPalette(props, forwardedRef) {
    const {
      asButtons,
      loop,
      clearable = true,
      colors = [],
      disableCustomColors = false,
      enableAlpha = false,
      onChange,
      value,
      selectedSlug,
      __experimentalIsRenderedInSidebar = false,
      headingLevel = 2,
      "aria-label": ariaLabel,
      "aria-labelledby": ariaLabelledby,
      ...additionalProps
    } = props;
    const [normalizedColorValue, setNormalizedColorValue] = (0, import_element80.useState)(value);
    const clearColor = (0, import_element80.useCallback)(() => onChange(void 0), [onChange]);
    const customColorPaletteCallbackRef = (0, import_element80.useCallback)((node2) => {
      setNormalizedColorValue(normalizeColorValue(value, node2));
    }, [value]);
    const hasMultipleColorOrigins = isMultiplePaletteArray(colors);
    const buttonLabelName = (0, import_element80.useMemo)(() => extractColorNameFromCurrentValue(value, colors, hasMultipleColorOrigins, selectedSlug), [value, colors, hasMultipleColorOrigins, selectedSlug]);
    const renderCustomColorPicker = () => /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(dropdown_content_wrapper_default, {
      paddingSize: "none",
      children: /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(LegacyAdapter, {
        color: normalizedColorValue,
        onChange: (color2) => onChange(color2),
        enableAlpha
      })
    });
    const isHex = value?.startsWith("#");
    const displayValue = value?.replace(/^var\((.+)\)$/, "$1");
    const customColorAccessibleLabel = !!displayValue ? (0, import_i18n20.sprintf)(
      // translators: 1: The name of the color e.g: "vivid red". 2: The color's hex code e.g: "#f00".
      (0, import_i18n20.__)('Custom color picker. The currently selected color is called "%1$s" and has a value of "%2$s".'),
      buttonLabelName,
      displayValue
    ) : (0, import_i18n20.__)("Custom color picker");
    const paletteCommonProps = {
      clearColor,
      onChange,
      value,
      selectedSlug
    };
    const actions = !!clearable && /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(circular_option_picker_default2.ButtonAction, {
      onClick: clearColor,
      accessibleWhenDisabled: true,
      disabled: !value,
      children: (0, import_i18n20.__)("Clear")
    });
    const {
      metaProps,
      labelProps
    } = getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby);
    if (disableCustomColors && colors.length === 0 && !actions) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime146.jsxs)(component_default18, {
      spacing: 3,
      ref: forwardedRef,
      ...additionalProps,
      children: [!disableCustomColors && /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(CustomColorPickerDropdown, {
        isRenderedInSidebar: __experimentalIsRenderedInSidebar,
        renderContent: renderCustomColorPicker,
        renderToggle: ({
          isOpen,
          onToggle
        }) => /* @__PURE__ */ (0, import_jsx_runtime146.jsxs)(component_default18, {
          className: "components-color-palette__custom-color-wrapper",
          spacing: 0,
          children: [/* @__PURE__ */ (0, import_jsx_runtime146.jsx)("button", {
            ref: customColorPaletteCallbackRef,
            className: "components-color-palette__custom-color-button",
            "aria-expanded": isOpen,
            "aria-haspopup": "true",
            onClick: onToggle,
            "aria-label": customColorAccessibleLabel,
            style: {
              background: value
            },
            type: "button"
          }), /* @__PURE__ */ (0, import_jsx_runtime146.jsxs)(component_default18, {
            className: "components-color-palette__custom-color-text-wrapper",
            spacing: 0.5,
            children: [/* @__PURE__ */ (0, import_jsx_runtime146.jsx)(component_default7, {
              className: "components-color-palette__custom-color-name",
              children: value ? buttonLabelName : (0, import_i18n20.__)("No color selected")
            }), /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(component_default7, {
              className: clsx_default("components-color-palette__custom-color-value", {
                "components-color-palette__custom-color-value--is-hex": isHex
              }),
              children: displayValue
            })]
          })]
        })
      }), (colors.length > 0 || actions) && /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(circular_option_picker_default2, {
        ...metaProps,
        ...labelProps,
        actions,
        options: hasMultipleColorOrigins ? /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(MultiplePalettes, {
          ...paletteCommonProps,
          headingLevel,
          colors,
          value
        }) : /* @__PURE__ */ (0, import_jsx_runtime146.jsx)(SinglePalette, {
          ...paletteCommonProps,
          colors,
          value
        })
      })]
    });
  }
  var ColorPalette = (0, import_element80.forwardRef)(UnforwardedColorPalette);
  ColorPalette.displayName = "ColorPalette";
  var color_palette_default = ColorPalette;

  // packages/components/build-module/border-control/border-control-dropdown/hook.mjs
  var import_element81 = __toESM(require_element(), 1);

  // packages/components/build-module/unit-control/styles/unit-control-styles.mjs
  var ValueInput = /* @__PURE__ */ createStyled(number_control_default, false ? {
    target: "e1bagdl32"
  } : {
    target: "e1bagdl32",
    label: "ValueInput"
  })("&&&{input{display:block;width:100%;}", BackdropUI, "{transition:box-shadow 0.1s linear;}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var baseUnitLabelStyles = ({
    selectSize
  }) => {
    const sizes = {
      small: /* @__PURE__ */ css("box-sizing:border-box;padding:2px 1px;width:20px;font-size:8px;line-height:1;letter-spacing:-0.5px;text-transform:uppercase;text-align-last:center;&:not( :disabled ){color:", COLORS.gray[800], ";}" + (false ? "" : ";label:small;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"),
      default: /* @__PURE__ */ css("box-sizing:border-box;min-width:24px;max-width:48px;height:24px;margin-inline-end:", space(2), ";padding:", space(1), ";font-size:13px;line-height:1;text-align-last:center;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;field-sizing:content;&:not( :disabled ){color:", COLORS.theme.accent, ";}" + (false ? "" : ";label:default;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */")
    };
    return sizes[selectSize];
  };
  var UnitLabel = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1bagdl31"
  } : {
    target: "e1bagdl31",
    label: "UnitLabel"
  })("&&&{pointer-events:none;", baseUnitLabelStyles, ";color:", COLORS.gray[900], ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var unitSelectSizes = ({
    selectSize = "default"
  }) => {
    const sizes = {
      small: /* @__PURE__ */ css("height:100%;border:1px solid transparent;transition:box-shadow 0.1s linear,border 0.1s linear;", rtl({
        borderTopLeftRadius: 0,
        borderBottomLeftRadius: 0
      })(), " &:not(:disabled):hover{background-color:", COLORS.gray[100], ";}&:focus{border:1px solid ", COLORS.ui.borderFocus, ";box-shadow:inset 0 0 0 ", config_values_default.borderWidth + " " + COLORS.ui.borderFocus, ";outline-offset:0;outline:2px solid transparent;z-index:1;}" + (false ? "" : ";label:small;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"),
      default: /* @__PURE__ */ css("display:flex;justify-content:center;align-items:center;&:where( :not( :disabled ) ):hover{box-shadow:0 0 0 ", config_values_default.borderWidth + " " + COLORS.ui.borderFocus, ";outline:", config_values_default.borderWidth, " solid transparent;}&:focus{box-shadow:0 0 0 ", config_values_default.borderWidthFocus + " " + COLORS.ui.borderFocus, ";outline:", config_values_default.borderWidthFocus, " solid transparent;}" + (false ? "" : ";label:default;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */")
    };
    return sizes[selectSize];
  };
  var UnitSelect = /* @__PURE__ */ createStyled("select", false ? {
    target: "e1bagdl30"
  } : {
    target: "e1bagdl30",
    label: "UnitSelect"
  })("&&&{appearance:none;background:transparent;border-radius:", config_values_default.radiusXSmall, ";border:none;display:block;outline:none;margin:0;min-height:auto;font-family:inherit;", baseUnitLabelStyles, ";", unitSelectSizes, ";&:not( :disabled ){cursor:pointer;}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // packages/components/build-module/border-control/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__12() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var focusBoxShadow = /* @__PURE__ */ css("box-shadow:inset ", config_values_default.controlBoxShadowFocus, ";" + (false ? "" : ";label:focusBoxShadow;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var borderControl = /* @__PURE__ */ css("border:0;padding:0;margin:0;", boxSizingReset, ";" + (false ? "" : ";label:borderControl;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var innerWrapper = () => /* @__PURE__ */ css(ValueInput, "{flex:1 1 40%;}&& ", UnitSelect, "{min-height:0;}" + (false ? "" : ";label:innerWrapper;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var wrapperWidth = /* @__PURE__ */ css(ValueInput, "{flex:0 0 auto;}" + (false ? "" : ";label:wrapperWidth;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var wrapperHeight = false ? {
    name: "1k18kha",
    styles: "height:40px"
  } : {
    name: "nqn9gd-wrapperHeight",
    styles: "height:40px;label:wrapperHeight;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__12
  };
  function getInnerWrapperStyles({
    hasWidth
  }) {
    return /* @__PURE__ */ css(innerWrapper(), hasWidth && wrapperWidth, wrapperHeight, false ? "" : ";label:getInnerWrapperStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  }
  var borderControlDropdown = /* @__PURE__ */ css("background:#fff;&&>button{aspect-ratio:1;padding:0;display:flex;align-items:center;justify-content:center;", rtl({
    borderRadius: `2px 0 0 2px`
  }, {
    borderRadius: `0 2px 2px 0`
  })(), " border:", config_values_default.borderWidth, " solid ", COLORS.ui.border, ";&:focus,&:hover:not( :disabled ){", focusBoxShadow, " border-color:", COLORS.ui.borderFocus, ";z-index:1;position:relative;}}" + (false ? "" : ";label:borderControlDropdown;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var colorIndicatorBorder = (border) => {
    const {
      color: color2,
      style: style2
    } = border || {};
    const fallbackColor = (
      // TODO: should use the `stroke-interactive-neutral` WPDS token when refactored to SCSS modules
      !!style2 && style2 !== "none" ? COLORS.gray[300] : void 0
    );
    return /* @__PURE__ */ css("border-style:", style2 === "none" ? "solid" : style2, ";border-color:", color2 || fallbackColor, ";" + (false ? "" : ";label:colorIndicatorBorder;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var colorIndicatorWrapper = (border) => {
    const {
      style: style2
    } = border || {};
    return /* @__PURE__ */ css("border-radius:", config_values_default.radiusFull, ";border:2px solid transparent;", style2 ? colorIndicatorBorder(border) : void 0, " width:24px;height:24px;padding:2px;&>span{height:", space(4), ";width:", space(4), ";background:linear-gradient(\n				-45deg,\n				transparent 48%,\n				rgb( 0 0 0 / 20% ) 48%,\n				rgb( 0 0 0 / 20% ) 52%,\n				transparent 52%\n			);}" + (false ? "" : ";label:colorIndicatorWrapper;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  };
  var swatchSize = 28;
  var swatchGap = 12;
  var borderControlPopoverControls = /* @__PURE__ */ css("width:", swatchSize * 6 + swatchGap * 5, "px;>div:first-of-type>", StyledLabel, "{margin-bottom:0;}&& ", StyledLabel, "+button:not( .has-text ){min-width:24px;padding:0;}" + (false ? "" : ";label:borderControlPopoverControls;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var borderControlPopoverContent = /* @__PURE__ */ css(false ? "" : ";label:borderControlPopoverContent;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var borderColorIndicator = /* @__PURE__ */ css(false ? "" : ";label:borderColorIndicator;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var resetButtonWrapper = false ? {
    name: "1ghe26v",
    styles: "display:flex;justify-content:flex-end;margin-top:12px"
  } : {
    name: "1a93xby-resetButtonWrapper",
    styles: "display:flex;justify-content:flex-end;margin-top:12px;label:resetButtonWrapper;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__12
  };
  var borderSlider = () => /* @__PURE__ */ css("flex:1 1 60%;", rtl({
    marginRight: space(3)
  })(), ";" + (false ? "" : ";label:borderSlider;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");

  // packages/components/build-module/unit-control/utils.mjs
  var import_i18n21 = __toESM(require_i18n(), 1);
  var allUnits = {
    px: {
      value: "px",
      label: "px",
      a11yLabel: (0, import_i18n21.__)("Pixels (px)"),
      step: 1
    },
    "%": {
      value: "%",
      label: "%",
      a11yLabel: (0, import_i18n21.__)("Percent (%)"),
      step: 0.1
    },
    em: {
      value: "em",
      label: "em",
      a11yLabel: (0, import_i18n21._x)("ems", "Relative to parent font size (em)"),
      step: 0.01
    },
    rem: {
      value: "rem",
      label: "rem",
      a11yLabel: (0, import_i18n21._x)("rems", "Relative to root font size (rem)"),
      step: 0.01
    },
    vw: {
      value: "vw",
      label: "vw",
      a11yLabel: (0, import_i18n21.__)("Viewport width (vw)"),
      step: 0.1
    },
    vh: {
      value: "vh",
      label: "vh",
      a11yLabel: (0, import_i18n21.__)("Viewport height (vh)"),
      step: 0.1
    },
    vmin: {
      value: "vmin",
      label: "vmin",
      a11yLabel: (0, import_i18n21.__)("Viewport smallest dimension (vmin)"),
      step: 0.1
    },
    vmax: {
      value: "vmax",
      label: "vmax",
      a11yLabel: (0, import_i18n21.__)("Viewport largest dimension (vmax)"),
      step: 0.1
    },
    ch: {
      value: "ch",
      label: "ch",
      a11yLabel: (0, import_i18n21.__)("Width of the zero (0) character (ch)"),
      step: 0.01
    },
    ex: {
      value: "ex",
      label: "ex",
      a11yLabel: (0, import_i18n21.__)("x-height of the font (ex)"),
      step: 0.01
    },
    cm: {
      value: "cm",
      label: "cm",
      a11yLabel: (0, import_i18n21.__)("Centimeters (cm)"),
      step: 1e-3
    },
    mm: {
      value: "mm",
      label: "mm",
      a11yLabel: (0, import_i18n21.__)("Millimeters (mm)"),
      step: 0.1
    },
    in: {
      value: "in",
      label: "in",
      a11yLabel: (0, import_i18n21.__)("Inches (in)"),
      step: 1e-3
    },
    pc: {
      value: "pc",
      label: "pc",
      a11yLabel: (0, import_i18n21.__)("Picas (pc)"),
      step: 1
    },
    pt: {
      value: "pt",
      label: "pt",
      a11yLabel: (0, import_i18n21.__)("Points (pt)"),
      step: 1
    },
    svw: {
      value: "svw",
      label: "svw",
      a11yLabel: (0, import_i18n21.__)("Small viewport width (svw)"),
      step: 0.1
    },
    svh: {
      value: "svh",
      label: "svh",
      a11yLabel: (0, import_i18n21.__)("Small viewport height (svh)"),
      step: 0.1
    },
    svi: {
      value: "svi",
      label: "svi",
      a11yLabel: (0, import_i18n21.__)("Small viewport width or height (svi)"),
      step: 0.1
    },
    svb: {
      value: "svb",
      label: "svb",
      a11yLabel: (0, import_i18n21.__)("Small viewport width or height (svb)"),
      step: 0.1
    },
    svmin: {
      value: "svmin",
      label: "svmin",
      a11yLabel: (0, import_i18n21.__)("Small viewport smallest dimension (svmin)"),
      step: 0.1
    },
    lvw: {
      value: "lvw",
      label: "lvw",
      a11yLabel: (0, import_i18n21.__)("Large viewport width (lvw)"),
      step: 0.1
    },
    lvh: {
      value: "lvh",
      label: "lvh",
      a11yLabel: (0, import_i18n21.__)("Large viewport height (lvh)"),
      step: 0.1
    },
    lvi: {
      value: "lvi",
      label: "lvi",
      a11yLabel: (0, import_i18n21.__)("Large viewport width or height (lvi)"),
      step: 0.1
    },
    lvb: {
      value: "lvb",
      label: "lvb",
      a11yLabel: (0, import_i18n21.__)("Large viewport width or height (lvb)"),
      step: 0.1
    },
    lvmin: {
      value: "lvmin",
      label: "lvmin",
      a11yLabel: (0, import_i18n21.__)("Large viewport smallest dimension (lvmin)"),
      step: 0.1
    },
    dvw: {
      value: "dvw",
      label: "dvw",
      a11yLabel: (0, import_i18n21.__)("Dynamic viewport width (dvw)"),
      step: 0.1
    },
    dvh: {
      value: "dvh",
      label: "dvh",
      a11yLabel: (0, import_i18n21.__)("Dynamic viewport height (dvh)"),
      step: 0.1
    },
    dvi: {
      value: "dvi",
      label: "dvi",
      a11yLabel: (0, import_i18n21.__)("Dynamic viewport width or height (dvi)"),
      step: 0.1
    },
    dvb: {
      value: "dvb",
      label: "dvb",
      a11yLabel: (0, import_i18n21.__)("Dynamic viewport width or height (dvb)"),
      step: 0.1
    },
    dvmin: {
      value: "dvmin",
      label: "dvmin",
      a11yLabel: (0, import_i18n21.__)("Dynamic viewport smallest dimension (dvmin)"),
      step: 0.1
    },
    dvmax: {
      value: "dvmax",
      label: "dvmax",
      a11yLabel: (0, import_i18n21.__)("Dynamic viewport largest dimension (dvmax)"),
      step: 0.1
    },
    svmax: {
      value: "svmax",
      label: "svmax",
      a11yLabel: (0, import_i18n21.__)("Small viewport largest dimension (svmax)"),
      step: 0.1
    },
    lvmax: {
      value: "lvmax",
      label: "lvmax",
      a11yLabel: (0, import_i18n21.__)("Large viewport largest dimension (lvmax)"),
      step: 0.1
    }
  };
  var ALL_CSS_UNITS = Object.values(allUnits);
  var CSS_UNITS = [allUnits.px, allUnits["%"], allUnits.em, allUnits.rem, allUnits.vw, allUnits.vh];
  var DEFAULT_UNIT = allUnits.px;
  function getParsedQuantityAndUnit(rawValue, fallbackUnit, allowedUnits) {
    const initialValue2 = fallbackUnit ? `${rawValue ?? ""}${fallbackUnit}` : rawValue;
    return parseQuantityAndUnitFromRawValue(initialValue2, allowedUnits);
  }
  function hasUnits(units) {
    return Array.isArray(units) && !!units.length;
  }
  function parseQuantityAndUnitFromRawValue(rawValue, allowedUnits = ALL_CSS_UNITS) {
    let trimmedValue;
    let quantityToReturn;
    if (typeof rawValue !== "undefined" || rawValue === null) {
      trimmedValue = `${rawValue}`.trim();
      const parsedQuantity = parseFloat(trimmedValue);
      quantityToReturn = !isFinite(parsedQuantity) ? void 0 : parsedQuantity;
    }
    const unitMatch = trimmedValue?.match(/[\d.\-\+]*\s*(.*)/);
    const matchedUnit = unitMatch?.[1]?.toLowerCase();
    let unitToReturn;
    if (hasUnits(allowedUnits)) {
      const match4 = allowedUnits.find((item2) => item2.value === matchedUnit);
      unitToReturn = match4?.value;
    } else {
      unitToReturn = DEFAULT_UNIT.value;
    }
    return [quantityToReturn, unitToReturn];
  }
  function getValidParsedQuantityAndUnit(rawValue, allowedUnits, fallbackQuantity, fallbackUnit) {
    const [parsedQuantity, parsedUnit] = parseQuantityAndUnitFromRawValue(rawValue, allowedUnits);
    const quantityToReturn = parsedQuantity ?? fallbackQuantity;
    let unitToReturn = parsedUnit || fallbackUnit;
    if (!unitToReturn && hasUnits(allowedUnits)) {
      unitToReturn = allowedUnits[0].value;
    }
    return [quantityToReturn, unitToReturn];
  }
  function filterUnitsWithSettings(allowedUnitValues = [], availableUnits) {
    return Array.isArray(availableUnits) ? availableUnits.filter((unit) => allowedUnitValues.includes(unit.value)) : [];
  }
  var useCustomUnits = ({
    units = ALL_CSS_UNITS,
    availableUnits = [],
    defaultValues
  }) => {
    const customUnitsToReturn = filterUnitsWithSettings(availableUnits, units);
    if (!defaultValues) {
      return customUnitsToReturn;
    }
    return customUnitsToReturn.map((unit) => {
      const [defaultValue2] = defaultValues[unit.value] ? parseQuantityAndUnitFromRawValue(defaultValues[unit.value]) : [];
      return {
        ...unit,
        default: defaultValue2
      };
    });
  };
  function getUnitsWithCurrentUnit(rawValue, legacyUnit, units = ALL_CSS_UNITS) {
    const unitsToReturn = Array.isArray(units) ? [...units] : [];
    const [, currentUnit] = getParsedQuantityAndUnit(rawValue, legacyUnit, ALL_CSS_UNITS);
    if (currentUnit && !unitsToReturn.some((unit) => unit.value === currentUnit)) {
      if (allUnits[currentUnit]) {
        unitsToReturn.unshift(allUnits[currentUnit]);
      }
    }
    return unitsToReturn;
  }

  // packages/components/build-module/border-control/border-control-dropdown/hook.mjs
  function useBorderControlDropdown(props) {
    const {
      border,
      className: className2,
      colors = [],
      enableAlpha = false,
      enableStyle = true,
      onChange,
      previousStyleSelection,
      __experimentalIsRenderedInSidebar = false,
      ...otherProps
    } = useContextSystem(props, "BorderControlDropdown");
    const [widthValue] = parseQuantityAndUnitFromRawValue(border?.width);
    const hasZeroWidth = widthValue === 0;
    const onColorChange = (color2) => {
      const style2 = border?.style === "none" ? previousStyleSelection : border?.style;
      const width = hasZeroWidth && !!color2 ? "1px" : border?.width;
      onChange({
        color: color2,
        style: style2,
        width
      });
    };
    const onStyleChange = (style2) => {
      const width = hasZeroWidth && !!style2 ? "1px" : border?.width;
      onChange({
        ...border,
        style: style2,
        width
      });
    };
    const onReset = () => {
      onChange({
        ...border,
        color: void 0,
        style: void 0
      });
    };
    const cx2 = useCx();
    const classes = (0, import_element81.useMemo)(() => {
      return cx2(borderControlDropdown, className2);
    }, [className2, cx2]);
    const indicatorClassName = (0, import_element81.useMemo)(() => {
      return cx2(borderColorIndicator);
    }, [cx2]);
    const indicatorWrapperClassName = (0, import_element81.useMemo)(() => {
      return cx2(colorIndicatorWrapper(border));
    }, [border, cx2]);
    const popoverControlsClassName = (0, import_element81.useMemo)(() => {
      return cx2(borderControlPopoverControls);
    }, [cx2]);
    const popoverContentClassName = (0, import_element81.useMemo)(() => {
      return cx2(borderControlPopoverContent);
    }, [cx2]);
    const resetButtonWrapperClassName = (0, import_element81.useMemo)(() => {
      return cx2(resetButtonWrapper);
    }, [cx2]);
    return {
      ...otherProps,
      border,
      className: classes,
      colors,
      enableAlpha,
      enableStyle,
      indicatorClassName,
      indicatorWrapperClassName,
      onColorChange,
      onStyleChange,
      onReset,
      popoverContentClassName,
      popoverControlsClassName,
      resetButtonWrapperClassName,
      __experimentalIsRenderedInSidebar
    };
  }

  // packages/components/build-module/border-control/border-control-dropdown/component.mjs
  var import_jsx_runtime147 = __toESM(require_jsx_runtime(), 1);
  var getAriaLabelColorValue = (colorValue) => {
    return colorValue.replace(/^var\((.+)\)$/, "$1");
  };
  var getColorObject = (colorValue, colors) => {
    if (!colorValue || !colors) {
      return;
    }
    if (isMultiplePaletteArray(colors)) {
      let matchedColor;
      colors.some((origin) => origin.colors.some((color2) => {
        if (color2.color === colorValue) {
          matchedColor = color2;
          return true;
        }
        return false;
      }));
      return matchedColor;
    }
    return colors.find((color2) => color2.color === colorValue);
  };
  var getToggleAriaLabel = (colorValue, colorObject, style2, isStyleEnabled) => {
    if (isStyleEnabled) {
      if (colorObject) {
        const ariaLabelValue = getAriaLabelColorValue(colorObject.color);
        return style2 ? (0, import_i18n22.sprintf)(
          // translators: 1: The name of the color e.g. "vivid red". 2: The color's hex code e.g.: "#f00:". 3: The current border style selection e.g. "solid".
          (0, import_i18n22.__)('Border color and style picker. The currently selected color is called "%1$s" and has a value of "%2$s". The currently selected style is "%3$s".'),
          colorObject.name,
          ariaLabelValue,
          style2
        ) : (0, import_i18n22.sprintf)(
          // translators: 1: The name of the color e.g. "vivid red". 2: The color's hex code e.g.: "#f00:".
          (0, import_i18n22.__)('Border color and style picker. The currently selected color is called "%1$s" and has a value of "%2$s".'),
          colorObject.name,
          ariaLabelValue
        );
      }
      if (colorValue) {
        const ariaLabelValue = getAriaLabelColorValue(colorValue);
        return style2 ? (0, import_i18n22.sprintf)(
          // translators: 1: The color's hex code e.g.: "#f00:". 2: The current border style selection e.g. "solid".
          (0, import_i18n22.__)('Border color and style picker. The currently selected color has a value of "%1$s". The currently selected style is "%2$s".'),
          ariaLabelValue,
          style2
        ) : (0, import_i18n22.sprintf)(
          // translators: %s: The color's hex code e.g: "#f00".
          (0, import_i18n22.__)('Border color and style picker. The currently selected color has a value of "%s".'),
          ariaLabelValue
        );
      }
      return (0, import_i18n22.__)("Border color and style picker.");
    }
    if (colorObject) {
      return (0, import_i18n22.sprintf)(
        // translators: 1: The name of the color e.g. "vivid red". 2: The color's hex code e.g: "#f00".
        (0, import_i18n22.__)('Border color picker. The currently selected color is called "%1$s" and has a value of "%2$s".'),
        colorObject.name,
        getAriaLabelColorValue(colorObject.color)
      );
    }
    if (colorValue) {
      return (0, import_i18n22.sprintf)(
        // translators: %s: The color's hex code e.g: "#f00".
        (0, import_i18n22.__)('Border color picker. The currently selected color has a value of "%s".'),
        getAriaLabelColorValue(colorValue)
      );
    }
    return (0, import_i18n22.__)("Border color picker.");
  };
  var BorderControlDropdown = (props, forwardedRef) => {
    const {
      __experimentalIsRenderedInSidebar,
      border,
      colors,
      disableCustomColors,
      enableAlpha,
      enableStyle,
      indicatorClassName,
      indicatorWrapperClassName,
      isStyleSettable,
      onReset,
      onColorChange,
      onStyleChange,
      popoverContentClassName,
      popoverControlsClassName,
      resetButtonWrapperClassName,
      __unstablePopoverProps,
      ...otherProps
    } = useBorderControlDropdown(props);
    const {
      color: color2,
      style: style2
    } = border || {};
    const colorObject = getColorObject(color2, colors);
    const toggleAriaLabel = getToggleAriaLabel(color2, colorObject, style2, enableStyle);
    const enableResetButton = color2 || style2 && style2 !== "none";
    const dropdownPosition = __experimentalIsRenderedInSidebar ? "bottom left" : void 0;
    const renderToggle = ({
      onToggle
    }) => /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(button_default, {
      onClick: onToggle,
      variant: "tertiary",
      "aria-label": toggleAriaLabel,
      tooltipPosition: dropdownPosition,
      label: (0, import_i18n22.__)("Border color and style picker"),
      showTooltip: true,
      __next40pxDefaultSize: true,
      children: /* @__PURE__ */ (0, import_jsx_runtime147.jsx)("span", {
        className: indicatorWrapperClassName,
        children: /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(color_indicator_default, {
          className: indicatorClassName,
          colorValue: color2
        })
      })
    });
    const renderContent = () => /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(import_jsx_runtime147.Fragment, {
      children: /* @__PURE__ */ (0, import_jsx_runtime147.jsxs)(dropdown_content_wrapper_default, {
        paddingSize: "medium",
        children: [/* @__PURE__ */ (0, import_jsx_runtime147.jsxs)(component_default18, {
          className: popoverControlsClassName,
          spacing: 6,
          children: [/* @__PURE__ */ (0, import_jsx_runtime147.jsx)(color_palette_default, {
            className: popoverContentClassName,
            value: color2,
            onChange: onColorChange,
            colors,
            disableCustomColors,
            __experimentalIsRenderedInSidebar,
            clearable: false,
            enableAlpha
          }), enableStyle && isStyleSettable && /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(component_default16, {
            label: (0, import_i18n22.__)("Style"),
            value: style2,
            onChange: onStyleChange
          })]
        }), /* @__PURE__ */ (0, import_jsx_runtime147.jsx)("div", {
          className: resetButtonWrapperClassName,
          children: /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(button_default, {
            variant: "tertiary",
            onClick: () => {
              onReset();
            },
            disabled: !enableResetButton,
            accessibleWhenDisabled: true,
            __next40pxDefaultSize: true,
            children: (0, import_i18n22.__)("Reset")
          })
        })]
      })
    });
    return /* @__PURE__ */ (0, import_jsx_runtime147.jsx)(dropdown_default, {
      renderToggle,
      renderContent,
      popoverProps: {
        ...__unstablePopoverProps
      },
      ...otherProps,
      ref: forwardedRef
    });
  };
  var ConnectedBorderControlDropdown = contextConnect(BorderControlDropdown, "BorderControlDropdown");
  var component_default20 = ConnectedBorderControlDropdown;

  // packages/components/build-module/unit-control/index.mjs
  var import_deprecated7 = __toESM(require_deprecated(), 1);
  var import_element83 = __toESM(require_element(), 1);
  var import_i18n23 = __toESM(require_i18n(), 1);

  // packages/components/build-module/unit-control/unit-select-control.mjs
  var import_element82 = __toESM(require_element(), 1);
  var import_jsx_runtime148 = __toESM(require_jsx_runtime(), 1);
  function UnitSelectControl({
    className: className2,
    isUnitSelectTabbable: isTabbable2 = true,
    onChange,
    size: size4 = "default",
    unit = "px",
    units = CSS_UNITS,
    ...props
  }, ref) {
    if (!hasUnits(units) || units?.length === 1) {
      return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(UnitLabel, {
        className: "components-unit-control__unit-label",
        selectSize: size4,
        children: unit
      });
    }
    const handleOnChange = (event) => {
      const {
        value: unitValue
      } = event.target;
      const data = units.find((option) => option.value === unitValue);
      onChange?.(unitValue, {
        event,
        data
      });
    };
    const classes = clsx_default("components-unit-control__select", className2);
    return /* @__PURE__ */ (0, import_jsx_runtime148.jsx)(UnitSelect, {
      ref,
      className: classes,
      onChange: handleOnChange,
      selectSize: size4,
      tabIndex: isTabbable2 ? void 0 : -1,
      value: unit,
      ...props,
      children: units.map((option) => /* @__PURE__ */ (0, import_jsx_runtime148.jsx)("option", {
        value: option.value,
        children: option.label
      }, option.value))
    });
  }
  var unit_select_control_default = (0, import_element82.forwardRef)(UnitSelectControl);

  // packages/components/build-module/unit-control/index.mjs
  var import_jsx_runtime149 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedUnitControl(unitControlProps, forwardedRef) {
    const {
      __unstableStateReducer,
      autoComplete = "off",
      // @ts-expect-error Ensure that children is omitted from restProps
      children,
      className: className2,
      disabled = false,
      disableUnits = false,
      isPressEnterToChange = false,
      isResetValueOnUnitChange = false,
      isUnitSelectTabbable = true,
      label,
      onChange: onChangeProp,
      onUnitChange,
      size: size4 = "default",
      unit: unitProp,
      units: unitsProp = CSS_UNITS,
      value: valueProp,
      onFocus: onFocusProp,
      ...props
    } = unitControlProps;
    if ("unit" in unitControlProps) {
      (0, import_deprecated7.default)("UnitControl unit prop", {
        since: "5.6",
        hint: "The unit should be provided within the `value` prop.",
        version: "6.2"
      });
    }
    const nonNullValueProp = valueProp ?? void 0;
    const [units, reFirstCharacterOfUnits] = (0, import_element83.useMemo)(() => {
      const list = getUnitsWithCurrentUnit(nonNullValueProp, unitProp, unitsProp);
      const [{
        value: firstUnitValue = ""
      } = {}, ...rest] = list;
      const firstCharacters = rest.reduce((carry, {
        value
      }) => {
        const first = escapeRegExp(value?.substring(0, 1) || "");
        return carry.includes(first) ? carry : `${carry}|${first}`;
      }, escapeRegExp(firstUnitValue.substring(0, 1)));
      return [list, new RegExp(`^(?:${firstCharacters})$`, "i")];
    }, [nonNullValueProp, unitProp, unitsProp]);
    const [parsedQuantity, parsedUnit] = getParsedQuantityAndUnit(nonNullValueProp, unitProp, units);
    const [unit, setUnit] = use_controlled_state_default(units.length === 1 ? units[0].value : unitProp, {
      initial: parsedUnit,
      fallback: ""
    });
    (0, import_element83.useEffect)(() => {
      if (parsedUnit !== void 0) {
        setUnit(parsedUnit);
      }
    }, [parsedUnit, setUnit]);
    const classes = clsx_default(
      "components-unit-control",
      // This class is added for legacy purposes to maintain it on the outer
      // wrapper. See: https://github.com/WordPress/gutenberg/pull/45139
      "components-unit-control-wrapper",
      className2
    );
    const handleOnQuantityChange = (nextQuantityValue, changeProps) => {
      if (nextQuantityValue === "" || typeof nextQuantityValue === "undefined" || nextQuantityValue === null) {
        onChangeProp?.("", changeProps);
        return;
      }
      const onChangeValue = getValidParsedQuantityAndUnit(nextQuantityValue, units, parsedQuantity, unit).join("");
      onChangeProp?.(onChangeValue, changeProps);
    };
    const handleOnUnitChange = (nextUnitValue, changeProps) => {
      const {
        data
      } = changeProps;
      let nextValue = `${parsedQuantity ?? ""}${nextUnitValue}`;
      if (isResetValueOnUnitChange && data?.default !== void 0) {
        nextValue = `${data.default}${nextUnitValue}`;
      }
      onChangeProp?.(nextValue, changeProps);
      onUnitChange?.(nextUnitValue, changeProps);
      setUnit(nextUnitValue);
    };
    let handleOnKeyDown;
    if (!disableUnits && isUnitSelectTabbable && units.length) {
      handleOnKeyDown = (event) => {
        props.onKeyDown?.(event);
        if (!event.metaKey && !event.ctrlKey && reFirstCharacterOfUnits.test(event.key)) {
          refInputSuffix.current?.focus();
        }
      };
    }
    const refInputSuffix = (0, import_element83.useRef)(null);
    const inputSuffix = !disableUnits ? /* @__PURE__ */ (0, import_jsx_runtime149.jsx)(unit_select_control_default, {
      ref: refInputSuffix,
      "aria-label": (0, import_i18n23.__)("Select unit"),
      disabled,
      isUnitSelectTabbable,
      onChange: handleOnUnitChange,
      size: ["small", "compact"].includes(size4) ? "small" : "default",
      unit,
      units,
      onFocus: onFocusProp,
      onBlur: unitControlProps.onBlur
    }) : null;
    let step = props.step;
    if (!step && units) {
      const activeUnit = units.find((option) => option.value === unit);
      step = activeUnit?.step ?? 1;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime149.jsx)(ValueInput, {
      ...props,
      autoComplete,
      className: classes,
      disabled,
      spinControls: "none",
      isPressEnterToChange,
      label,
      onKeyDown: handleOnKeyDown,
      onChange: handleOnQuantityChange,
      ref: forwardedRef,
      size: size4,
      suffix: inputSuffix,
      type: isPressEnterToChange ? "text" : "number",
      value: parsedQuantity ?? "",
      step,
      onFocus: onFocusProp,
      __unstableStateReducer
    });
  }
  var UnitControl = (0, import_element83.forwardRef)(UnforwardedUnitControl);
  UnitControl.displayName = "UnitControl";
  var unit_control_default = UnitControl;

  // packages/components/build-module/border-control/border-control/hook.mjs
  var import_element84 = __toESM(require_element(), 1);
  var isValidBorder = (border) => {
    const hasWidth = border?.width !== void 0 && border.width !== "";
    const hasColor = border?.color !== void 0;
    return hasWidth || hasColor;
  };
  function useBorderControl(props) {
    const {
      className: className2,
      colors = [],
      isCompact,
      onChange,
      enableAlpha = true,
      enableStyle = true,
      shouldSanitizeBorder = true,
      value: border,
      width,
      __experimentalIsRenderedInSidebar = false,
      // Deprecated props, no longer used.
      size: _size,
      __next40pxDefaultSize: _next40pxDefaultSize,
      ...otherProps
    } = useContextSystem(props, "BorderControl");
    const [widthValue, originalWidthUnit] = parseQuantityAndUnitFromRawValue(border?.width);
    const widthUnit = originalWidthUnit || "px";
    const hadPreviousZeroWidth = widthValue === 0;
    const [colorSelection, setColorSelection] = (0, import_element84.useState)();
    const [styleSelection, setStyleSelection] = (0, import_element84.useState)();
    const isStyleSettable = shouldSanitizeBorder ? isValidBorder(border) : true;
    const onBorderChange = (0, import_element84.useCallback)((newBorder) => {
      if (shouldSanitizeBorder && !isValidBorder(newBorder)) {
        onChange(void 0);
        return;
      }
      onChange(newBorder);
    }, [onChange, shouldSanitizeBorder]);
    const onWidthChange = (0, import_element84.useCallback)((newWidth) => {
      const newWidthValue = newWidth === "" ? void 0 : newWidth;
      const [parsedValue] = parseQuantityAndUnitFromRawValue(newWidth);
      const hasZeroWidth = parsedValue === 0;
      const updatedBorder = {
        ...border,
        width: newWidthValue
      };
      if (hasZeroWidth && !hadPreviousZeroWidth) {
        setColorSelection(border?.color);
        setStyleSelection(border?.style);
        updatedBorder.color = void 0;
        updatedBorder.style = "none";
      }
      if (!hasZeroWidth && hadPreviousZeroWidth) {
        if (updatedBorder.color === void 0) {
          updatedBorder.color = colorSelection;
        }
        if (updatedBorder.style === "none") {
          updatedBorder.style = styleSelection;
        }
      }
      onBorderChange(updatedBorder);
    }, [border, hadPreviousZeroWidth, colorSelection, styleSelection, onBorderChange]);
    const onSliderChange = (0, import_element84.useCallback)((value) => {
      onWidthChange(`${value}${widthUnit}`);
    }, [onWidthChange, widthUnit]);
    const cx2 = useCx();
    const classes = (0, import_element84.useMemo)(() => {
      return cx2(borderControl, className2);
    }, [className2, cx2]);
    let wrapperWidth2 = width;
    if (isCompact) {
      wrapperWidth2 = "116px";
    }
    const innerWrapperClassName = (0, import_element84.useMemo)(() => {
      return cx2(getInnerWrapperStyles({
        hasWidth: !!wrapperWidth2
      }));
    }, [wrapperWidth2, cx2]);
    const sliderClassName = (0, import_element84.useMemo)(() => {
      return cx2(borderSlider());
    }, [cx2]);
    return {
      ...otherProps,
      className: classes,
      colors,
      enableAlpha,
      enableStyle,
      innerWrapperClassName,
      inputWidth: wrapperWidth2,
      isStyleSettable,
      onBorderChange,
      onSliderChange,
      onWidthChange,
      previousStyleSelection: styleSelection,
      sliderClassName,
      value: border,
      widthUnit,
      widthValue,
      __experimentalIsRenderedInSidebar
    };
  }

  // packages/components/build-module/border-control/border-control/component.mjs
  var import_jsx_runtime150 = __toESM(require_jsx_runtime(), 1);
  var BorderLabel = (props) => {
    const {
      label,
      hideLabelFromVision
    } = props;
    if (!label) {
      return null;
    }
    return hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(component_default2, {
      as: "legend",
      children: label
    }) : /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(StyledLabel, {
      as: "legend",
      children: label
    });
  };
  var UnconnectedBorderControl = (props, forwardedRef) => {
    const {
      colors,
      disableCustomColors,
      disableUnits,
      enableAlpha,
      enableStyle,
      hideLabelFromVision,
      innerWrapperClassName,
      inputWidth,
      isStyleSettable,
      label,
      onBorderChange,
      onSliderChange,
      onWidthChange,
      placeholder,
      __unstablePopoverProps,
      previousStyleSelection,
      showDropdownHeader,
      sliderClassName,
      value: border,
      widthUnit,
      widthValue,
      withSlider,
      __experimentalIsRenderedInSidebar,
      ...otherProps
    } = useBorderControl(props);
    return /* @__PURE__ */ (0, import_jsx_runtime150.jsxs)(component_default, {
      as: "fieldset",
      ...otherProps,
      ref: forwardedRef,
      children: [/* @__PURE__ */ (0, import_jsx_runtime150.jsx)(BorderLabel, {
        label,
        hideLabelFromVision
      }), /* @__PURE__ */ (0, import_jsx_runtime150.jsxs)(component_default9, {
        spacing: 4,
        className: innerWrapperClassName,
        children: [/* @__PURE__ */ (0, import_jsx_runtime150.jsx)(unit_control_default, {
          prefix: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(component_default6, {
            marginRight: 1,
            marginBottom: 0,
            children: /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(component_default20, {
              border,
              colors,
              __unstablePopoverProps,
              disableCustomColors,
              enableAlpha,
              enableStyle,
              isStyleSettable,
              onChange: onBorderChange,
              previousStyleSelection,
              __experimentalIsRenderedInSidebar
            })
          }),
          label: (0, import_i18n24.__)("Border width"),
          hideLabelFromVision: true,
          min: 0,
          onChange: onWidthChange,
          value: border?.width || "",
          placeholder,
          disableUnits,
          __unstableInputWidth: inputWidth
        }), withSlider && /* @__PURE__ */ (0, import_jsx_runtime150.jsx)(range_control_default, {
          label: (0, import_i18n24.__)("Border width"),
          hideLabelFromVision: true,
          className: sliderClassName,
          initialPosition: 0,
          max: 100,
          min: 0,
          onChange: onSliderChange,
          step: ["px", "%"].includes(widthUnit) ? 1 : 0.1,
          value: widthValue || void 0,
          withInputField: false
        })]
      })]
    });
  };
  var BorderControl = contextConnect(UnconnectedBorderControl, "BorderControl");
  var component_default21 = BorderControl;

  // packages/components/build-module/grid/hook.mjs
  var import_element85 = __toESM(require_element(), 1);

  // packages/components/build-module/grid/utils.mjs
  var ALIGNMENTS2 = {
    bottom: {
      alignItems: "flex-end",
      justifyContent: "center"
    },
    bottomLeft: {
      alignItems: "flex-start",
      justifyContent: "flex-end"
    },
    bottomRight: {
      alignItems: "flex-end",
      justifyContent: "flex-end"
    },
    center: {
      alignItems: "center",
      justifyContent: "center"
    },
    spaced: {
      alignItems: "center",
      justifyContent: "space-between"
    },
    left: {
      alignItems: "center",
      justifyContent: "flex-start"
    },
    right: {
      alignItems: "center",
      justifyContent: "flex-end"
    },
    stretch: {
      alignItems: "stretch"
    },
    top: {
      alignItems: "flex-start",
      justifyContent: "center"
    },
    topLeft: {
      alignItems: "flex-start",
      justifyContent: "flex-start"
    },
    topRight: {
      alignItems: "flex-start",
      justifyContent: "flex-end"
    }
  };
  function getAlignmentProps2(alignment) {
    const alignmentProps = alignment ? ALIGNMENTS2[alignment] : {};
    return alignmentProps;
  }

  // packages/components/build-module/grid/hook.mjs
  function useGrid(props) {
    const {
      align,
      alignment,
      className: className2,
      columnGap,
      columns = 2,
      gap = 3,
      isInline = false,
      justify,
      rowGap,
      rows,
      templateColumns,
      templateRows,
      ...otherProps
    } = useContextSystem(props, "Grid");
    const columnsAsArray = Array.isArray(columns) ? columns : [columns];
    const column2 = useResponsiveValue(columnsAsArray);
    const rowsAsArray = Array.isArray(rows) ? rows : [rows];
    const row = useResponsiveValue(rowsAsArray);
    const gridTemplateColumns = templateColumns || !!columns && `repeat( ${column2}, 1fr )`;
    const gridTemplateRows = templateRows || !!rows && `repeat( ${row}, 1fr )`;
    const cx2 = useCx();
    const classes = (0, import_element85.useMemo)(() => {
      const alignmentProps = getAlignmentProps2(alignment);
      const gridClasses = /* @__PURE__ */ css({
        alignItems: align,
        display: isInline ? "inline-grid" : "grid",
        gap: `calc( ${config_values_default.gridBase} * ${gap} )`,
        gridTemplateColumns: gridTemplateColumns || void 0,
        gridTemplateRows: gridTemplateRows || void 0,
        gridRowGap: rowGap,
        gridColumnGap: columnGap,
        justifyContent: justify,
        verticalAlign: isInline ? "middle" : void 0,
        ...alignmentProps
      }, false ? "" : ";label:gridClasses;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
      return cx2(gridClasses, className2);
    }, [align, alignment, className2, columnGap, cx2, gap, gridTemplateColumns, gridTemplateRows, isInline, justify, rowGap]);
    return {
      ...otherProps,
      className: classes
    };
  }

  // packages/components/build-module/grid/component.mjs
  var import_jsx_runtime151 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedGrid(props, forwardedRef) {
    const gridProps = useGrid(props);
    return /* @__PURE__ */ (0, import_jsx_runtime151.jsx)(component_default, {
      ...gridProps,
      ref: forwardedRef
    });
  }
  var Grid = contextConnect(UnconnectedGrid, "Grid");
  var component_default22 = Grid;

  // packages/components/build-module/border-box-control/border-box-control-split-controls/hook.mjs
  var import_element86 = __toESM(require_element(), 1);
  function useBorderBoxControlSplitControls(props) {
    const {
      className: className2,
      colors = [],
      enableAlpha = false,
      enableStyle = true,
      __experimentalIsRenderedInSidebar = false,
      ...otherProps
    } = useContextSystem(props, "BorderBoxControlSplitControls");
    const cx2 = useCx();
    const classes = (0, import_element86.useMemo)(() => {
      return cx2(borderBoxControlSplitControls, className2);
    }, [cx2, className2]);
    const centeredClassName = (0, import_element86.useMemo)(() => {
      return cx2(centeredBorderControl, className2);
    }, [cx2, className2]);
    const rightAlignedClassName = (0, import_element86.useMemo)(() => {
      return cx2(rightBorderControl(), className2);
    }, [cx2, className2]);
    return {
      ...otherProps,
      centeredClassName,
      className: classes,
      colors,
      enableAlpha,
      enableStyle,
      rightAlignedClassName,
      __experimentalIsRenderedInSidebar
    };
  }

  // packages/components/build-module/border-box-control/border-box-control-split-controls/component.mjs
  var import_jsx_runtime152 = __toESM(require_jsx_runtime(), 1);
  var BorderBoxControlSplitControls = (props, forwardedRef) => {
    const {
      centeredClassName,
      colors,
      disableCustomColors,
      enableAlpha,
      enableStyle,
      onChange,
      popoverPlacement,
      popoverOffset,
      rightAlignedClassName,
      value,
      __experimentalIsRenderedInSidebar,
      ...otherProps
    } = useBorderBoxControlSplitControls(props);
    const [popoverAnchor, setPopoverAnchor] = (0, import_element87.useState)(null);
    const popoverProps = (0, import_element87.useMemo)(() => popoverPlacement ? {
      placement: popoverPlacement,
      offset: popoverOffset,
      anchor: popoverAnchor,
      shift: true
    } : void 0, [popoverPlacement, popoverOffset, popoverAnchor]);
    const sharedBorderControlProps = {
      colors,
      disableCustomColors,
      enableAlpha,
      enableStyle,
      isCompact: true,
      __experimentalIsRenderedInSidebar
    };
    const mergedRef = (0, import_compose35.useMergeRefs)([setPopoverAnchor, forwardedRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime152.jsxs)(component_default22, {
      ...otherProps,
      ref: mergedRef,
      gap: 3,
      children: [/* @__PURE__ */ (0, import_jsx_runtime152.jsx)(component_default11, {
        value
      }), /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(component_default21, {
        className: centeredClassName,
        hideLabelFromVision: true,
        label: (0, import_i18n25.__)("Top border"),
        onChange: (newBorder) => onChange(newBorder, "top"),
        __unstablePopoverProps: popoverProps,
        value: value?.top,
        ...sharedBorderControlProps
      }), /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(component_default21, {
        hideLabelFromVision: true,
        label: (0, import_i18n25.__)("Left border"),
        onChange: (newBorder) => onChange(newBorder, "left"),
        __unstablePopoverProps: popoverProps,
        value: value?.left,
        ...sharedBorderControlProps
      }), /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(component_default21, {
        className: rightAlignedClassName,
        hideLabelFromVision: true,
        label: (0, import_i18n25.__)("Right border"),
        onChange: (newBorder) => onChange(newBorder, "right"),
        __unstablePopoverProps: popoverProps,
        value: value?.right,
        ...sharedBorderControlProps
      }), /* @__PURE__ */ (0, import_jsx_runtime152.jsx)(component_default21, {
        className: centeredClassName,
        hideLabelFromVision: true,
        label: (0, import_i18n25.__)("Bottom border"),
        onChange: (newBorder) => onChange(newBorder, "bottom"),
        __unstablePopoverProps: popoverProps,
        value: value?.bottom,
        ...sharedBorderControlProps
      })]
    });
  };
  var ConnectedBorderBoxControlSplitControls = contextConnect(BorderBoxControlSplitControls, "BorderBoxControlSplitControls");
  var component_default23 = ConnectedBorderBoxControlSplitControls;

  // packages/components/build-module/border-box-control/border-box-control/hook.mjs
  var import_element88 = __toESM(require_element(), 1);

  // packages/components/build-module/utils/unit-values.mjs
  var UNITED_VALUE_REGEX = /^([\d.\-+]*)\s*(fr|cm|mm|Q|in|pc|pt|px|em|ex|ch|rem|lh|vw|vh|vmin|vmax|%|cap|ic|rlh|vi|vb|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx|svw|lvw|dvw|svh|lvh|dvh|svi|lvi|dvi|svb|lvb|dvb|svmin|lvmin|dvmin|svmax|lvmax|dvmax)?$/;
  function parseCSSUnitValue(toParse) {
    const value = toParse.trim();
    const matched = value.match(UNITED_VALUE_REGEX);
    if (!matched) {
      return [void 0, void 0];
    }
    const [, num, unit] = matched;
    let numParsed = parseFloat(num);
    numParsed = Number.isNaN(numParsed) ? void 0 : numParsed;
    return [numParsed, unit];
  }

  // packages/components/build-module/border-box-control/utils.mjs
  var sides2 = ["top", "right", "bottom", "left"];
  var borderProps = ["color", "style", "width"];
  var isEmptyBorder = (border) => {
    if (!border) {
      return true;
    }
    return !borderProps.some((prop) => border[prop] !== void 0);
  };
  var isDefinedBorder = (border) => {
    if (!border) {
      return false;
    }
    if (hasSplitBorders(border)) {
      const allSidesEmpty = sides2.every((side) => isEmptyBorder(border[side]));
      return !allSidesEmpty;
    }
    return !isEmptyBorder(border);
  };
  var isCompleteBorder = (border) => {
    if (!border) {
      return false;
    }
    return borderProps.every((prop) => border[prop] !== void 0);
  };
  var hasSplitBorders = (border = {}) => {
    return Object.keys(border).some((side) => sides2.indexOf(side) !== -1);
  };
  var hasMixedBorders = (borders2) => {
    if (!hasSplitBorders(borders2)) {
      return false;
    }
    const shorthandBorders = sides2.map((side) => getShorthandBorderStyle(borders2?.[side]));
    return !shorthandBorders.every((border) => border === shorthandBorders[0]);
  };
  var getSplitBorders = (border) => {
    if (!border || isEmptyBorder(border)) {
      return void 0;
    }
    return {
      top: border,
      right: border,
      bottom: border,
      left: border
    };
  };
  var getBorderDiff = (original, updated) => {
    const diff = {};
    if (original.color !== updated.color) {
      diff.color = updated.color;
    }
    if (original.style !== updated.style) {
      diff.style = updated.style;
    }
    if (original.width !== updated.width) {
      diff.width = updated.width;
    }
    return diff;
  };
  var getCommonBorder = (borders2) => {
    if (!borders2) {
      return void 0;
    }
    const colors = [];
    const styles3 = [];
    const widths = [];
    sides2.forEach((side) => {
      colors.push(borders2[side]?.color);
      styles3.push(borders2[side]?.style);
      widths.push(borders2[side]?.width);
    });
    const allColorsMatch = colors.every((value) => value === colors[0]);
    const allStylesMatch = styles3.every((value) => value === styles3[0]);
    const allWidthsMatch = widths.every((value) => value === widths[0]);
    return {
      color: allColorsMatch ? colors[0] : void 0,
      style: allStylesMatch ? styles3[0] : void 0,
      width: allWidthsMatch ? widths[0] : getMostCommonUnit(widths)
    };
  };
  var getShorthandBorderStyle = (border, fallbackBorder) => {
    if (isEmptyBorder(border)) {
      return fallbackBorder;
    }
    const {
      color: fallbackColor,
      style: fallbackStyle,
      width: fallbackWidth
    } = fallbackBorder || {};
    const {
      color: color2 = fallbackColor,
      style: style2 = fallbackStyle,
      width = fallbackWidth
    } = border;
    const hasVisibleBorder = !!width && width !== "0" || !!color2;
    const borderStyle = hasVisibleBorder ? style2 || "solid" : style2;
    return [width, borderStyle, color2].filter(Boolean).join(" ");
  };
  var getMostCommonUnit = (values) => {
    const units = values.map((value) => value === void 0 ? void 0 : parseCSSUnitValue(`${value}`)[1]);
    const filteredUnits = units.filter((value) => value !== void 0);
    return mode(filteredUnits);
  };
  function mode(values) {
    if (values.length === 0) {
      return void 0;
    }
    const map = {};
    let maxCount = 0;
    let currentMode;
    values.forEach((value) => {
      map[value] = map[value] === void 0 ? 1 : map[value] + 1;
      if (map[value] > maxCount) {
        currentMode = value;
        maxCount = map[value];
      }
    });
    return currentMode;
  }

  // packages/components/build-module/border-box-control/border-box-control/hook.mjs
  function useBorderBoxControl(props) {
    const {
      className: className2,
      colors = [],
      onChange,
      enableAlpha = false,
      enableStyle = true,
      value,
      __experimentalIsRenderedInSidebar = false,
      // Deprecated props, no longer used.
      size: _size,
      __next40pxDefaultSize: _next40pxDefaultSize,
      ...otherProps
    } = useContextSystem(props, "BorderBoxControl");
    const mixedBorders = hasMixedBorders(value);
    const splitBorders = hasSplitBorders(value);
    const linkedValue = splitBorders ? getCommonBorder(value) : value;
    const splitValue = splitBorders ? value : getSplitBorders(value);
    const hasWidthValue = !isNaN(parseFloat(`${linkedValue?.width}`));
    const [isLinked, setIsLinked] = (0, import_element88.useState)(!mixedBorders);
    const toggleLinked = () => setIsLinked(!isLinked);
    const onLinkedChange = (newBorder) => {
      if (!newBorder) {
        return onChange(void 0);
      }
      if (!mixedBorders || isCompleteBorder(newBorder)) {
        return onChange(isEmptyBorder(newBorder) ? void 0 : newBorder);
      }
      const changes = getBorderDiff(linkedValue, newBorder);
      const updatedBorders = {
        top: {
          ...value?.top,
          ...changes
        },
        right: {
          ...value?.right,
          ...changes
        },
        bottom: {
          ...value?.bottom,
          ...changes
        },
        left: {
          ...value?.left,
          ...changes
        }
      };
      if (hasMixedBorders(updatedBorders)) {
        return onChange(updatedBorders);
      }
      const filteredResult = isEmptyBorder(updatedBorders.top) ? void 0 : updatedBorders.top;
      onChange(filteredResult);
    };
    const onSplitChange = (newBorder, side) => {
      const updatedBorders = {
        ...splitValue,
        [side]: newBorder
      };
      if (hasMixedBorders(updatedBorders)) {
        onChange(updatedBorders);
      } else {
        onChange(newBorder);
      }
    };
    const cx2 = useCx();
    const classes = (0, import_element88.useMemo)(() => {
      return cx2(borderBoxControl, className2);
    }, [cx2, className2]);
    const linkedControlClassName = (0, import_element88.useMemo)(() => {
      return cx2(linkedBorderControl());
    }, [cx2]);
    const wrapperClassName = (0, import_element88.useMemo)(() => {
      return cx2(wrapper);
    }, [cx2]);
    return {
      ...otherProps,
      className: classes,
      colors,
      disableUnits: mixedBorders && !hasWidthValue,
      enableAlpha,
      enableStyle,
      hasMixedBorders: mixedBorders,
      isLinked,
      linkedControlClassName,
      onLinkedChange,
      onSplitChange,
      toggleLinked,
      linkedValue,
      splitValue,
      wrapperClassName,
      __experimentalIsRenderedInSidebar
    };
  }

  // packages/components/build-module/border-box-control/border-box-control/component.mjs
  var import_jsx_runtime153 = __toESM(require_jsx_runtime(), 1);
  var BorderLabel2 = (props) => {
    const {
      label,
      hideLabelFromVision
    } = props;
    if (!label) {
      return null;
    }
    return hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime153.jsx)(component_default2, {
      as: "label",
      children: label
    }) : /* @__PURE__ */ (0, import_jsx_runtime153.jsx)(StyledLabel, {
      children: label
    });
  };
  var UnconnectedBorderBoxControl = (props, forwardedRef) => {
    const {
      className: className2,
      colors,
      disableCustomColors,
      disableUnits,
      enableAlpha,
      enableStyle,
      hasMixedBorders: hasMixedBorders2,
      hideLabelFromVision,
      isLinked,
      label,
      linkedControlClassName,
      linkedValue,
      onLinkedChange,
      onSplitChange,
      popoverPlacement,
      popoverOffset,
      splitValue,
      toggleLinked,
      wrapperClassName,
      __experimentalIsRenderedInSidebar,
      ...otherProps
    } = useBorderBoxControl(props);
    const [popoverAnchor, setPopoverAnchor] = (0, import_element89.useState)(null);
    const popoverProps = (0, import_element89.useMemo)(() => popoverPlacement ? {
      placement: popoverPlacement,
      offset: popoverOffset,
      anchor: popoverAnchor,
      shift: true
    } : void 0, [popoverPlacement, popoverOffset, popoverAnchor]);
    const mergedRef = (0, import_compose36.useMergeRefs)([setPopoverAnchor, forwardedRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime153.jsxs)(component_default, {
      className: className2,
      ...otherProps,
      ref: mergedRef,
      children: [/* @__PURE__ */ (0, import_jsx_runtime153.jsx)(BorderLabel2, {
        label,
        hideLabelFromVision
      }), /* @__PURE__ */ (0, import_jsx_runtime153.jsxs)(component_default, {
        className: wrapperClassName,
        children: [isLinked ? /* @__PURE__ */ (0, import_jsx_runtime153.jsx)(component_default21, {
          className: linkedControlClassName,
          colors,
          disableUnits,
          disableCustomColors,
          enableAlpha,
          enableStyle,
          onChange: onLinkedChange,
          placeholder: hasMixedBorders2 ? (0, import_i18n26.__)("Mixed") : void 0,
          __unstablePopoverProps: popoverProps,
          shouldSanitizeBorder: false,
          value: linkedValue,
          withSlider: true,
          width: "116px",
          __experimentalIsRenderedInSidebar
        }) : /* @__PURE__ */ (0, import_jsx_runtime153.jsx)(component_default23, {
          colors,
          disableCustomColors,
          enableAlpha,
          enableStyle,
          onChange: onSplitChange,
          popoverPlacement,
          popoverOffset,
          value: splitValue,
          __experimentalIsRenderedInSidebar
        }), /* @__PURE__ */ (0, import_jsx_runtime153.jsx)(component_default10, {
          onClick: toggleLinked,
          isLinked
        })]
      })]
    });
  };
  var BorderBoxControl = contextConnect(UnconnectedBorderBoxControl, "BorderBoxControl");
  var component_default24 = BorderBoxControl;

  // packages/components/build-module/box-control/index.mjs
  var import_compose38 = __toESM(require_compose(), 1);
  var import_element91 = __toESM(require_element(), 1);
  var import_i18n30 = __toESM(require_i18n(), 1);
  var import_warning5 = __toESM(require_warning(), 1);

  // packages/components/build-module/box-control/box-input-control.mjs
  var import_compose37 = __toESM(require_compose(), 1);
  var import_i18n28 = __toESM(require_i18n(), 1);
  var import_element90 = __toESM(require_element(), 1);

  // packages/components/build-module/box-control/utils.mjs
  var import_i18n27 = __toESM(require_i18n(), 1);
  var CUSTOM_VALUE_SETTINGS = {
    px: {
      max: 300,
      step: 1
    },
    "%": {
      max: 100,
      step: 1
    },
    vw: {
      max: 100,
      step: 1
    },
    vh: {
      max: 100,
      step: 1
    },
    em: {
      max: 10,
      step: 0.1
    },
    rm: {
      max: 10,
      step: 0.1
    },
    svw: {
      max: 100,
      step: 1
    },
    lvw: {
      max: 100,
      step: 1
    },
    dvw: {
      max: 100,
      step: 1
    },
    svh: {
      max: 100,
      step: 1
    },
    lvh: {
      max: 100,
      step: 1
    },
    dvh: {
      max: 100,
      step: 1
    },
    vi: {
      max: 100,
      step: 1
    },
    svi: {
      max: 100,
      step: 1
    },
    lvi: {
      max: 100,
      step: 1
    },
    dvi: {
      max: 100,
      step: 1
    },
    vb: {
      max: 100,
      step: 1
    },
    svb: {
      max: 100,
      step: 1
    },
    lvb: {
      max: 100,
      step: 1
    },
    dvb: {
      max: 100,
      step: 1
    },
    vmin: {
      max: 100,
      step: 1
    },
    svmin: {
      max: 100,
      step: 1
    },
    lvmin: {
      max: 100,
      step: 1
    },
    dvmin: {
      max: 100,
      step: 1
    },
    vmax: {
      max: 100,
      step: 1
    },
    svmax: {
      max: 100,
      step: 1
    },
    lvmax: {
      max: 100,
      step: 1
    },
    dvmax: {
      max: 100,
      step: 1
    }
  };
  var LABELS = {
    all: (0, import_i18n27.__)("All sides"),
    top: (0, import_i18n27.__)("Top side"),
    bottom: (0, import_i18n27.__)("Bottom side"),
    left: (0, import_i18n27.__)("Left side"),
    right: (0, import_i18n27.__)("Right side"),
    vertical: (0, import_i18n27.__)("Top and bottom sides"),
    horizontal: (0, import_i18n27.__)("Left and right sides")
  };
  var DEFAULT_VALUES = {
    top: void 0,
    right: void 0,
    bottom: void 0,
    left: void 0
  };
  var ALL_SIDES = ["top", "right", "bottom", "left"];
  function getMergedValue(values = {}, availableSides = ALL_SIDES) {
    const sides3 = normalizeSides(availableSides);
    if (sides3.every((side) => values[side] === values[sides3[0]])) {
      return values[sides3[0]];
    }
    return void 0;
  }
  function isValueMixed(values = {}, availableSides = ALL_SIDES) {
    const sides3 = normalizeSides(availableSides);
    return sides3.some((side) => values[side] !== values[sides3[0]]);
  }
  function isValuesDefined(values) {
    return values && Object.values(values).filter(
      // Switching units when input is empty causes values only
      // containing units. This gives false positive on mixed values
      // unless filtered.
      (value) => !!value && /\d/.test(value)
    ).length > 0;
  }
  function normalizeSides(sides3) {
    const filteredSides = [];
    if (!sides3?.length) {
      return ALL_SIDES;
    }
    if (sides3.includes("vertical")) {
      filteredSides.push(...["top", "bottom"]);
    } else if (sides3.includes("horizontal")) {
      filteredSides.push(...["left", "right"]);
    } else {
      const newSides = ALL_SIDES.filter((side) => sides3.includes(side));
      filteredSides.push(...newSides);
    }
    return filteredSides;
  }
  function getAllowedSides(sides3) {
    const allowedSides = new Set(!sides3 ? ALL_SIDES : []);
    sides3?.forEach((allowedSide) => {
      if (allowedSide === "vertical") {
        allowedSides.add("top");
        allowedSides.add("bottom");
      } else if (allowedSide === "horizontal") {
        allowedSides.add("right");
        allowedSides.add("left");
      } else {
        allowedSides.add(allowedSide);
      }
    });
    return allowedSides;
  }
  function isValuePreset(value, presetKey) {
    return value.startsWith(`var:preset|${presetKey}|`);
  }
  function getPresetIndexFromValue(value, presetKey, presets) {
    if (!isValuePreset(value, presetKey)) {
      return void 0;
    }
    const match4 = value.match(new RegExp(`^var:preset\\|${presetKey}\\|(.+)$`));
    if (!match4) {
      return void 0;
    }
    const slug = match4[1];
    const index2 = presets.findIndex((preset) => {
      return preset.slug === slug;
    });
    return index2 !== -1 ? index2 : void 0;
  }
  function getPresetValueFromIndex(index2, presetKey, presets) {
    const preset = presets[index2];
    return `var:preset|${presetKey}|${preset.slug}`;
  }

  // packages/components/build-module/box-control/styles/box-control-icon-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__13() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Root3 = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1j5nr4z8"
  } : {
    target: "e1j5nr4z8",
    label: "Root"
  })(false ? {
    name: "1w884gc",
    styles: "box-sizing:border-box;display:block;width:24px;height:24px;position:relative;padding:4px"
  } : {
    name: "1w884gc",
    styles: "box-sizing:border-box;display:block;width:24px;height:24px;position:relative;padding:4px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU0rQiIsImZpbGUiOiJib3gtY29udHJvbC1pY29uLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuZXhwb3J0IGNvbnN0IFJvb3QgPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHdpZHRoOiAyNHB4O1xuXHRoZWlnaHQ6IDI0cHg7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0cGFkZGluZzogNHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IFZpZXdib3ggPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0d2lkdGg6IDEwMCU7XG5cdGhlaWdodDogMTAwJTtcbmA7XG5cbmNvbnN0IHN0cm9rZUZvY3VzID0gKCB7IGlzRm9jdXNlZCB9OiB7IGlzRm9jdXNlZDogYm9vbGVhbiB9ICkgPT4ge1xuXHRyZXR1cm4gY3NzKCB7XG5cdFx0YmFja2dyb3VuZENvbG9yOiAnY3VycmVudENvbG9yJyxcblx0XHRvcGFjaXR5OiBpc0ZvY3VzZWQgPyAxIDogMC4zLFxuXHR9ICk7XG59O1xuXG5jb25zdCBTdHJva2UgPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHBvaW50ZXItZXZlbnRzOiBub25lO1xuXHRwb3NpdGlvbjogYWJzb2x1dGU7XG5cdCR7IHN0cm9rZUZvY3VzIH07XG5gO1xuXG5jb25zdCBWZXJ0aWNhbFN0cm9rZSA9IHN0eWxlZCggU3Ryb2tlIClgXG5cdGJvdHRvbTogM3B4O1xuXHR0b3A6IDNweDtcblx0d2lkdGg6IDJweDtcbmA7XG5cbmNvbnN0IEhvcml6b250YWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRoZWlnaHQ6IDJweDtcblx0bGVmdDogM3B4O1xuXHRyaWdodDogM3B4O1xuYDtcblxuZXhwb3J0IGNvbnN0IFRvcFN0cm9rZSA9IHN0eWxlZCggSG9yaXpvbnRhbFN0cm9rZSApYFxuXHR0b3A6IDA7XG5gO1xuXG5leHBvcnQgY29uc3QgUmlnaHRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdHJpZ2h0OiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IEJvdHRvbVN0cm9rZSA9IHN0eWxlZCggSG9yaXpvbnRhbFN0cm9rZSApYFxuXHRib3R0b206IDA7XG5gO1xuXG5leHBvcnQgY29uc3QgTGVmdFN0cm9rZSA9IHN0eWxlZCggVmVydGljYWxTdHJva2UgKWBcblx0bGVmdDogMDtcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });
  var Viewbox = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1j5nr4z7"
  } : {
    target: "e1j5nr4z7",
    label: "Viewbox"
  })(false ? {
    name: "i6vjox",
    styles: "box-sizing:border-box;display:block;position:relative;width:100%;height:100%"
  } : {
    name: "i6vjox",
    styles: "box-sizing:border-box;display:block;position:relative;width:100%;height:100%/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWVrQyIsImZpbGUiOiJib3gtY29udHJvbC1pY29uLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuZXhwb3J0IGNvbnN0IFJvb3QgPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHdpZHRoOiAyNHB4O1xuXHRoZWlnaHQ6IDI0cHg7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0cGFkZGluZzogNHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IFZpZXdib3ggPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0d2lkdGg6IDEwMCU7XG5cdGhlaWdodDogMTAwJTtcbmA7XG5cbmNvbnN0IHN0cm9rZUZvY3VzID0gKCB7IGlzRm9jdXNlZCB9OiB7IGlzRm9jdXNlZDogYm9vbGVhbiB9ICkgPT4ge1xuXHRyZXR1cm4gY3NzKCB7XG5cdFx0YmFja2dyb3VuZENvbG9yOiAnY3VycmVudENvbG9yJyxcblx0XHRvcGFjaXR5OiBpc0ZvY3VzZWQgPyAxIDogMC4zLFxuXHR9ICk7XG59O1xuXG5jb25zdCBTdHJva2UgPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHBvaW50ZXItZXZlbnRzOiBub25lO1xuXHRwb3NpdGlvbjogYWJzb2x1dGU7XG5cdCR7IHN0cm9rZUZvY3VzIH07XG5gO1xuXG5jb25zdCBWZXJ0aWNhbFN0cm9rZSA9IHN0eWxlZCggU3Ryb2tlIClgXG5cdGJvdHRvbTogM3B4O1xuXHR0b3A6IDNweDtcblx0d2lkdGg6IDJweDtcbmA7XG5cbmNvbnN0IEhvcml6b250YWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRoZWlnaHQ6IDJweDtcblx0bGVmdDogM3B4O1xuXHRyaWdodDogM3B4O1xuYDtcblxuZXhwb3J0IGNvbnN0IFRvcFN0cm9rZSA9IHN0eWxlZCggSG9yaXpvbnRhbFN0cm9rZSApYFxuXHR0b3A6IDA7XG5gO1xuXG5leHBvcnQgY29uc3QgUmlnaHRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdHJpZ2h0OiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IEJvdHRvbVN0cm9rZSA9IHN0eWxlZCggSG9yaXpvbnRhbFN0cm9rZSApYFxuXHRib3R0b206IDA7XG5gO1xuXG5leHBvcnQgY29uc3QgTGVmdFN0cm9rZSA9IHN0eWxlZCggVmVydGljYWxTdHJva2UgKWBcblx0bGVmdDogMDtcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });
  var strokeFocus = ({
    isFocused
  }) => {
    return /* @__PURE__ */ css({
      backgroundColor: "currentColor",
      opacity: isFocused ? 1 : 0.3
    }, false ? "" : ";label:strokeFocus;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXdCUSIsImZpbGUiOiJib3gtY29udHJvbC1pY29uLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuZXhwb3J0IGNvbnN0IFJvb3QgPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHdpZHRoOiAyNHB4O1xuXHRoZWlnaHQ6IDI0cHg7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0cGFkZGluZzogNHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IFZpZXdib3ggPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0d2lkdGg6IDEwMCU7XG5cdGhlaWdodDogMTAwJTtcbmA7XG5cbmNvbnN0IHN0cm9rZUZvY3VzID0gKCB7IGlzRm9jdXNlZCB9OiB7IGlzRm9jdXNlZDogYm9vbGVhbiB9ICkgPT4ge1xuXHRyZXR1cm4gY3NzKCB7XG5cdFx0YmFja2dyb3VuZENvbG9yOiAnY3VycmVudENvbG9yJyxcblx0XHRvcGFjaXR5OiBpc0ZvY3VzZWQgPyAxIDogMC4zLFxuXHR9ICk7XG59O1xuXG5jb25zdCBTdHJva2UgPSBzdHlsZWQuc3BhbmBcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdHBvaW50ZXItZXZlbnRzOiBub25lO1xuXHRwb3NpdGlvbjogYWJzb2x1dGU7XG5cdCR7IHN0cm9rZUZvY3VzIH07XG5gO1xuXG5jb25zdCBWZXJ0aWNhbFN0cm9rZSA9IHN0eWxlZCggU3Ryb2tlIClgXG5cdGJvdHRvbTogM3B4O1xuXHR0b3A6IDNweDtcblx0d2lkdGg6IDJweDtcbmA7XG5cbmNvbnN0IEhvcml6b250YWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRoZWlnaHQ6IDJweDtcblx0bGVmdDogM3B4O1xuXHRyaWdodDogM3B4O1xuYDtcblxuZXhwb3J0IGNvbnN0IFRvcFN0cm9rZSA9IHN0eWxlZCggSG9yaXpvbnRhbFN0cm9rZSApYFxuXHR0b3A6IDA7XG5gO1xuXG5leHBvcnQgY29uc3QgUmlnaHRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdHJpZ2h0OiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IEJvdHRvbVN0cm9rZSA9IHN0eWxlZCggSG9yaXpvbnRhbFN0cm9rZSApYFxuXHRib3R0b206IDA7XG5gO1xuXG5leHBvcnQgY29uc3QgTGVmdFN0cm9rZSA9IHN0eWxlZCggVmVydGljYWxTdHJva2UgKWBcblx0bGVmdDogMDtcbmA7XG4iXX0= */");
  };
  var Stroke = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1j5nr4z6"
  } : {
    target: "e1j5nr4z6",
    label: "Stroke"
  })("box-sizing:border-box;display:block;pointer-events:none;position:absolute;", strokeFocus, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQThCMEIiLCJmaWxlIjoiYm94LWNvbnRyb2wtaWNvbi1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHR3aWR0aDogMjRweDtcblx0aGVpZ2h0OiAyNHB4O1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHBhZGRpbmc6IDRweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBWaWV3Ym94ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHdpZHRoOiAxMDAlO1xuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5jb25zdCBzdHJva2VGb2N1cyA9ICggeyBpc0ZvY3VzZWQgfTogeyBpc0ZvY3VzZWQ6IGJvb2xlYW4gfSApID0+IHtcblx0cmV0dXJuIGNzcygge1xuXHRcdGJhY2tncm91bmRDb2xvcjogJ2N1cnJlbnRDb2xvcicsXG5cdFx0b3BhY2l0eTogaXNGb2N1c2VkID8gMSA6IDAuMyxcblx0fSApO1xufTtcblxuY29uc3QgU3Ryb2tlID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHQkeyBzdHJva2VGb2N1cyB9O1xuYDtcblxuY29uc3QgVmVydGljYWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRib3R0b206IDNweDtcblx0dG9wOiAzcHg7XG5cdHdpZHRoOiAycHg7XG5gO1xuXG5jb25zdCBIb3Jpem9udGFsU3Ryb2tlID0gc3R5bGVkKCBTdHJva2UgKWBcblx0aGVpZ2h0OiAycHg7XG5cdGxlZnQ6IDNweDtcblx0cmlnaHQ6IDNweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb3BTdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJpZ2h0U3Ryb2tlID0gc3R5bGVkKCBWZXJ0aWNhbFN0cm9rZSApYFxuXHRyaWdodDogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBCb3R0b21TdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0Ym90dG9tOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IExlZnRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdGxlZnQ6IDA7XG5gO1xuIl19 */"));
  var VerticalStroke = /* @__PURE__ */ createStyled(Stroke, false ? {
    target: "e1j5nr4z5"
  } : {
    target: "e1j5nr4z5",
    label: "VerticalStroke"
  })(false ? {
    name: "1k2w39q",
    styles: "bottom:3px;top:3px;width:2px"
  } : {
    name: "1k2w39q",
    styles: "bottom:3px;top:3px;width:2px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXNDdUMiLCJmaWxlIjoiYm94LWNvbnRyb2wtaWNvbi1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHR3aWR0aDogMjRweDtcblx0aGVpZ2h0OiAyNHB4O1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHBhZGRpbmc6IDRweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBWaWV3Ym94ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHdpZHRoOiAxMDAlO1xuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5jb25zdCBzdHJva2VGb2N1cyA9ICggeyBpc0ZvY3VzZWQgfTogeyBpc0ZvY3VzZWQ6IGJvb2xlYW4gfSApID0+IHtcblx0cmV0dXJuIGNzcygge1xuXHRcdGJhY2tncm91bmRDb2xvcjogJ2N1cnJlbnRDb2xvcicsXG5cdFx0b3BhY2l0eTogaXNGb2N1c2VkID8gMSA6IDAuMyxcblx0fSApO1xufTtcblxuY29uc3QgU3Ryb2tlID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHQkeyBzdHJva2VGb2N1cyB9O1xuYDtcblxuY29uc3QgVmVydGljYWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRib3R0b206IDNweDtcblx0dG9wOiAzcHg7XG5cdHdpZHRoOiAycHg7XG5gO1xuXG5jb25zdCBIb3Jpem9udGFsU3Ryb2tlID0gc3R5bGVkKCBTdHJva2UgKWBcblx0aGVpZ2h0OiAycHg7XG5cdGxlZnQ6IDNweDtcblx0cmlnaHQ6IDNweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb3BTdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJpZ2h0U3Ryb2tlID0gc3R5bGVkKCBWZXJ0aWNhbFN0cm9rZSApYFxuXHRyaWdodDogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBCb3R0b21TdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0Ym90dG9tOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IExlZnRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdGxlZnQ6IDA7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });
  var HorizontalStroke = /* @__PURE__ */ createStyled(Stroke, false ? {
    target: "e1j5nr4z4"
  } : {
    target: "e1j5nr4z4",
    label: "HorizontalStroke"
  })(false ? {
    name: "1q9b07k",
    styles: "height:2px;left:3px;right:3px"
  } : {
    name: "1q9b07k",
    styles: "height:2px;left:3px;right:3px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTRDeUMiLCJmaWxlIjoiYm94LWNvbnRyb2wtaWNvbi1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHR3aWR0aDogMjRweDtcblx0aGVpZ2h0OiAyNHB4O1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHBhZGRpbmc6IDRweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBWaWV3Ym94ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHdpZHRoOiAxMDAlO1xuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5jb25zdCBzdHJva2VGb2N1cyA9ICggeyBpc0ZvY3VzZWQgfTogeyBpc0ZvY3VzZWQ6IGJvb2xlYW4gfSApID0+IHtcblx0cmV0dXJuIGNzcygge1xuXHRcdGJhY2tncm91bmRDb2xvcjogJ2N1cnJlbnRDb2xvcicsXG5cdFx0b3BhY2l0eTogaXNGb2N1c2VkID8gMSA6IDAuMyxcblx0fSApO1xufTtcblxuY29uc3QgU3Ryb2tlID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHQkeyBzdHJva2VGb2N1cyB9O1xuYDtcblxuY29uc3QgVmVydGljYWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRib3R0b206IDNweDtcblx0dG9wOiAzcHg7XG5cdHdpZHRoOiAycHg7XG5gO1xuXG5jb25zdCBIb3Jpem9udGFsU3Ryb2tlID0gc3R5bGVkKCBTdHJva2UgKWBcblx0aGVpZ2h0OiAycHg7XG5cdGxlZnQ6IDNweDtcblx0cmlnaHQ6IDNweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb3BTdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJpZ2h0U3Ryb2tlID0gc3R5bGVkKCBWZXJ0aWNhbFN0cm9rZSApYFxuXHRyaWdodDogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBCb3R0b21TdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0Ym90dG9tOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IExlZnRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdGxlZnQ6IDA7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });
  var TopStroke = /* @__PURE__ */ createStyled(HorizontalStroke, false ? {
    target: "e1j5nr4z3"
  } : {
    target: "e1j5nr4z3",
    label: "TopStroke"
  })(false ? {
    name: "abcix4",
    styles: "top:0"
  } : {
    name: "abcix4",
    styles: "top:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWtEbUQiLCJmaWxlIjoiYm94LWNvbnRyb2wtaWNvbi1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHR3aWR0aDogMjRweDtcblx0aGVpZ2h0OiAyNHB4O1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHBhZGRpbmc6IDRweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBWaWV3Ym94ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHdpZHRoOiAxMDAlO1xuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5jb25zdCBzdHJva2VGb2N1cyA9ICggeyBpc0ZvY3VzZWQgfTogeyBpc0ZvY3VzZWQ6IGJvb2xlYW4gfSApID0+IHtcblx0cmV0dXJuIGNzcygge1xuXHRcdGJhY2tncm91bmRDb2xvcjogJ2N1cnJlbnRDb2xvcicsXG5cdFx0b3BhY2l0eTogaXNGb2N1c2VkID8gMSA6IDAuMyxcblx0fSApO1xufTtcblxuY29uc3QgU3Ryb2tlID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHQkeyBzdHJva2VGb2N1cyB9O1xuYDtcblxuY29uc3QgVmVydGljYWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRib3R0b206IDNweDtcblx0dG9wOiAzcHg7XG5cdHdpZHRoOiAycHg7XG5gO1xuXG5jb25zdCBIb3Jpem9udGFsU3Ryb2tlID0gc3R5bGVkKCBTdHJva2UgKWBcblx0aGVpZ2h0OiAycHg7XG5cdGxlZnQ6IDNweDtcblx0cmlnaHQ6IDNweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb3BTdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJpZ2h0U3Ryb2tlID0gc3R5bGVkKCBWZXJ0aWNhbFN0cm9rZSApYFxuXHRyaWdodDogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBCb3R0b21TdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0Ym90dG9tOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IExlZnRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdGxlZnQ6IDA7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });
  var RightStroke = /* @__PURE__ */ createStyled(VerticalStroke, false ? {
    target: "e1j5nr4z2"
  } : {
    target: "e1j5nr4z2",
    label: "RightStroke"
  })(false ? {
    name: "1wf8jf",
    styles: "right:0"
  } : {
    name: "1wf8jf",
    styles: "right:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQXNEbUQiLCJmaWxlIjoiYm94LWNvbnRyb2wtaWNvbi1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHR3aWR0aDogMjRweDtcblx0aGVpZ2h0OiAyNHB4O1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHBhZGRpbmc6IDRweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBWaWV3Ym94ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHdpZHRoOiAxMDAlO1xuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5jb25zdCBzdHJva2VGb2N1cyA9ICggeyBpc0ZvY3VzZWQgfTogeyBpc0ZvY3VzZWQ6IGJvb2xlYW4gfSApID0+IHtcblx0cmV0dXJuIGNzcygge1xuXHRcdGJhY2tncm91bmRDb2xvcjogJ2N1cnJlbnRDb2xvcicsXG5cdFx0b3BhY2l0eTogaXNGb2N1c2VkID8gMSA6IDAuMyxcblx0fSApO1xufTtcblxuY29uc3QgU3Ryb2tlID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHQkeyBzdHJva2VGb2N1cyB9O1xuYDtcblxuY29uc3QgVmVydGljYWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRib3R0b206IDNweDtcblx0dG9wOiAzcHg7XG5cdHdpZHRoOiAycHg7XG5gO1xuXG5jb25zdCBIb3Jpem9udGFsU3Ryb2tlID0gc3R5bGVkKCBTdHJva2UgKWBcblx0aGVpZ2h0OiAycHg7XG5cdGxlZnQ6IDNweDtcblx0cmlnaHQ6IDNweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb3BTdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJpZ2h0U3Ryb2tlID0gc3R5bGVkKCBWZXJ0aWNhbFN0cm9rZSApYFxuXHRyaWdodDogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBCb3R0b21TdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0Ym90dG9tOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IExlZnRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdGxlZnQ6IDA7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });
  var BottomStroke = /* @__PURE__ */ createStyled(HorizontalStroke, false ? {
    target: "e1j5nr4z1"
  } : {
    target: "e1j5nr4z1",
    label: "BottomStroke"
  })(false ? {
    name: "8tapst",
    styles: "bottom:0"
  } : {
    name: "8tapst",
    styles: "bottom:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTBEc0QiLCJmaWxlIjoiYm94LWNvbnRyb2wtaWNvbi1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHR3aWR0aDogMjRweDtcblx0aGVpZ2h0OiAyNHB4O1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHBhZGRpbmc6IDRweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBWaWV3Ym94ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHdpZHRoOiAxMDAlO1xuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5jb25zdCBzdHJva2VGb2N1cyA9ICggeyBpc0ZvY3VzZWQgfTogeyBpc0ZvY3VzZWQ6IGJvb2xlYW4gfSApID0+IHtcblx0cmV0dXJuIGNzcygge1xuXHRcdGJhY2tncm91bmRDb2xvcjogJ2N1cnJlbnRDb2xvcicsXG5cdFx0b3BhY2l0eTogaXNGb2N1c2VkID8gMSA6IDAuMyxcblx0fSApO1xufTtcblxuY29uc3QgU3Ryb2tlID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHQkeyBzdHJva2VGb2N1cyB9O1xuYDtcblxuY29uc3QgVmVydGljYWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRib3R0b206IDNweDtcblx0dG9wOiAzcHg7XG5cdHdpZHRoOiAycHg7XG5gO1xuXG5jb25zdCBIb3Jpem9udGFsU3Ryb2tlID0gc3R5bGVkKCBTdHJva2UgKWBcblx0aGVpZ2h0OiAycHg7XG5cdGxlZnQ6IDNweDtcblx0cmlnaHQ6IDNweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb3BTdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJpZ2h0U3Ryb2tlID0gc3R5bGVkKCBWZXJ0aWNhbFN0cm9rZSApYFxuXHRyaWdodDogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBCb3R0b21TdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0Ym90dG9tOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IExlZnRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdGxlZnQ6IDA7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });
  var LeftStroke = /* @__PURE__ */ createStyled(VerticalStroke, false ? {
    target: "e1j5nr4z0"
  } : {
    target: "e1j5nr4z0",
    label: "LeftStroke"
  })(false ? {
    name: "1ode3cm",
    styles: "left:0"
  } : {
    name: "1ode3cm",
    styles: "left:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLWljb24tc3R5bGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQThEa0QiLCJmaWxlIjoiYm94LWNvbnRyb2wtaWNvbi1zdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHR3aWR0aDogMjRweDtcblx0aGVpZ2h0OiAyNHB4O1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHBhZGRpbmc6IDRweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBWaWV3Ym94ID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdHdpZHRoOiAxMDAlO1xuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5jb25zdCBzdHJva2VGb2N1cyA9ICggeyBpc0ZvY3VzZWQgfTogeyBpc0ZvY3VzZWQ6IGJvb2xlYW4gfSApID0+IHtcblx0cmV0dXJuIGNzcygge1xuXHRcdGJhY2tncm91bmRDb2xvcjogJ2N1cnJlbnRDb2xvcicsXG5cdFx0b3BhY2l0eTogaXNGb2N1c2VkID8gMSA6IDAuMyxcblx0fSApO1xufTtcblxuY29uc3QgU3Ryb2tlID0gc3R5bGVkLnNwYW5gXG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGRpc3BsYXk6IGJsb2NrO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHQkeyBzdHJva2VGb2N1cyB9O1xuYDtcblxuY29uc3QgVmVydGljYWxTdHJva2UgPSBzdHlsZWQoIFN0cm9rZSApYFxuXHRib3R0b206IDNweDtcblx0dG9wOiAzcHg7XG5cdHdpZHRoOiAycHg7XG5gO1xuXG5jb25zdCBIb3Jpem9udGFsU3Ryb2tlID0gc3R5bGVkKCBTdHJva2UgKWBcblx0aGVpZ2h0OiAycHg7XG5cdGxlZnQ6IDNweDtcblx0cmlnaHQ6IDNweDtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb3BTdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJpZ2h0U3Ryb2tlID0gc3R5bGVkKCBWZXJ0aWNhbFN0cm9rZSApYFxuXHRyaWdodDogMDtcbmA7XG5cbmV4cG9ydCBjb25zdCBCb3R0b21TdHJva2UgPSBzdHlsZWQoIEhvcml6b250YWxTdHJva2UgKWBcblx0Ym90dG9tOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IExlZnRTdHJva2UgPSBzdHlsZWQoIFZlcnRpY2FsU3Ryb2tlIClgXG5cdGxlZnQ6IDA7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__13
  });

  // packages/components/build-module/box-control/icon.mjs
  var import_jsx_runtime154 = __toESM(require_jsx_runtime(), 1);
  var BASE_ICON_SIZE = 24;
  function BoxControlIcon({
    size: size4 = 24,
    side = "all",
    sides: sides3,
    ...props
  }) {
    const isSideDisabled = (value) => sides3?.length && !sides3.includes(value);
    const hasSide = (value) => {
      if (isSideDisabled(value)) {
        return false;
      }
      return side === "all" || side === value;
    };
    const top = hasSide("top") || hasSide("vertical");
    const right = hasSide("right") || hasSide("horizontal");
    const bottom = hasSide("bottom") || hasSide("vertical");
    const left = hasSide("left") || hasSide("horizontal");
    const scale2 = size4 / BASE_ICON_SIZE;
    return /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(Root3, {
      style: {
        transform: `scale(${scale2})`
      },
      ...props,
      children: /* @__PURE__ */ (0, import_jsx_runtime154.jsxs)(Viewbox, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime154.jsx)(TopStroke, {
          isFocused: top
        }), /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(RightStroke, {
          isFocused: right
        }), /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(BottomStroke, {
          isFocused: bottom
        }), /* @__PURE__ */ (0, import_jsx_runtime154.jsx)(LeftStroke, {
          isFocused: left
        })]
      })
    });
  }

  // packages/components/build-module/box-control/styles/box-control-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__14() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var StyledUnitControl = /* @__PURE__ */ createStyled(unit_control_default, false ? {
    target: "e1jovhle5"
  } : {
    target: "e1jovhle5",
    label: "StyledUnitControl"
  })(false ? {
    name: "1ejyr19",
    styles: "max-width:90px"
  } : {
    name: "1ejyr19",
    styles: "max-width:90px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFjc0QiLCJmaWxlIjoiYm94LWNvbnRyb2wtc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IEJveENvbnRyb2xJY29uIGZyb20gJy4uL2ljb24nO1xuaW1wb3J0IEJ1dHRvbiBmcm9tICcuLi8uLi9idXR0b24nO1xuaW1wb3J0IHsgSFN0YWNrIH0gZnJvbSAnLi4vLi4vaC1zdGFjayc7XG5pbXBvcnQgUmFuZ2VDb250cm9sIGZyb20gJy4uLy4uL3JhbmdlLWNvbnRyb2wnO1xuaW1wb3J0IFVuaXRDb250cm9sIGZyb20gJy4uLy4uL3VuaXQtY29udHJvbCc7XG5pbXBvcnQgeyBzcGFjZSB9IGZyb20gJy4uLy4uL3V0aWxzL3NwYWNlJztcblxuZXhwb3J0IGNvbnN0IFN0eWxlZFVuaXRDb250cm9sID0gc3R5bGVkKCBVbml0Q29udHJvbCApYFxuXHRtYXgtd2lkdGg6IDkwcHg7XG5gO1xuXG5leHBvcnQgY29uc3QgSW5wdXRXcmFwcGVyID0gc3R5bGVkKCBIU3RhY2sgKWBcblx0Z3JpZC1jb2x1bW46IDEgLyBzcGFuIDM7XG5gO1xuXG5leHBvcnQgY29uc3QgUmVzZXRCdXR0b24gPSBzdHlsZWQoIEJ1dHRvbiApYFxuXHRncmlkLWFyZWE6IDEgLyAyO1xuXHRqdXN0aWZ5LXNlbGY6IGVuZDtcbmA7XG5cbmV4cG9ydCBjb25zdCBMaW5rZWRCdXR0b25XcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0Z3JpZC1hcmVhOiAxIC8gMztcblx0anVzdGlmeS1zZWxmOiBlbmQ7XG5gO1xuXG5leHBvcnQgY29uc3QgRmxleGVkQm94Q29udHJvbEljb24gPSBzdHlsZWQoIEJveENvbnRyb2xJY29uIClgXG5cdGZsZXg6IDAgMCBhdXRvO1xuYDtcblxuZXhwb3J0IGNvbnN0IEZsZXhlZFJhbmdlQ29udHJvbCA9IHN0eWxlZCggUmFuZ2VDb250cm9sIClgXG5cdHdpZHRoOiAxMDAlO1xuXHRtYXJnaW4taW5saW5lLWVuZDogJHsgc3BhY2UoIDIgKSB9O1xuYDtcbiJdfQ== */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__14
  });
  var InputWrapper = /* @__PURE__ */ createStyled(component_default9, false ? {
    target: "e1jovhle4"
  } : {
    target: "e1jovhle4",
    label: "InputWrapper"
  })(false ? {
    name: "1j1lmoi",
    styles: "grid-column:1/span 3"
  } : {
    name: "1j1lmoi",
    styles: "grid-column:1/span 3/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFrQjRDIiwiZmlsZSI6ImJveC1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbi8qKlxuICogSW50ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBCb3hDb250cm9sSWNvbiBmcm9tICcuLi9pY29uJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IEhTdGFjayB9IGZyb20gJy4uLy4uL2gtc3RhY2snO1xuaW1wb3J0IFJhbmdlQ29udHJvbCBmcm9tICcuLi8uLi9yYW5nZS1jb250cm9sJztcbmltcG9ydCBVbml0Q29udHJvbCBmcm9tICcuLi8uLi91bml0LWNvbnRyb2wnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRVbml0Q29udHJvbCA9IHN0eWxlZCggVW5pdENvbnRyb2wgKWBcblx0bWF4LXdpZHRoOiA5MHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IElucHV0V3JhcHBlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGdyaWQtY29sdW1uOiAxIC8gc3BhbiAzO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJlc2V0QnV0dG9uID0gc3R5bGVkKCBCdXR0b24gKWBcblx0Z3JpZC1hcmVhOiAxIC8gMjtcblx0anVzdGlmeS1zZWxmOiBlbmQ7XG5gO1xuXG5leHBvcnQgY29uc3QgTGlua2VkQnV0dG9uV3JhcHBlciA9IHN0eWxlZC5kaXZgXG5cdGdyaWQtYXJlYTogMSAvIDM7XG5cdGp1c3RpZnktc2VsZjogZW5kO1xuYDtcblxuZXhwb3J0IGNvbnN0IEZsZXhlZEJveENvbnRyb2xJY29uID0gc3R5bGVkKCBCb3hDb250cm9sSWNvbiApYFxuXHRmbGV4OiAwIDAgYXV0bztcbmA7XG5cbmV4cG9ydCBjb25zdCBGbGV4ZWRSYW5nZUNvbnRyb2wgPSBzdHlsZWQoIFJhbmdlQ29udHJvbCApYFxuXHR3aWR0aDogMTAwJTtcblx0bWFyZ2luLWlubGluZS1lbmQ6ICR7IHNwYWNlKCAyICkgfTtcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__14
  });
  var ResetButton = /* @__PURE__ */ createStyled(button_default, false ? {
    target: "e1jovhle3"
  } : {
    target: "e1jovhle3",
    label: "ResetButton"
  })(false ? {
    name: "tkya7b",
    styles: "grid-area:1/2;justify-self:end"
  } : {
    name: "tkya7b",
    styles: "grid-area:1/2;justify-self:end/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQjJDIiwiZmlsZSI6ImJveC1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbi8qKlxuICogSW50ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBCb3hDb250cm9sSWNvbiBmcm9tICcuLi9pY29uJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IEhTdGFjayB9IGZyb20gJy4uLy4uL2gtc3RhY2snO1xuaW1wb3J0IFJhbmdlQ29udHJvbCBmcm9tICcuLi8uLi9yYW5nZS1jb250cm9sJztcbmltcG9ydCBVbml0Q29udHJvbCBmcm9tICcuLi8uLi91bml0LWNvbnRyb2wnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRVbml0Q29udHJvbCA9IHN0eWxlZCggVW5pdENvbnRyb2wgKWBcblx0bWF4LXdpZHRoOiA5MHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IElucHV0V3JhcHBlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGdyaWQtY29sdW1uOiAxIC8gc3BhbiAzO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJlc2V0QnV0dG9uID0gc3R5bGVkKCBCdXR0b24gKWBcblx0Z3JpZC1hcmVhOiAxIC8gMjtcblx0anVzdGlmeS1zZWxmOiBlbmQ7XG5gO1xuXG5leHBvcnQgY29uc3QgTGlua2VkQnV0dG9uV3JhcHBlciA9IHN0eWxlZC5kaXZgXG5cdGdyaWQtYXJlYTogMSAvIDM7XG5cdGp1c3RpZnktc2VsZjogZW5kO1xuYDtcblxuZXhwb3J0IGNvbnN0IEZsZXhlZEJveENvbnRyb2xJY29uID0gc3R5bGVkKCBCb3hDb250cm9sSWNvbiApYFxuXHRmbGV4OiAwIDAgYXV0bztcbmA7XG5cbmV4cG9ydCBjb25zdCBGbGV4ZWRSYW5nZUNvbnRyb2wgPSBzdHlsZWQoIFJhbmdlQ29udHJvbCApYFxuXHR3aWR0aDogMTAwJTtcblx0bWFyZ2luLWlubGluZS1lbmQ6ICR7IHNwYWNlKCAyICkgfTtcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__14
  });
  var LinkedButtonWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1jovhle2"
  } : {
    target: "e1jovhle2",
    label: "LinkedButtonWrapper"
  })(false ? {
    name: "1dfa8al",
    styles: "grid-area:1/3;justify-self:end"
  } : {
    name: "1dfa8al",
    styles: "grid-area:1/3;justify-self:end/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEyQjZDIiwiZmlsZSI6ImJveC1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbi8qKlxuICogSW50ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBCb3hDb250cm9sSWNvbiBmcm9tICcuLi9pY29uJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IEhTdGFjayB9IGZyb20gJy4uLy4uL2gtc3RhY2snO1xuaW1wb3J0IFJhbmdlQ29udHJvbCBmcm9tICcuLi8uLi9yYW5nZS1jb250cm9sJztcbmltcG9ydCBVbml0Q29udHJvbCBmcm9tICcuLi8uLi91bml0LWNvbnRyb2wnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRVbml0Q29udHJvbCA9IHN0eWxlZCggVW5pdENvbnRyb2wgKWBcblx0bWF4LXdpZHRoOiA5MHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IElucHV0V3JhcHBlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGdyaWQtY29sdW1uOiAxIC8gc3BhbiAzO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJlc2V0QnV0dG9uID0gc3R5bGVkKCBCdXR0b24gKWBcblx0Z3JpZC1hcmVhOiAxIC8gMjtcblx0anVzdGlmeS1zZWxmOiBlbmQ7XG5gO1xuXG5leHBvcnQgY29uc3QgTGlua2VkQnV0dG9uV3JhcHBlciA9IHN0eWxlZC5kaXZgXG5cdGdyaWQtYXJlYTogMSAvIDM7XG5cdGp1c3RpZnktc2VsZjogZW5kO1xuYDtcblxuZXhwb3J0IGNvbnN0IEZsZXhlZEJveENvbnRyb2xJY29uID0gc3R5bGVkKCBCb3hDb250cm9sSWNvbiApYFxuXHRmbGV4OiAwIDAgYXV0bztcbmA7XG5cbmV4cG9ydCBjb25zdCBGbGV4ZWRSYW5nZUNvbnRyb2wgPSBzdHlsZWQoIFJhbmdlQ29udHJvbCApYFxuXHR3aWR0aDogMTAwJTtcblx0bWFyZ2luLWlubGluZS1lbmQ6ICR7IHNwYWNlKCAyICkgfTtcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__14
  });
  var FlexedBoxControlIcon = /* @__PURE__ */ createStyled(BoxControlIcon, false ? {
    target: "e1jovhle1"
  } : {
    target: "e1jovhle1",
    label: "FlexedBoxControlIcon"
  })(false ? {
    name: "ou8xsw",
    styles: "flex:0 0 auto"
  } : {
    name: "ou8xsw",
    styles: "flex:0 0 auto/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFnQzREIiwiZmlsZSI6ImJveC1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbi8qKlxuICogSW50ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBCb3hDb250cm9sSWNvbiBmcm9tICcuLi9pY29uJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IEhTdGFjayB9IGZyb20gJy4uLy4uL2gtc3RhY2snO1xuaW1wb3J0IFJhbmdlQ29udHJvbCBmcm9tICcuLi8uLi9yYW5nZS1jb250cm9sJztcbmltcG9ydCBVbml0Q29udHJvbCBmcm9tICcuLi8uLi91bml0LWNvbnRyb2wnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRVbml0Q29udHJvbCA9IHN0eWxlZCggVW5pdENvbnRyb2wgKWBcblx0bWF4LXdpZHRoOiA5MHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IElucHV0V3JhcHBlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGdyaWQtY29sdW1uOiAxIC8gc3BhbiAzO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJlc2V0QnV0dG9uID0gc3R5bGVkKCBCdXR0b24gKWBcblx0Z3JpZC1hcmVhOiAxIC8gMjtcblx0anVzdGlmeS1zZWxmOiBlbmQ7XG5gO1xuXG5leHBvcnQgY29uc3QgTGlua2VkQnV0dG9uV3JhcHBlciA9IHN0eWxlZC5kaXZgXG5cdGdyaWQtYXJlYTogMSAvIDM7XG5cdGp1c3RpZnktc2VsZjogZW5kO1xuYDtcblxuZXhwb3J0IGNvbnN0IEZsZXhlZEJveENvbnRyb2xJY29uID0gc3R5bGVkKCBCb3hDb250cm9sSWNvbiApYFxuXHRmbGV4OiAwIDAgYXV0bztcbmA7XG5cbmV4cG9ydCBjb25zdCBGbGV4ZWRSYW5nZUNvbnRyb2wgPSBzdHlsZWQoIFJhbmdlQ29udHJvbCApYFxuXHR3aWR0aDogMTAwJTtcblx0bWFyZ2luLWlubGluZS1lbmQ6ICR7IHNwYWNlKCAyICkgfTtcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__14
  });
  var FlexedRangeControl = /* @__PURE__ */ createStyled(range_control_default, false ? {
    target: "e1jovhle0"
  } : {
    target: "e1jovhle0",
    label: "FlexedRangeControl"
  })("width:100%;margin-inline-end:", space(2), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImJveC1jb250cm9sLXN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFvQ3dEIiwiZmlsZSI6ImJveC1jb250cm9sLXN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbi8qKlxuICogSW50ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBCb3hDb250cm9sSWNvbiBmcm9tICcuLi9pY29uJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vLi4vYnV0dG9uJztcbmltcG9ydCB7IEhTdGFjayB9IGZyb20gJy4uLy4uL2gtc3RhY2snO1xuaW1wb3J0IFJhbmdlQ29udHJvbCBmcm9tICcuLi8uLi9yYW5nZS1jb250cm9sJztcbmltcG9ydCBVbml0Q29udHJvbCBmcm9tICcuLi8uLi91bml0LWNvbnRyb2wnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi8uLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRVbml0Q29udHJvbCA9IHN0eWxlZCggVW5pdENvbnRyb2wgKWBcblx0bWF4LXdpZHRoOiA5MHB4O1xuYDtcblxuZXhwb3J0IGNvbnN0IElucHV0V3JhcHBlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGdyaWQtY29sdW1uOiAxIC8gc3BhbiAzO1xuYDtcblxuZXhwb3J0IGNvbnN0IFJlc2V0QnV0dG9uID0gc3R5bGVkKCBCdXR0b24gKWBcblx0Z3JpZC1hcmVhOiAxIC8gMjtcblx0anVzdGlmeS1zZWxmOiBlbmQ7XG5gO1xuXG5leHBvcnQgY29uc3QgTGlua2VkQnV0dG9uV3JhcHBlciA9IHN0eWxlZC5kaXZgXG5cdGdyaWQtYXJlYTogMSAvIDM7XG5cdGp1c3RpZnktc2VsZjogZW5kO1xuYDtcblxuZXhwb3J0IGNvbnN0IEZsZXhlZEJveENvbnRyb2xJY29uID0gc3R5bGVkKCBCb3hDb250cm9sSWNvbiApYFxuXHRmbGV4OiAwIDAgYXV0bztcbmA7XG5cbmV4cG9ydCBjb25zdCBGbGV4ZWRSYW5nZUNvbnRyb2wgPSBzdHlsZWQoIFJhbmdlQ29udHJvbCApYFxuXHR3aWR0aDogMTAwJTtcblx0bWFyZ2luLWlubGluZS1lbmQ6ICR7IHNwYWNlKCAyICkgfTtcbmA7XG4iXX0= */"));

  // packages/components/build-module/box-control/box-input-control.mjs
  var import_jsx_runtime155 = __toESM(require_jsx_runtime(), 1);
  var noop10 = () => {
  };
  function getSidesToModify(side, sides3, isAlt) {
    const allowedSides = getAllowedSides(sides3);
    let modifiedSides = [];
    switch (side) {
      case "all":
        modifiedSides = ["top", "bottom", "left", "right"];
        break;
      case "horizontal":
        modifiedSides = ["left", "right"];
        break;
      case "vertical":
        modifiedSides = ["top", "bottom"];
        break;
      default:
        modifiedSides = [side];
    }
    if (isAlt) {
      switch (side) {
        case "top":
          modifiedSides.push("bottom");
          break;
        case "bottom":
          modifiedSides.push("top");
          break;
        case "left":
          modifiedSides.push("left");
          break;
        case "right":
          modifiedSides.push("right");
          break;
      }
    }
    return modifiedSides.filter((s3) => allowedSides.has(s3));
  }
  function BoxInputControl({
    onChange = noop10,
    onFocus = noop10,
    values,
    selectedUnits,
    setSelectedUnits,
    sides: sides3,
    side,
    min: min3 = 0,
    presets,
    presetKey,
    placeholder: placeholderProp,
    ...props
  }) {
    const defaultValuesToModify = getSidesToModify(side, sides3);
    const handleOnFocus = (event) => {
      onFocus(event, {
        side
      });
    };
    const handleOnChange = (nextValues) => {
      onChange(nextValues);
    };
    const handleRawOnValueChange = (next2) => {
      const nextValues = {
        ...values
      };
      defaultValuesToModify.forEach((modifiedSide) => {
        nextValues[modifiedSide] = next2;
      });
      handleOnChange(nextValues);
    };
    const handleOnValueChange = (next2, extra) => {
      const nextValues = {
        ...values
      };
      const isNumeric = next2 !== void 0 && !isNaN(parseFloat(next2));
      const nextValue = isNumeric ? next2 : void 0;
      const modifiedSides = getSidesToModify(
        side,
        sides3,
        /**
         * Supports changing pair sides. For example, holding the ALT key
         * when changing the TOP will also update BOTTOM.
         */
        // @ts-expect-error - TODO: event.altKey is only present when the change event was
        // triggered by a keyboard event. Should this feature be implemented differently so
        // it also works with drag events?
        !!extra?.event.altKey
      );
      modifiedSides.forEach((modifiedSide) => {
        nextValues[modifiedSide] = nextValue;
      });
      handleOnChange(nextValues);
    };
    const handleOnUnitChange = (next2) => {
      const newUnits = {
        ...selectedUnits
      };
      defaultValuesToModify.forEach((modifiedSide) => {
        newUnits[modifiedSide] = next2;
      });
      setSelectedUnits(newUnits);
    };
    const mergedValue = getMergedValue(values, defaultValuesToModify);
    const hasValues = isValuesDefined(values);
    const isMixed = hasValues && defaultValuesToModify.length > 1 && isValueMixed(values, defaultValuesToModify);
    const [parsedQuantity, parsedUnit] = parseQuantityAndUnitFromRawValue(mergedValue);
    const computedUnit = hasValues ? parsedUnit : selectedUnits[defaultValuesToModify[0]];
    const generatedId = (0, import_compose37.useInstanceId)(BoxInputControl, "box-control-input");
    const inputId = [generatedId, side].join("-");
    const isMixedUnit = defaultValuesToModify.length > 1 && mergedValue === void 0 && defaultValuesToModify.some((s3) => selectedUnits[s3] !== computedUnit);
    const usedValue = mergedValue === void 0 && computedUnit ? computedUnit : mergedValue;
    const mixedPlaceholder = isMixed || isMixedUnit ? (0, import_i18n28.__)("Mixed") : void 0;
    const hasPresets = presets && presets.length > 0 && presetKey;
    const hasPresetValue = hasPresets && mergedValue !== void 0 && !isMixed && isValuePreset(mergedValue, presetKey);
    const [showCustomValueControl, setShowCustomValueControl] = (0, import_element90.useState)(!hasPresets || !hasPresetValue && !isMixed && mergedValue !== void 0);
    const presetIndex = hasPresetValue ? getPresetIndexFromValue(mergedValue, presetKey, presets) : void 0;
    const marks = hasPresets ? [{
      value: 0,
      label: "",
      tooltip: (0, import_i18n28.__)("None")
    }, ...presets.map((preset, index2) => ({
      value: index2 + 1,
      label: "",
      tooltip: preset.name ?? preset.slug
    }))] : [];
    return /* @__PURE__ */ (0, import_jsx_runtime155.jsxs)(InputWrapper, {
      expanded: true,
      children: [/* @__PURE__ */ (0, import_jsx_runtime155.jsx)(FlexedBoxControlIcon, {
        side,
        sides: sides3
      }), showCustomValueControl && /* @__PURE__ */ (0, import_jsx_runtime155.jsxs)(import_jsx_runtime155.Fragment, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime155.jsx)(tooltip_default, {
          placement: "top-end",
          text: LABELS[side],
          children: /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(StyledUnitControl, {
            ...props,
            min: min3,
            className: "component-box-control__unit-control",
            id: inputId,
            isPressEnterToChange: true,
            disableUnits: isMixed || isMixedUnit,
            value: usedValue,
            onChange: handleOnValueChange,
            onUnitChange: handleOnUnitChange,
            onFocus: handleOnFocus,
            label: LABELS[side],
            placeholder: mixedPlaceholder ?? placeholderProp,
            hideLabelFromVision: true
          })
        }), /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(FlexedRangeControl, {
          "aria-controls": inputId,
          label: LABELS[side],
          hideLabelFromVision: true,
          onChange: (newValue) => {
            handleOnValueChange(newValue !== void 0 ? [newValue, computedUnit].join("") : void 0);
          },
          min: isFinite(min3) ? min3 : 0,
          max: CUSTOM_VALUE_SETTINGS[computedUnit ?? "px"]?.max ?? 10,
          step: CUSTOM_VALUE_SETTINGS[computedUnit ?? "px"]?.step ?? 0.1,
          value: parsedQuantity ?? 0,
          withInputField: false
        })]
      }), hasPresets && !showCustomValueControl && /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(FlexedRangeControl, {
        className: "spacing-sizes-control__range-control",
        value: presetIndex !== void 0 ? presetIndex + 1 : 0,
        onChange: (newIndex) => {
          const newValue = newIndex === 0 || newIndex === void 0 ? void 0 : getPresetValueFromIndex(newIndex - 1, presetKey, presets);
          handleRawOnValueChange(newValue);
        },
        withInputField: false,
        "aria-valuenow": presetIndex !== void 0 ? presetIndex + 1 : 0,
        "aria-valuetext": marks[presetIndex !== void 0 ? presetIndex + 1 : 0].tooltip,
        renderTooltipContent: (index2) => marks[!index2 ? 0 : index2].tooltip,
        min: 0,
        max: marks.length - 1,
        marks,
        label: LABELS[side],
        hideLabelFromVision: true
      }), hasPresets && /* @__PURE__ */ (0, import_jsx_runtime155.jsx)(button_default, {
        label: showCustomValueControl ? (0, import_i18n28.__)("Use size preset") : (0, import_i18n28.__)("Set custom size"),
        icon: settings_default,
        onClick: () => {
          setShowCustomValueControl(!showCustomValueControl);
        },
        isPressed: showCustomValueControl,
        size: "small",
        iconSize: 24
      })]
    }, `box-control-${side}`);
  }

  // packages/components/build-module/box-control/linked-button.mjs
  var import_i18n29 = __toESM(require_i18n(), 1);
  var import_jsx_runtime156 = __toESM(require_jsx_runtime(), 1);
  function LinkedButton({
    isLinked,
    ...props
  }) {
    const label = isLinked ? (0, import_i18n29.__)("Unlink sides") : (0, import_i18n29.__)("Link sides");
    return /* @__PURE__ */ (0, import_jsx_runtime156.jsx)(button_default, {
      ...props,
      className: "component-box-control__linked-button",
      size: "small",
      icon: isLinked ? link_default : link_off_default,
      iconSize: 24,
      label
    });
  }

  // packages/components/build-module/box-control/index.mjs
  var import_jsx_runtime157 = __toESM(require_jsx_runtime(), 1);
  var defaultInputProps = {
    min: 0
  };
  var noop11 = () => {
  };
  function useUniqueId4(idProp) {
    const instanceId = (0, import_compose38.useInstanceId)(BoxControl, "inspector-box-control");
    return idProp || instanceId;
  }
  function BoxControl({
    id: idProp,
    inputProps = defaultInputProps,
    onChange = noop11,
    label = (0, import_i18n30.__)("Box Control"),
    values: valuesProp,
    units,
    sides: sides3,
    splitOnAxis = false,
    allowReset = true,
    resetValues = DEFAULT_VALUES,
    presets,
    presetKey,
    onMouseOver,
    onMouseOut
  }) {
    const [values, setValues] = use_controlled_state_default(valuesProp, {
      fallback: DEFAULT_VALUES
    });
    const inputValues = values || DEFAULT_VALUES;
    const hasInitialValue = isValuesDefined(valuesProp);
    const hasOneSide = sides3?.length === 1;
    const [isDirty, setIsDirty] = (0, import_element91.useState)(hasInitialValue);
    const [isLinked, setIsLinked] = (0, import_element91.useState)(!hasInitialValue || !isValueMixed(inputValues) || hasOneSide);
    const [selectedUnits, setSelectedUnits] = (0, import_element91.useState)({
      top: parseQuantityAndUnitFromRawValue(valuesProp?.top)[1],
      right: parseQuantityAndUnitFromRawValue(valuesProp?.right)[1],
      bottom: parseQuantityAndUnitFromRawValue(valuesProp?.bottom)[1],
      left: parseQuantityAndUnitFromRawValue(valuesProp?.left)[1]
    });
    const id3 = useUniqueId4(idProp);
    const headingId = `${id3}-heading`;
    const toggleLinked = () => {
      setIsLinked(!isLinked);
    };
    const handleOnChange = (nextValues) => {
      onChange(nextValues);
      setValues(nextValues);
      setIsDirty(true);
    };
    const handleOnReset = () => {
      onChange(resetValues);
      setValues(resetValues);
      setSelectedUnits(resetValues);
      setIsDirty(false);
    };
    const inputControlProps = {
      onMouseOver,
      onMouseOut,
      ...inputProps,
      onChange: handleOnChange,
      isLinked,
      units,
      selectedUnits,
      setSelectedUnits,
      sides: sides3,
      values: inputValues,
      presets,
      presetKey
    };
    const sidesToRender = getAllowedSides(sides3);
    if (presets && !presetKey || !presets && presetKey) {
      const definedProp = presets ? "presets" : "presetKey";
      const missingProp = presets ? "presetKey" : "presets";
      true ? (0, import_warning5.default)(`wp.components.BoxControl: the '${missingProp}' prop is required when the '${definedProp}' prop is defined.`) : void 0;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime157.jsxs)(component_default22, {
      id: id3,
      columns: 3,
      templateColumns: "1fr min-content min-content",
      role: "group",
      "aria-labelledby": headingId,
      children: [/* @__PURE__ */ (0, import_jsx_runtime157.jsx)(BaseControl.VisualLabel, {
        id: headingId,
        children: label
      }), isLinked && /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(InputWrapper, {
        children: /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(BoxInputControl, {
          side: "all",
          ...inputControlProps
        })
      }), !hasOneSide && /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(LinkedButtonWrapper, {
        children: /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(LinkedButton, {
          onClick: toggleLinked,
          isLinked
        })
      }), !isLinked && splitOnAxis && ["vertical", "horizontal"].map((axis) => /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(BoxInputControl, {
        side: axis,
        ...inputControlProps
      }, axis)), !isLinked && !splitOnAxis && Array.from(sidesToRender).map((axis) => /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(BoxInputControl, {
        side: axis,
        ...inputControlProps
      }, axis)), allowReset && /* @__PURE__ */ (0, import_jsx_runtime157.jsx)(ResetButton, {
        className: "component-box-control__reset-button",
        variant: "secondary",
        size: "small",
        onClick: handleOnReset,
        disabled: !isDirty,
        children: (0, import_i18n30.__)("Reset")
      })]
    });
  }
  var box_control_default = BoxControl;

  // packages/components/build-module/button-group/index.mjs
  var import_element92 = __toESM(require_element(), 1);
  var import_deprecated8 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime158 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedButtonGroup(props, ref) {
    const {
      className: className2,
      __shouldNotWarnDeprecated,
      ...restProps
    } = props;
    const classes = clsx_default("components-button-group", className2);
    if (!__shouldNotWarnDeprecated) {
      (0, import_deprecated8.default)("wp.components.ButtonGroup", {
        since: "6.8",
        alternative: "wp.components.__experimentalToggleGroupControl"
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime158.jsx)("div", {
      ref,
      role: "group",
      className: classes,
      ...restProps
    });
  }
  var ButtonGroup = (0, import_element92.forwardRef)(UnforwardedButtonGroup);
  ButtonGroup.displayName = "ButtonGroup";
  var button_group_default = ButtonGroup;

  // packages/components/build-module/card/card/component.mjs
  var import_element95 = __toESM(require_element(), 1);

  // packages/components/build-module/elevation/hook.mjs
  var import_element93 = __toESM(require_element(), 1);

  // packages/components/build-module/elevation/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__15() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Elevation = false ? {
    name: "12ip69d",
    styles: "background:transparent;display:block;margin:0!important;pointer-events:none;position:absolute;will-change:box-shadow"
  } : {
    name: "1n58bsy-Elevation",
    styles: "background:transparent;display:block;margin:0!important;pointer-events:none;position:absolute;will-change:box-shadow;label:Elevation;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLNEIiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG5leHBvcnQgY29uc3QgRWxldmF0aW9uID0gY3NzYFxuXHRiYWNrZ3JvdW5kOiB0cmFuc3BhcmVudDtcblx0ZGlzcGxheTogYmxvY2s7XG5cdG1hcmdpbjogMCAhaW1wb3J0YW50O1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHR3aWxsLWNoYW5nZTogYm94LXNoYWRvdztcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__15
  };

  // packages/components/build-module/elevation/hook.mjs
  function getBoxShadow(value) {
    const boxShadowColor = `rgba(0, 0, 0, ${value / 20})`;
    const boxShadow = `0 ${value}px ${value * 2}px 0
	${boxShadowColor}`;
    return boxShadow;
  }
  function useElevation(props) {
    const {
      active,
      borderRadius: borderRadius3 = "inherit",
      className: className2,
      focus: focus4,
      hover: hover2,
      isInteractive = false,
      offset: offset4 = 0,
      value = 0,
      ...otherProps
    } = useContextSystem(props, "Elevation");
    const cx2 = useCx();
    const classes = (0, import_element93.useMemo)(() => {
      let hoverValue = isValueDefined(hover2) ? hover2 : value * 2;
      let activeValue = isValueDefined(active) ? active : value / 2;
      if (!isInteractive) {
        hoverValue = isValueDefined(hover2) ? hover2 : void 0;
        activeValue = isValueDefined(active) ? active : void 0;
      }
      const transition = `box-shadow ${config_values_default.transitionDuration} ${config_values_default.transitionTimingFunction}`;
      const sx = {};
      sx.Base = /* @__PURE__ */ css({
        borderRadius: borderRadius3,
        bottom: offset4,
        boxShadow: getBoxShadow(value),
        opacity: config_values_default.elevationIntensity,
        left: offset4,
        right: offset4,
        top: offset4
      }, /* @__PURE__ */ css("@media not ( prefers-reduced-motion ){transition:", transition, ";}" + (false ? "" : ";label:sx-Base;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"), false ? "" : ";label:sx-Base;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      if (isValueDefined(hoverValue)) {
        sx.hover = /* @__PURE__ */ css("*:hover>&{box-shadow:", getBoxShadow(hoverValue), ";}" + (false ? "" : ";label:sx-hover;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      }
      if (isValueDefined(activeValue)) {
        sx.active = /* @__PURE__ */ css("*:active>&{box-shadow:", getBoxShadow(activeValue), ";}" + (false ? "" : ";label:sx-active;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      }
      if (isValueDefined(focus4)) {
        sx.focus = /* @__PURE__ */ css("*:focus>&{box-shadow:", getBoxShadow(focus4), ";}" + (false ? "" : ";label:sx-focus;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      }
      const elevationStyles = /* @__PURE__ */ css(Elevation, sx.Base, sx.hover, sx.focus, sx.active, false ? "" : ";label:elevationStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
      return cx2(elevationStyles, className2);
    }, [active, borderRadius3, className2, cx2, focus4, hover2, isInteractive, offset4, value]);
    return {
      ...otherProps,
      className: classes,
      "aria-hidden": true
    };
  }

  // packages/components/build-module/elevation/component.mjs
  var import_jsx_runtime159 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedElevation(props, forwardedRef) {
    const elevationProps = useElevation(props);
    return /* @__PURE__ */ (0, import_jsx_runtime159.jsx)(component_default, {
      ...elevationProps,
      ref: forwardedRef
    });
  }
  var Elevation2 = contextConnect(UnconnectedElevation, "Elevation");
  var component_default25 = Elevation2;

  // packages/components/build-module/card/get-padding-by-size.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__16() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var xSmallCardPadding = /* @__PURE__ */ css("padding:", space(2), ";" + (false ? "" : ";label:xSmallCardPadding;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var cardPaddings = {
    none: false ? {
      name: "1hcx8jb",
      styles: "padding:0"
    } : {
      name: "1nt59cd-none",
      styles: "padding:0;label:none;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
      toString: _EMOTION_STRINGIFIED_CSS_ERROR__16
    },
    large: /* @__PURE__ */ css("padding:", space(6), " ", space(8), ";" + (false ? "" : ";label:large;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),
    medium: /* @__PURE__ */ css("padding:", space(4), " ", space(6), ";" + (false ? "" : ";label:medium;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),
    small: /* @__PURE__ */ css("padding:", space(4), ";" + (false ? "" : ";label:small;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),
    xSmall: xSmallCardPadding,
    // The `extraSmall` size is not officially documented, but the following styles
    // are kept for legacy reasons to support older values of the `size` prop.
    extraSmall: xSmallCardPadding
  };
  var getSinglePaddingValue = (size4) => {
    switch (size4) {
      case "xSmall":
        return space(2);
      case "small":
        return space(4);
      case "medium":
        return space(6);
      case "large":
        return space(8);
      case "none":
        return "0";
      default:
        return space(6);
    }
  };
  var getPaddingBySize = (size4) => {
    if (typeof size4 === "string") {
      return cardPaddings[size4];
    }
    if (size4) {
      const {
        blockStart,
        blockEnd,
        inlineStart,
        inlineEnd
      } = size4;
      return /* @__PURE__ */ css("padding-block-start:", getSinglePaddingValue(blockStart), ";padding-block-end:", getSinglePaddingValue(blockEnd), ";padding-inline-start:", getSinglePaddingValue(inlineStart), ";padding-inline-end:", getSinglePaddingValue(inlineEnd), ";" + (false ? "" : ";label:getPaddingBySize;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
    }
    return cardPaddings.medium;
  };

  // packages/components/build-module/card/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__17() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var adjustedBorderRadius = `calc(${config_values_default.radiusLarge} - 1px)`;
  var Card = /* @__PURE__ */ css("box-shadow:0 0 0 1px ", config_values_default.surfaceBorderColor, ";outline:none;" + (false ? "" : ";label:Card;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var Header = false ? {
    name: "1showjb",
    styles: "border-bottom:1px solid;box-sizing:border-box;&:last-child{border-bottom:none;}"
  } : {
    name: "euqiwd-Header",
    styles: "border-bottom:1px solid;box-sizing:border-box;&:last-child{border-bottom:none;};label:Header;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var Footer = false ? {
    name: "14n5oej",
    styles: "border-top:1px solid;box-sizing:border-box;&:first-of-type{border-top:none;}"
  } : {
    name: "1rianq6-Footer",
    styles: "border-top:1px solid;box-sizing:border-box;&:first-of-type{border-top:none;};label:Footer;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var Content = false ? {
    name: "13udsys",
    styles: "height:100%"
  } : {
    name: "1ruapvy-Content",
    styles: "height:100%;label:Content;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var Body = false ? {
    name: "6ywzd",
    styles: "box-sizing:border-box;height:auto;max-height:100%"
  } : {
    name: "1klm29z-Body",
    styles: "box-sizing:border-box;height:auto;max-height:100%;label:Body;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var Media = false ? {
    name: "dq805e",
    styles: "box-sizing:border-box;overflow:hidden;&>img,&>iframe{display:block;height:auto;max-width:100%;width:100%;}"
  } : {
    name: "6f4wyb-Media",
    styles: "box-sizing:border-box;overflow:hidden;&>img,&>iframe{display:block;height:auto;max-width:100%;width:100%;};label:Media;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var Divider = false ? {
    name: "c990dr",
    styles: "box-sizing:border-box;display:block;width:100%"
  } : {
    name: "c5mt54-Divider",
    styles: "box-sizing:border-box;display:block;width:100%;label:Divider;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var borderRadius = /* @__PURE__ */ css("&:first-of-type{border-top-left-radius:", adjustedBorderRadius, ";border-top-right-radius:", adjustedBorderRadius, ";}&:last-of-type{border-bottom-left-radius:", adjustedBorderRadius, ";border-bottom-right-radius:", adjustedBorderRadius, ";}" + (false ? "" : ";label:borderRadius;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var borderColor = /* @__PURE__ */ css("border-color:", config_values_default.colorDivider, ";" + (false ? "" : ";label:borderColor;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var boxShadowless = false ? {
    name: "1t90u8d",
    styles: "box-shadow:none"
  } : {
    name: "14zofrl-boxShadowless",
    styles: "box-shadow:none;label:boxShadowless;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var borderless = false ? {
    name: "1e1ncky",
    styles: "border:none"
  } : {
    name: "kyy9w8-borderless",
    styles: "border:none;label:borderless;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__17
  };
  var rounded = /* @__PURE__ */ css("border-radius:", adjustedBorderRadius, ";" + (false ? "" : ";label:rounded;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var shady = /* @__PURE__ */ css("background-color:", COLORS.ui.backgroundDisabled, ";" + (false ? "" : ";label:shady;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  function getCardStyles({
    isBorderless,
    isRounded
  }) {
    const cardStyles = /* @__PURE__ */ css(Card, isBorderless && boxShadowless, isRounded && rounded, false ? "" : ";label:cardStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
    return cardStyles;
  }
  function getCardHeaderStyles({
    isBorderless,
    isShady,
    size: size4
  }) {
    const headerStyles = /* @__PURE__ */ css(Header, borderRadius, borderColor, getPaddingBySize(size4), isBorderless && borderless, isShady && shady, false ? "" : ";label:headerStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
    return headerStyles;
  }
  function getCardFooterStyles({
    isBorderless,
    isShady,
    size: size4
  }) {
    const footerStyles = /* @__PURE__ */ css(Footer, borderRadius, borderColor, getPaddingBySize(size4), isBorderless && borderless, isShady && shady, false ? "" : ";label:footerStyles;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
    return footerStyles;
  }

  // packages/components/build-module/card/card/hook.mjs
  var import_deprecated9 = __toESM(require_deprecated(), 1);
  var import_element94 = __toESM(require_element(), 1);

  // packages/components/build-module/surface/hook.mjs
  var STYLE_HASH_ATTRIBUTE9 = "data-wp-hash";
  function getRuntime9() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument9(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash9(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE9}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE9) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle9(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime9();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash9(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE9, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument9(targetDocument) {
    const runtime = getRuntime9();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle9(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle8(hash2, css3) {
    const runtime = getRuntime9();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle9(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle8("afa72ffb80", "._074d7c69bf27b61f__surface{background-color:var(--wpds-color-background-surface-neutral-strong,#fff);color:var(--wpds-color-foreground-content-neutral,#1e1e1e);position:relative}.c8e7f206d344f0be__border-bottom{border-bottom:var(--wpds-border-width-xs,1px) solid var(--wpds-color-stroke-surface-neutral,#dbdbdb)}._64aa30939d5e500b__border-left{border-left:var(--wpds-border-width-xs,1px) solid var(--wpds-color-stroke-surface-neutral,#dbdbdb)}._543f465ff38d9d77__border-right{border-right:var(--wpds-border-width-xs,1px) solid var(--wpds-color-stroke-surface-neutral,#dbdbdb)}._8aca9849530b97b1__border-top{border-top:var(--wpds-border-width-xs,1px) solid var(--wpds-color-stroke-surface-neutral,#dbdbdb)}._67628eb2296cfec7__secondary{background:var(--wpds-color-background-surface-neutral-weak,#f4f4f4)}._0efc0a4250262223__dotted{background:linear-gradient(90deg,var(--wpds-color-background-surface-neutral-strong,#fff) var(--wp-components-surface-background-size-dotted),transparent 1%) 50%,linear-gradient(var(--wpds-color-background-surface-neutral-strong,#fff) var(--wp-components-surface-background-size-dotted),transparent 1%) 50%,var(--wpds-color-stroke-surface-neutral,#dbdbdb);background-size:var(--wp-components-surface-background-size) var(--wp-components-surface-background-size)}._5e99093161bb409c__grid{background:var(--wpds-color-background-surface-neutral-strong,#fff);background-image:linear-gradient(var(--wpds-color-stroke-surface-neutral-weak,#f0f0f0) var(--wpds-border-width-xs,1px),transparent var(--wpds-border-width-xs,1px)),linear-gradient(90deg,var(--wpds-color-stroke-surface-neutral-weak,#f0f0f0) var(--wpds-border-width-xs,1px),transparent var(--wpds-border-width-xs,1px));background-size:var(--wp-components-surface-background-size) var(--wp-components-surface-background-size)}");
  }
  var style_module_default8 = { "surface": "_074d7c69bf27b61f__surface", "border-bottom": "c8e7f206d344f0be__border-bottom", "border-left": "_64aa30939d5e500b__border-left", "border-right": "_543f465ff38d9d77__border-right", "border-top": "_8aca9849530b97b1__border-top", "secondary": "_67628eb2296cfec7__secondary", "dotted": "_0efc0a4250262223__dotted", "grid": "_5e99093161bb409c__grid" };
  function useSurface(props) {
    const {
      backgroundSize = 12,
      borderBottom = false,
      borderLeft = false,
      borderRight = false,
      borderTop = false,
      className: className2,
      style: style2,
      variant = "primary",
      ...otherProps
    } = useContextSystem(props, "Surface");
    const hasPatternBackground = variant === "dotted" || variant === "grid";
    const surfaceStyle = hasPatternBackground ? {
      ...style2,
      "--wp-components-surface-background-size": `${backgroundSize}px`,
      "--wp-components-surface-background-size-dotted": `${backgroundSize - 1}px`
    } : style2;
    return {
      ...otherProps,
      className: clsx_default(style_module_default8.surface, {
        [style_module_default8["border-bottom"]]: borderBottom,
        [style_module_default8["border-left"]]: borderLeft,
        [style_module_default8["border-right"]]: borderRight,
        [style_module_default8["border-top"]]: borderTop,
        [style_module_default8.secondary]: variant === "secondary",
        [style_module_default8.dotted]: variant === "dotted",
        [style_module_default8.grid]: variant === "grid"
      }, className2),
      style: surfaceStyle
    };
  }

  // packages/components/build-module/surface/component.mjs
  var import_jsx_runtime160 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedSurface(props, forwardedRef) {
    const surfaceProps = useSurface(props);
    return /* @__PURE__ */ (0, import_jsx_runtime160.jsx)(component_default, {
      ...surfaceProps,
      ref: forwardedRef
    });
  }
  var Surface = contextConnect(UnconnectedSurface, "Surface");
  var component_default26 = Surface;

  // packages/components/build-module/card/card/hook.mjs
  function useDeprecatedProps4({
    elevation,
    isElevated,
    ...otherProps
  }) {
    const propsToReturn = {
      ...otherProps
    };
    let computedElevation = elevation;
    if (isElevated) {
      (0, import_deprecated9.default)("Card isElevated prop", {
        since: "5.9",
        alternative: "elevation"
      });
      computedElevation ??= 2;
    }
    if (typeof computedElevation !== "undefined") {
      propsToReturn.elevation = computedElevation;
    }
    return propsToReturn;
  }
  function useCard(props) {
    const {
      className: className2,
      elevation = 0,
      isBorderless = false,
      isRounded = true,
      size: size4 = "medium",
      ...otherProps
    } = useContextSystem(useDeprecatedProps4(props), "Card");
    const cx2 = useCx();
    const classes = (0, import_element94.useMemo)(() => {
      return cx2(getCardStyles({
        isBorderless,
        isRounded
      }), className2);
    }, [className2, cx2, isBorderless, isRounded]);
    const surfaceProps = useSurface({
      ...otherProps,
      className: classes
    });
    return {
      ...surfaceProps,
      elevation,
      isBorderless,
      isRounded,
      size: size4
    };
  }

  // packages/components/build-module/card/card/component.mjs
  var import_jsx_runtime161 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedCard(props, forwardedRef) {
    const {
      children,
      elevation,
      isBorderless,
      isRounded,
      size: size4,
      ...otherProps
    } = useCard(props);
    const elevationBorderRadius = isRounded ? config_values_default.radiusLarge : 0;
    const cx2 = useCx();
    const elevationClassName = (0, import_element95.useMemo)(() => cx2(/* @__PURE__ */ css({
      borderRadius: elevationBorderRadius
    }, false ? "" : ";label:elevationClassName;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */")), [cx2, elevationBorderRadius]);
    const contextProviderValue = (0, import_element95.useMemo)(() => {
      const contextProps = {
        size: size4,
        isBorderless
      };
      return {
        CardBody: contextProps,
        CardHeader: contextProps,
        CardFooter: contextProps
      };
    }, [isBorderless, size4]);
    return /* @__PURE__ */ (0, import_jsx_runtime161.jsx)(ContextSystemProvider, {
      value: contextProviderValue,
      children: /* @__PURE__ */ (0, import_jsx_runtime161.jsxs)(component_default, {
        ...otherProps,
        ref: forwardedRef,
        children: [/* @__PURE__ */ (0, import_jsx_runtime161.jsx)(component_default, {
          className: cx2(Content),
          children
        }), /* @__PURE__ */ (0, import_jsx_runtime161.jsx)(component_default25, {
          className: elevationClassName,
          isInteractive: false,
          value: elevation ? 1 : 0
        }), /* @__PURE__ */ (0, import_jsx_runtime161.jsx)(component_default25, {
          className: elevationClassName,
          isInteractive: false,
          value: elevation
        })]
      })
    });
  }
  var Card2 = contextConnect(UnconnectedCard, "Card");
  var component_default27 = Card2;

  // packages/components/build-module/scrollable/hook.mjs
  var import_element96 = __toESM(require_element(), 1);

  // packages/components/build-module/scrollable/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__18() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var scrollableScrollbar = /* @__PURE__ */ css("@media only screen and ( min-device-width: 40em ){&::-webkit-scrollbar{height:12px;width:12px;}&::-webkit-scrollbar-track{background-color:transparent;}&::-webkit-scrollbar-track{background:", config_values_default.colorScrollbarTrack, ";border-radius:8px;}&::-webkit-scrollbar-thumb{background-clip:padding-box;background-color:", config_values_default.colorScrollbarThumb, ";border:2px solid rgba( 0, 0, 0, 0 );border-radius:7px;}&:hover::-webkit-scrollbar-thumb{background-color:", config_values_default.colorScrollbarThumbHover, ";}}" + (false ? "" : ";label:scrollableScrollbar;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFVc0MiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBDT05GSUcgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBzY3JvbGxhYmxlU2Nyb2xsYmFyID0gY3NzYFxuXHRAbWVkaWEgb25seSBzY3JlZW4gYW5kICggbWluLWRldmljZS13aWR0aDogNDBlbSApIHtcblx0XHQmOjotd2Via2l0LXNjcm9sbGJhciB7XG5cdFx0XHRoZWlnaHQ6IDEycHg7XG5cdFx0XHR3aWR0aDogMTJweDtcblx0XHR9XG5cblx0XHQmOjotd2Via2l0LXNjcm9sbGJhci10cmFjayB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDtcblx0XHR9XG5cblx0XHQmOjotd2Via2l0LXNjcm9sbGJhci10cmFjayB7XG5cdFx0XHRiYWNrZ3JvdW5kOiAkeyBDT05GSUcuY29sb3JTY3JvbGxiYXJUcmFjayB9O1xuXHRcdFx0Ym9yZGVyLXJhZGl1czogOHB4O1xuXHRcdH1cblxuXHRcdCY6Oi13ZWJraXQtc2Nyb2xsYmFyLXRodW1iIHtcblx0XHRcdGJhY2tncm91bmQtY2xpcDogcGFkZGluZy1ib3g7XG5cdFx0XHRiYWNrZ3JvdW5kLWNvbG9yOiAkeyBDT05GSUcuY29sb3JTY3JvbGxiYXJUaHVtYiB9O1xuXHRcdFx0Ym9yZGVyOiAycHggc29saWQgcmdiYSggMCwgMCwgMCwgMCApO1xuXHRcdFx0Ym9yZGVyLXJhZGl1czogN3B4O1xuXHRcdH1cblxuXHRcdCY6aG92ZXI6Oi13ZWJraXQtc2Nyb2xsYmFyLXRodW1iIHtcblx0XHRcdGJhY2tncm91bmQtY29sb3I6ICR7IENPTkZJRy5jb2xvclNjcm9sbGJhclRodW1iSG92ZXIgfTtcblx0XHR9XG5cdH1cbmA7XG5cbmV4cG9ydCBjb25zdCBTY3JvbGxhYmxlID0gY3NzYFxuXHRoZWlnaHQ6IDEwMCU7XG5gO1xuXG5leHBvcnQgY29uc3QgQ29udGVudCA9IGNzc2Bcblx0cG9zaXRpb246IHJlbGF0aXZlO1xuYDtcblxuZXhwb3J0IGNvbnN0IHNtb290aFNjcm9sbCA9IGNzc2Bcblx0c2Nyb2xsLWJlaGF2aW9yOiBzbW9vdGg7XG5gO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsWCA9IGNzc2Bcblx0b3ZlcmZsb3cteDogYXV0bztcblx0b3ZlcmZsb3cteTogaGlkZGVuO1xuYDtcblxuZXhwb3J0IGNvbnN0IHNjcm9sbFkgPSBjc3NgXG5cdG92ZXJmbG93LXg6IGhpZGRlbjtcblx0b3ZlcmZsb3cteTogYXV0bztcbmA7XG5cbmV4cG9ydCBjb25zdCBzY3JvbGxBdXRvID0gY3NzYFxuXHRvdmVyZmxvdy15OiBhdXRvO1xuYDtcbiJdfQ== */");
  var Scrollable = false ? {
    name: "13udsys",
    styles: "height:100%"
  } : {
    name: "drdujb-Scrollable",
    styles: "height:100%;label:Scrollable;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF1QzZCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHIH0gZnJvbSAnLi4vdXRpbHMnO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsYWJsZVNjcm9sbGJhciA9IGNzc2Bcblx0QG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAoIG1pbi1kZXZpY2Utd2lkdGg6IDQwZW0gKSB7XG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXIge1xuXHRcdFx0aGVpZ2h0OiAxMnB4O1xuXHRcdFx0d2lkdGg6IDEycHg7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZDogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVHJhY2sgfTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDhweDtcblx0XHR9XG5cblx0XHQmOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNsaXA6IHBhZGRpbmctYm94O1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVGh1bWIgfTtcblx0XHRcdGJvcmRlcjogMnB4IHNvbGlkIHJnYmEoIDAsIDAsIDAsIDAgKTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDdweDtcblx0XHR9XG5cblx0XHQmOmhvdmVyOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNvbG9yOiAkeyBDT05GSUcuY29sb3JTY3JvbGxiYXJUaHVtYkhvdmVyIH07XG5cdFx0fVxuXHR9XG5gO1xuXG5leHBvcnQgY29uc3QgU2Nyb2xsYWJsZSA9IGNzc2Bcblx0aGVpZ2h0OiAxMDAlO1xuYDtcblxuZXhwb3J0IGNvbnN0IENvbnRlbnQgPSBjc3NgXG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzbW9vdGhTY3JvbGwgPSBjc3NgXG5cdHNjcm9sbC1iZWhhdmlvcjogc21vb3RoO1xuYDtcblxuZXhwb3J0IGNvbnN0IHNjcm9sbFggPSBjc3NgXG5cdG92ZXJmbG93LXg6IGF1dG87XG5cdG92ZXJmbG93LXk6IGhpZGRlbjtcbmA7XG5cbmV4cG9ydCBjb25zdCBzY3JvbGxZID0gY3NzYFxuXHRvdmVyZmxvdy14OiBoaWRkZW47XG5cdG92ZXJmbG93LXk6IGF1dG87XG5gO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsQXV0byA9IGNzc2Bcblx0b3ZlcmZsb3cteTogYXV0bztcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__18
  };
  var smoothScroll = false ? {
    name: "7zq9w",
    styles: "scroll-behavior:smooth"
  } : {
    name: "rnnynm-smoothScroll",
    styles: "scroll-behavior:smooth;label:smoothScroll;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUErQytCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHIH0gZnJvbSAnLi4vdXRpbHMnO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsYWJsZVNjcm9sbGJhciA9IGNzc2Bcblx0QG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAoIG1pbi1kZXZpY2Utd2lkdGg6IDQwZW0gKSB7XG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXIge1xuXHRcdFx0aGVpZ2h0OiAxMnB4O1xuXHRcdFx0d2lkdGg6IDEycHg7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZDogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVHJhY2sgfTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDhweDtcblx0XHR9XG5cblx0XHQmOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNsaXA6IHBhZGRpbmctYm94O1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVGh1bWIgfTtcblx0XHRcdGJvcmRlcjogMnB4IHNvbGlkIHJnYmEoIDAsIDAsIDAsIDAgKTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDdweDtcblx0XHR9XG5cblx0XHQmOmhvdmVyOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNvbG9yOiAkeyBDT05GSUcuY29sb3JTY3JvbGxiYXJUaHVtYkhvdmVyIH07XG5cdFx0fVxuXHR9XG5gO1xuXG5leHBvcnQgY29uc3QgU2Nyb2xsYWJsZSA9IGNzc2Bcblx0aGVpZ2h0OiAxMDAlO1xuYDtcblxuZXhwb3J0IGNvbnN0IENvbnRlbnQgPSBjc3NgXG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzbW9vdGhTY3JvbGwgPSBjc3NgXG5cdHNjcm9sbC1iZWhhdmlvcjogc21vb3RoO1xuYDtcblxuZXhwb3J0IGNvbnN0IHNjcm9sbFggPSBjc3NgXG5cdG92ZXJmbG93LXg6IGF1dG87XG5cdG92ZXJmbG93LXk6IGhpZGRlbjtcbmA7XG5cbmV4cG9ydCBjb25zdCBzY3JvbGxZID0gY3NzYFxuXHRvdmVyZmxvdy14OiBoaWRkZW47XG5cdG92ZXJmbG93LXk6IGF1dG87XG5gO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsQXV0byA9IGNzc2Bcblx0b3ZlcmZsb3cteTogYXV0bztcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__18
  };
  var scrollX = false ? {
    name: "q33xhg",
    styles: "overflow-x:auto;overflow-y:hidden"
  } : {
    name: "17z0rvw-scrollX",
    styles: "overflow-x:auto;overflow-y:hidden;label:scrollX;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFtRDBCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHIH0gZnJvbSAnLi4vdXRpbHMnO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsYWJsZVNjcm9sbGJhciA9IGNzc2Bcblx0QG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAoIG1pbi1kZXZpY2Utd2lkdGg6IDQwZW0gKSB7XG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXIge1xuXHRcdFx0aGVpZ2h0OiAxMnB4O1xuXHRcdFx0d2lkdGg6IDEycHg7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZDogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVHJhY2sgfTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDhweDtcblx0XHR9XG5cblx0XHQmOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNsaXA6IHBhZGRpbmctYm94O1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVGh1bWIgfTtcblx0XHRcdGJvcmRlcjogMnB4IHNvbGlkIHJnYmEoIDAsIDAsIDAsIDAgKTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDdweDtcblx0XHR9XG5cblx0XHQmOmhvdmVyOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNvbG9yOiAkeyBDT05GSUcuY29sb3JTY3JvbGxiYXJUaHVtYkhvdmVyIH07XG5cdFx0fVxuXHR9XG5gO1xuXG5leHBvcnQgY29uc3QgU2Nyb2xsYWJsZSA9IGNzc2Bcblx0aGVpZ2h0OiAxMDAlO1xuYDtcblxuZXhwb3J0IGNvbnN0IENvbnRlbnQgPSBjc3NgXG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzbW9vdGhTY3JvbGwgPSBjc3NgXG5cdHNjcm9sbC1iZWhhdmlvcjogc21vb3RoO1xuYDtcblxuZXhwb3J0IGNvbnN0IHNjcm9sbFggPSBjc3NgXG5cdG92ZXJmbG93LXg6IGF1dG87XG5cdG92ZXJmbG93LXk6IGhpZGRlbjtcbmA7XG5cbmV4cG9ydCBjb25zdCBzY3JvbGxZID0gY3NzYFxuXHRvdmVyZmxvdy14OiBoaWRkZW47XG5cdG92ZXJmbG93LXk6IGF1dG87XG5gO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsQXV0byA9IGNzc2Bcblx0b3ZlcmZsb3cteTogYXV0bztcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__18
  };
  var scrollY = false ? {
    name: "103x71s",
    styles: "overflow-x:hidden;overflow-y:auto"
  } : {
    name: "flie1-scrollY",
    styles: "overflow-x:hidden;overflow-y:auto;label:scrollY;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF3RDBCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHIH0gZnJvbSAnLi4vdXRpbHMnO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsYWJsZVNjcm9sbGJhciA9IGNzc2Bcblx0QG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAoIG1pbi1kZXZpY2Utd2lkdGg6IDQwZW0gKSB7XG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXIge1xuXHRcdFx0aGVpZ2h0OiAxMnB4O1xuXHRcdFx0d2lkdGg6IDEycHg7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZDogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVHJhY2sgfTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDhweDtcblx0XHR9XG5cblx0XHQmOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNsaXA6IHBhZGRpbmctYm94O1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVGh1bWIgfTtcblx0XHRcdGJvcmRlcjogMnB4IHNvbGlkIHJnYmEoIDAsIDAsIDAsIDAgKTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDdweDtcblx0XHR9XG5cblx0XHQmOmhvdmVyOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNvbG9yOiAkeyBDT05GSUcuY29sb3JTY3JvbGxiYXJUaHVtYkhvdmVyIH07XG5cdFx0fVxuXHR9XG5gO1xuXG5leHBvcnQgY29uc3QgU2Nyb2xsYWJsZSA9IGNzc2Bcblx0aGVpZ2h0OiAxMDAlO1xuYDtcblxuZXhwb3J0IGNvbnN0IENvbnRlbnQgPSBjc3NgXG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzbW9vdGhTY3JvbGwgPSBjc3NgXG5cdHNjcm9sbC1iZWhhdmlvcjogc21vb3RoO1xuYDtcblxuZXhwb3J0IGNvbnN0IHNjcm9sbFggPSBjc3NgXG5cdG92ZXJmbG93LXg6IGF1dG87XG5cdG92ZXJmbG93LXk6IGhpZGRlbjtcbmA7XG5cbmV4cG9ydCBjb25zdCBzY3JvbGxZID0gY3NzYFxuXHRvdmVyZmxvdy14OiBoaWRkZW47XG5cdG92ZXJmbG93LXk6IGF1dG87XG5gO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsQXV0byA9IGNzc2Bcblx0b3ZlcmZsb3cteTogYXV0bztcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__18
  };
  var scrollAuto = false ? {
    name: "umwchj",
    styles: "overflow-y:auto"
  } : {
    name: "1lcuu7v-scrollAuto",
    styles: "overflow-y:auto;label:scrollAuto;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE2RDZCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHIH0gZnJvbSAnLi4vdXRpbHMnO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsYWJsZVNjcm9sbGJhciA9IGNzc2Bcblx0QG1lZGlhIG9ubHkgc2NyZWVuIGFuZCAoIG1pbi1kZXZpY2Utd2lkdGg6IDQwZW0gKSB7XG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXIge1xuXHRcdFx0aGVpZ2h0OiAxMnB4O1xuXHRcdFx0d2lkdGg6IDEycHg7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdFx0fVxuXG5cdFx0Jjo6LXdlYmtpdC1zY3JvbGxiYXItdHJhY2sge1xuXHRcdFx0YmFja2dyb3VuZDogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVHJhY2sgfTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDhweDtcblx0XHR9XG5cblx0XHQmOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNsaXA6IHBhZGRpbmctYm94O1xuXHRcdFx0YmFja2dyb3VuZC1jb2xvcjogJHsgQ09ORklHLmNvbG9yU2Nyb2xsYmFyVGh1bWIgfTtcblx0XHRcdGJvcmRlcjogMnB4IHNvbGlkIHJnYmEoIDAsIDAsIDAsIDAgKTtcblx0XHRcdGJvcmRlci1yYWRpdXM6IDdweDtcblx0XHR9XG5cblx0XHQmOmhvdmVyOjotd2Via2l0LXNjcm9sbGJhci10aHVtYiB7XG5cdFx0XHRiYWNrZ3JvdW5kLWNvbG9yOiAkeyBDT05GSUcuY29sb3JTY3JvbGxiYXJUaHVtYkhvdmVyIH07XG5cdFx0fVxuXHR9XG5gO1xuXG5leHBvcnQgY29uc3QgU2Nyb2xsYWJsZSA9IGNzc2Bcblx0aGVpZ2h0OiAxMDAlO1xuYDtcblxuZXhwb3J0IGNvbnN0IENvbnRlbnQgPSBjc3NgXG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzbW9vdGhTY3JvbGwgPSBjc3NgXG5cdHNjcm9sbC1iZWhhdmlvcjogc21vb3RoO1xuYDtcblxuZXhwb3J0IGNvbnN0IHNjcm9sbFggPSBjc3NgXG5cdG92ZXJmbG93LXg6IGF1dG87XG5cdG92ZXJmbG93LXk6IGhpZGRlbjtcbmA7XG5cbmV4cG9ydCBjb25zdCBzY3JvbGxZID0gY3NzYFxuXHRvdmVyZmxvdy14OiBoaWRkZW47XG5cdG92ZXJmbG93LXk6IGF1dG87XG5gO1xuXG5leHBvcnQgY29uc3Qgc2Nyb2xsQXV0byA9IGNzc2Bcblx0b3ZlcmZsb3cteTogYXV0bztcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__18
  };

  // packages/components/build-module/scrollable/hook.mjs
  function useScrollable(props) {
    const {
      className: className2,
      scrollDirection = "y",
      smoothScroll: smoothScroll2 = false,
      ...otherProps
    } = useContextSystem(props, "Scrollable");
    const cx2 = useCx();
    const classes = (0, import_element96.useMemo)(() => cx2(Scrollable, scrollableScrollbar, smoothScroll2 && smoothScroll, scrollDirection === "x" && scrollX, scrollDirection === "y" && scrollY, scrollDirection === "auto" && scrollAuto, className2), [className2, cx2, scrollDirection, smoothScroll2]);
    return {
      ...otherProps,
      className: classes
    };
  }

  // packages/components/build-module/scrollable/component.mjs
  var import_jsx_runtime162 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedScrollable(props, forwardedRef) {
    const scrollableProps = useScrollable(props);
    return /* @__PURE__ */ (0, import_jsx_runtime162.jsx)(component_default, {
      ...scrollableProps,
      ref: forwardedRef
    });
  }
  var Scrollable2 = contextConnect(UnconnectedScrollable, "Scrollable");
  var component_default28 = Scrollable2;

  // packages/components/build-module/card/card-body/hook.mjs
  var import_element97 = __toESM(require_element(), 1);
  function useCardBody(props) {
    const {
      className: className2,
      isScrollable = false,
      isShady = false,
      size: size4 = "medium",
      ...otherProps
    } = useContextSystem(props, "CardBody");
    const cx2 = useCx();
    const classes = (0, import_element97.useMemo)(() => cx2(
      Body,
      borderRadius,
      getPaddingBySize(size4),
      isShady && shady,
      // This classname is added for legacy compatibility reasons.
      "components-card__body",
      className2
    ), [className2, cx2, isShady, size4]);
    return {
      ...otherProps,
      className: classes,
      isScrollable
    };
  }

  // packages/components/build-module/card/card-body/component.mjs
  var import_jsx_runtime163 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedCardBody(props, forwardedRef) {
    const {
      isScrollable,
      ...otherProps
    } = useCardBody(props);
    if (isScrollable) {
      return /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(component_default28, {
        ...otherProps,
        ref: forwardedRef
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime163.jsx)(component_default, {
      ...otherProps,
      ref: forwardedRef
    });
  }
  var CardBody = contextConnect(UnconnectedCardBody, "CardBody");
  var component_default29 = CardBody;

  // packages/components/build-module/divider/component.mjs
  var import_jsx_runtime164 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE10 = "data-wp-hash";
  function getRuntime10() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument10(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash10(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE10}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE10) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle10(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime10();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash10(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE10, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument10(targetDocument) {
    const runtime = getRuntime10();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle10(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle9(hash2, css3) {
    const runtime = getRuntime10();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle10(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle9("b6ebee9322", ".e10c29fc10c181dc__divider{border:0;margin:0}.e10c29fc10c181dc__divider:where([aria-orientation=horizontal]){block-size:0;border-block-end:1px solid currentColor;inline-size:auto;margin-block-end:var(--wp-components-divider-margin-end,0);margin-block-start:var(--wp-components-divider-margin-start,0)}.e10c29fc10c181dc__divider:where([aria-orientation=vertical]){block-size:auto;border-inline-end:1px solid currentColor;display:inline;inline-size:0;margin-inline-end:var(--wp-components-divider-margin-end,0);margin-inline-start:var(--wp-components-divider-margin-start,0)}");
  }
  var style_module_default9 = { "divider": "e10c29fc10c181dc__divider" };
  function UnconnectedDivider(props, forwardedRef) {
    const {
      className: className2,
      margin,
      marginEnd,
      marginStart,
      style: style2,
      ...contextProps
    } = useContextSystem(props, "Divider");
    const dividerStyle = {
      ...style2
    };
    const resolvedMarginStart = space(marginStart ?? margin);
    const resolvedMarginEnd = space(marginEnd ?? margin);
    if (resolvedMarginStart) {
      dividerStyle["--wp-components-divider-margin-start"] = resolvedMarginStart;
    }
    if (resolvedMarginEnd) {
      dividerStyle["--wp-components-divider-margin-end"] = resolvedMarginEnd;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime164.jsx)(Separator, {
      className: clsx_default(style_module_default9.divider, className2),
      style: dividerStyle,
      ...contextProps,
      ref: forwardedRef
    });
  }
  var Divider2 = contextConnect(UnconnectedDivider, "Divider");
  var component_default30 = Divider2;

  // packages/components/build-module/card/card-divider/hook.mjs
  var import_element98 = __toESM(require_element(), 1);
  function useCardDivider(props) {
    const {
      className: className2,
      ...otherProps
    } = useContextSystem(props, "CardDivider");
    const cx2 = useCx();
    const classes = (0, import_element98.useMemo)(() => cx2(
      Divider,
      borderColor,
      // This classname is added for legacy compatibility reasons.
      "components-card__divider",
      className2
    ), [className2, cx2]);
    return {
      ...otherProps,
      className: classes
    };
  }

  // packages/components/build-module/card/card-divider/component.mjs
  var import_jsx_runtime165 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedCardDivider(props, forwardedRef) {
    const dividerProps = useCardDivider(props);
    return /* @__PURE__ */ (0, import_jsx_runtime165.jsx)(component_default30, {
      ...dividerProps,
      ref: forwardedRef
    });
  }
  var CardDivider = contextConnect(UnconnectedCardDivider, "CardDivider");
  var component_default31 = CardDivider;

  // packages/components/build-module/card/card-footer/hook.mjs
  var import_element99 = __toESM(require_element(), 1);
  function useCardFooter(props) {
    const {
      className: className2,
      justify,
      isBorderless = false,
      isShady = false,
      size: size4 = "medium",
      ...otherProps
    } = useContextSystem(props, "CardFooter");
    const cx2 = useCx();
    const classes = (0, import_element99.useMemo)(() => {
      return cx2(
        getCardFooterStyles({
          isBorderless,
          isShady,
          size: size4
        }),
        // This classname is added for legacy compatibility reasons.
        "components-card__footer",
        className2
      );
    }, [className2, cx2, isBorderless, isShady, size4]);
    return {
      ...otherProps,
      className: classes,
      justify
    };
  }

  // packages/components/build-module/card/card-footer/component.mjs
  var import_jsx_runtime166 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedCardFooter(props, forwardedRef) {
    const footerProps = useCardFooter(props);
    return /* @__PURE__ */ (0, import_jsx_runtime166.jsx)(component_default3, {
      ...footerProps,
      ref: forwardedRef
    });
  }
  var CardFooter = contextConnect(UnconnectedCardFooter, "CardFooter");
  var component_default32 = CardFooter;

  // packages/components/build-module/card/card-header/hook.mjs
  var import_element100 = __toESM(require_element(), 1);
  function useCardHeader(props) {
    const {
      className: className2,
      isBorderless = false,
      isShady = false,
      size: size4 = "medium",
      ...otherProps
    } = useContextSystem(props, "CardHeader");
    const cx2 = useCx();
    const classes = (0, import_element100.useMemo)(() => {
      return cx2(
        getCardHeaderStyles({
          isBorderless,
          isShady,
          size: size4
        }),
        // This classname is added for legacy compatibility reasons.
        "components-card__header",
        className2
      );
    }, [className2, cx2, isBorderless, isShady, size4]);
    return {
      ...otherProps,
      className: classes
    };
  }

  // packages/components/build-module/card/card-header/component.mjs
  var import_jsx_runtime167 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedCardHeader(props, forwardedRef) {
    const headerProps = useCardHeader(props);
    return /* @__PURE__ */ (0, import_jsx_runtime167.jsx)(component_default3, {
      ...headerProps,
      ref: forwardedRef
    });
  }
  var CardHeader = contextConnect(UnconnectedCardHeader, "CardHeader");
  var component_default33 = CardHeader;

  // packages/components/build-module/card/card-media/hook.mjs
  var import_element101 = __toESM(require_element(), 1);
  function useCardMedia(props) {
    const {
      className: className2,
      ...otherProps
    } = useContextSystem(props, "CardMedia");
    const cx2 = useCx();
    const classes = (0, import_element101.useMemo)(() => cx2(
      Media,
      borderRadius,
      // This classname is added for legacy compatibility reasons.
      "components-card__media",
      className2
    ), [className2, cx2]);
    return {
      ...otherProps,
      className: classes
    };
  }

  // packages/components/build-module/card/card-media/component.mjs
  var import_jsx_runtime168 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedCardMedia(props, forwardedRef) {
    const cardMediaProps = useCardMedia(props);
    return /* @__PURE__ */ (0, import_jsx_runtime168.jsx)(component_default, {
      ...cardMediaProps,
      ref: forwardedRef
    });
  }
  var CardMedia = contextConnect(UnconnectedCardMedia, "CardMedia");
  var component_default34 = CardMedia;

  // packages/components/build-module/checkbox-control/index.mjs
  var import_element102 = __toESM(require_element(), 1);
  var import_compose39 = __toESM(require_compose(), 1);
  var import_deprecated10 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime169 = __toESM(require_jsx_runtime(), 1);
  function CheckboxControl(props) {
    const {
      // Prevent passing this to `input`.
      __nextHasNoMarginBottom: _2,
      label,
      className: className2,
      heading,
      checked,
      indeterminate,
      help,
      id: idProp,
      onChange,
      onClick,
      ...additionalProps
    } = props;
    if (heading) {
      (0, import_deprecated10.default)("`heading` prop in `CheckboxControl`", {
        alternative: "a separate element to implement a heading",
        since: "5.8"
      });
    }
    const [showCheckedIcon, setShowCheckedIcon] = (0, import_element102.useState)(false);
    const [showIndeterminateIcon, setShowIndeterminateIcon] = (0, import_element102.useState)(false);
    const ref = (0, import_compose39.useRefEffect)((node2) => {
      if (!node2) {
        return;
      }
      node2.indeterminate = !!indeterminate;
      setShowCheckedIcon(node2.matches(":checked"));
      setShowIndeterminateIcon(node2.matches(":indeterminate"));
    }, [checked, indeterminate]);
    const id3 = (0, import_compose39.useInstanceId)(CheckboxControl, "inspector-checkbox-control", idProp);
    const onChangeValue = (event) => onChange(event.target.checked);
    return /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(base_control_default, {
      label: heading,
      id: id3,
      help: help && /* @__PURE__ */ (0, import_jsx_runtime169.jsx)("span", {
        className: "components-checkbox-control__help",
        children: help
      }),
      className: clsx_default("components-checkbox-control", className2),
      children: /* @__PURE__ */ (0, import_jsx_runtime169.jsxs)(component_default9, {
        spacing: 0,
        justify: "start",
        alignment: "top",
        children: [/* @__PURE__ */ (0, import_jsx_runtime169.jsxs)("span", {
          className: "components-checkbox-control__input-container",
          children: [/* @__PURE__ */ (0, import_jsx_runtime169.jsx)("input", {
            ref,
            id: id3,
            className: "components-checkbox-control__input",
            type: "checkbox",
            value: "1",
            onChange: onChangeValue,
            checked,
            "aria-describedby": !!help ? id3 + "__help" : void 0,
            onClick: (event) => {
              event.currentTarget.focus();
              onClick?.(event);
            },
            ...additionalProps
          }), showIndeterminateIcon ? /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(icon_default2, {
            icon: reset_default,
            className: "components-checkbox-control__indeterminate",
            role: "presentation"
          }) : null, showCheckedIcon ? /* @__PURE__ */ (0, import_jsx_runtime169.jsx)(icon_default2, {
            icon: check_default,
            className: "components-checkbox-control__checked",
            role: "presentation"
          }) : null]
        }), label && /* @__PURE__ */ (0, import_jsx_runtime169.jsx)("label", {
          className: "components-checkbox-control__label",
          htmlFor: id3,
          children: label
        })]
      })
    });
  }
  var checkbox_control_default = CheckboxControl;

  // packages/components/build-module/clipboard-button/index.mjs
  var import_element103 = __toESM(require_element(), 1);
  var import_compose40 = __toESM(require_compose(), 1);
  var import_deprecated11 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime170 = __toESM(require_jsx_runtime(), 1);
  var TIMEOUT = 4e3;
  function ClipboardButton({
    className: className2,
    children,
    onCopy,
    onFinishCopy,
    text,
    ...buttonProps
  }) {
    (0, import_deprecated11.default)("wp.components.ClipboardButton", {
      since: "5.8",
      alternative: "wp.compose.useCopyToClipboard"
    });
    const timeoutIdRef = (0, import_element103.useRef)(void 0);
    const ref = (0, import_compose40.useCopyToClipboard)(text, () => {
      onCopy();
      if (timeoutIdRef.current) {
        clearTimeout(timeoutIdRef.current);
      }
      if (onFinishCopy) {
        timeoutIdRef.current = setTimeout(() => onFinishCopy(), TIMEOUT);
      }
    });
    (0, import_element103.useEffect)(() => {
      return () => {
        if (timeoutIdRef.current) {
          clearTimeout(timeoutIdRef.current);
        }
      };
    }, []);
    const classes = clsx_default("components-clipboard-button", className2);
    const focusOnCopyEventTarget = (event) => {
      event.target.focus();
    };
    return (
      // Disable reasons: the parent component takes care of the __next40pxDefaultSize prop.
      // eslint-disable-next-line @wordpress/components-no-missing-40px-size-prop
      /* @__PURE__ */ (0, import_jsx_runtime170.jsx)(button_default, {
        ...buttonProps,
        className: classes,
        ref,
        onCopy: focusOnCopyEventTarget,
        children
      })
    );
  }

  // packages/components/build-module/palette-edit/index.mjs
  var import_element113 = __toESM(require_element(), 1);
  var import_i18n35 = __toESM(require_i18n(), 1);
  var import_compose44 = __toESM(require_compose(), 1);

  // packages/components/build-module/item-group/item/hook.mjs
  var import_element105 = __toESM(require_element(), 1);

  // packages/components/build-module/item-group/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__19() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var unstyledButton = (as) => {
    return /* @__PURE__ */ css("font-size:", font("default.fontSize"), ";font-family:inherit;appearance:none;border:1px solid transparent;cursor:pointer;background:none;text-align:start;text-decoration:", as === "a" ? "none" : void 0, ";svg,path{fill:currentColor;}&:hover{color:", COLORS.theme.accent, ";}&:focus{box-shadow:none;outline:none;}&:focus-visible{box-shadow:0 0 0 var( --wp-admin-border-width-focus ) ", COLORS.theme.accent, ";outline:2px solid transparent;outline-offset:0;}" + (false ? "" : ";label:unstyledButton;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  };
  var itemWrapper = false ? {
    name: "1bcj5ek",
    styles: "width:100%;display:block"
  } : {
    name: "dcjs67-itemWrapper",
    styles: "width:100%;display:block;label:itemWrapper;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__19
  };
  var item = false ? {
    name: "150ruhm",
    styles: "box-sizing:border-box;width:100%;display:block;margin:0;color:inherit"
  } : {
    name: "1izz8ne-item",
    styles: "box-sizing:border-box;width:100%;display:block;margin:0;color:inherit;label:item;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFrRHVCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHLCBDT0xPUlMsIGZvbnQgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCB1bnN0eWxlZEJ1dHRvbiA9ICggYXM6ICdhJyB8ICdidXR0b24nICkgPT4ge1xuXHRyZXR1cm4gY3NzYFxuXHRcdGZvbnQtc2l6ZTogJHsgZm9udCggJ2RlZmF1bHQuZm9udFNpemUnICkgfTtcblx0XHRmb250LWZhbWlseTogaW5oZXJpdDtcblx0XHRhcHBlYXJhbmNlOiBub25lO1xuXHRcdGJvcmRlcjogMXB4IHNvbGlkIHRyYW5zcGFyZW50O1xuXHRcdGN1cnNvcjogcG9pbnRlcjtcblx0XHRiYWNrZ3JvdW5kOiBub25lO1xuXHRcdHRleHQtYWxpZ246IHN0YXJ0O1xuXHRcdHRleHQtZGVjb3JhdGlvbjogJHsgYXMgPT09ICdhJyA/ICdub25lJyA6IHVuZGVmaW5lZCB9O1xuXG5cdFx0c3ZnLFxuXHRcdHBhdGgge1xuXHRcdFx0ZmlsbDogY3VycmVudENvbG9yO1xuXHRcdH1cblxuXHRcdCY6aG92ZXIge1xuXHRcdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5hY2NlbnQgfTtcblx0XHR9XG5cblx0XHQmOmZvY3VzIHtcblx0XHRcdGJveC1zaGFkb3c6IG5vbmU7XG5cdFx0XHRvdXRsaW5lOiBub25lO1xuXHRcdH1cblxuXHRcdCY6Zm9jdXMtdmlzaWJsZSB7XG5cdFx0XHRib3gtc2hhZG93OiAwIDAgMCB2YXIoIC0td3AtYWRtaW4tYm9yZGVyLXdpZHRoLWZvY3VzIClcblx0XHRcdFx0JHsgQ09MT1JTLnRoZW1lLmFjY2VudCB9O1xuXHRcdFx0Ly8gV2luZG93cyBoaWdoIGNvbnRyYXN0IG1vZGUuXG5cdFx0XHRvdXRsaW5lOiAycHggc29saWQgdHJhbnNwYXJlbnQ7XG5cdFx0XHRvdXRsaW5lLW9mZnNldDogMDtcblx0XHR9XG5cdGA7XG59O1xuXG5leHBvcnQgY29uc3QgaXRlbVdyYXBwZXIgPSBjc3NgXG5cdHdpZHRoOiAxMDAlO1xuXHRkaXNwbGF5OiBibG9jaztcbmA7XG5cbmV4cG9ydCBjb25zdCBpdGVtID0gY3NzYFxuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHR3aWR0aDogMTAwJTtcblx0ZGlzcGxheTogYmxvY2s7XG5cdG1hcmdpbjogMDtcblx0Y29sb3I6IGluaGVyaXQ7XG5gO1xuXG5leHBvcnQgY29uc3QgYm9yZGVyZWQgPSBjc3NgXG5cdGJvcmRlcjogMXB4IHNvbGlkICR7IENPTkZJRy5zdXJmYWNlQm9yZGVyQ29sb3IgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzZXBhcmF0ZWQgPSBjc3NgXG5cdD4gKjpub3QoIG1hcnF1ZWUgKSA+ICoge1xuXHRcdGJvcmRlci1ib3R0b206IDFweCBzb2xpZCAkeyBDT05GSUcuc3VyZmFjZUJvcmRlckNvbG9yIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdH1cbmA7XG5cbmNvbnN0IGJvcmRlclJhZGl1cyA9IENPTkZJRy5yYWRpdXNTbWFsbDtcblxuZXhwb3J0IGNvbnN0IHNwYWNlZEFyb3VuZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5gO1xuXG5leHBvcnQgY29uc3Qgcm91bmRlZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cblx0PiAqOmZpcnN0LW9mLXR5cGUgPiAqIHtcblx0XHRib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAkeyBib3JkZXJSYWRpdXMgfTtcblx0XHRib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdFx0Ym9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6ICR7IGJvcmRlclJhZGl1cyB9O1xuXHR9XG5gO1xuXG5jb25zdCBiYXNlRm9udEhlaWdodCA9IGBjYWxjKCR7IENPTkZJRy5mb250U2l6ZSB9ICogJHsgQ09ORklHLmZvbnRMaW5lSGVpZ2h0QmFzZSB9KWA7XG5cbi8qXG4gKiBNYXRoOlxuICogLSBVc2UgdGhlIGRlc2lyZWQgaGVpZ2h0IGFzIHRoZSBiYXNlIHZhbHVlXG4gKiAtIFN1YnRyYWN0IHRoZSBjb21wdXRlZCBoZWlnaHQgb2YgKGRlZmF1bHQpIHRleHRcbiAqIC0gU3VidHJhY3QgdGhlIGVmZmVjdHMgb2YgYm9yZGVyXG4gKiAtIERpdmlkZSB0aGUgY2FsY3VsYXRlZCBudW1iZXIgYnkgMiwgaW4gb3JkZXIgdG8gZ2V0IGFuIGluZGl2aWR1YWwgdG9wL2JvdHRvbSBwYWRkaW5nXG4gKi9cbmNvbnN0IHBhZGRpbmdZID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0IH0gLSAkeyBiYXNlRm9udEhlaWdodCB9IC0gMnB4KSAvIDIpYDtcbmNvbnN0IHBhZGRpbmdZU21hbGwgPSBgY2FsYygoJHsgQ09ORklHLmNvbnRyb2xIZWlnaHRTbWFsbCB9IC0gJHsgYmFzZUZvbnRIZWlnaHQgfSAtIDJweCkgLyAyKWA7XG5jb25zdCBwYWRkaW5nWUxhcmdlID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0TGFyZ2UgfSAtICR7IGJhc2VGb250SGVpZ2h0IH0gLSAycHgpIC8gMilgO1xuXG5leHBvcnQgY29uc3QgaXRlbVNpemVzID0ge1xuXHRzbWFsbDogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZU21hbGwgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYU21hbGwgfXB4O1xuXHRgLFxuXHRtZWRpdW06IGNzc2Bcblx0XHRwYWRkaW5nOiAkeyBwYWRkaW5nWSB9ICR7IENPTkZJRy5jb250cm9sUGFkZGluZ1ggfXB4O1xuXHRgLFxuXHRsYXJnZTogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZTGFyZ2UgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYTGFyZ2UgfXB4O1xuXHRgLFxufTtcbiJdfQ== */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__19
  };
  var bordered = /* @__PURE__ */ css("border:1px solid ", config_values_default.surfaceBorderColor, ";" + (false ? "" : ";label:bordered;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEwRDJCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHLCBDT0xPUlMsIGZvbnQgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCB1bnN0eWxlZEJ1dHRvbiA9ICggYXM6ICdhJyB8ICdidXR0b24nICkgPT4ge1xuXHRyZXR1cm4gY3NzYFxuXHRcdGZvbnQtc2l6ZTogJHsgZm9udCggJ2RlZmF1bHQuZm9udFNpemUnICkgfTtcblx0XHRmb250LWZhbWlseTogaW5oZXJpdDtcblx0XHRhcHBlYXJhbmNlOiBub25lO1xuXHRcdGJvcmRlcjogMXB4IHNvbGlkIHRyYW5zcGFyZW50O1xuXHRcdGN1cnNvcjogcG9pbnRlcjtcblx0XHRiYWNrZ3JvdW5kOiBub25lO1xuXHRcdHRleHQtYWxpZ246IHN0YXJ0O1xuXHRcdHRleHQtZGVjb3JhdGlvbjogJHsgYXMgPT09ICdhJyA/ICdub25lJyA6IHVuZGVmaW5lZCB9O1xuXG5cdFx0c3ZnLFxuXHRcdHBhdGgge1xuXHRcdFx0ZmlsbDogY3VycmVudENvbG9yO1xuXHRcdH1cblxuXHRcdCY6aG92ZXIge1xuXHRcdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5hY2NlbnQgfTtcblx0XHR9XG5cblx0XHQmOmZvY3VzIHtcblx0XHRcdGJveC1zaGFkb3c6IG5vbmU7XG5cdFx0XHRvdXRsaW5lOiBub25lO1xuXHRcdH1cblxuXHRcdCY6Zm9jdXMtdmlzaWJsZSB7XG5cdFx0XHRib3gtc2hhZG93OiAwIDAgMCB2YXIoIC0td3AtYWRtaW4tYm9yZGVyLXdpZHRoLWZvY3VzIClcblx0XHRcdFx0JHsgQ09MT1JTLnRoZW1lLmFjY2VudCB9O1xuXHRcdFx0Ly8gV2luZG93cyBoaWdoIGNvbnRyYXN0IG1vZGUuXG5cdFx0XHRvdXRsaW5lOiAycHggc29saWQgdHJhbnNwYXJlbnQ7XG5cdFx0XHRvdXRsaW5lLW9mZnNldDogMDtcblx0XHR9XG5cdGA7XG59O1xuXG5leHBvcnQgY29uc3QgaXRlbVdyYXBwZXIgPSBjc3NgXG5cdHdpZHRoOiAxMDAlO1xuXHRkaXNwbGF5OiBibG9jaztcbmA7XG5cbmV4cG9ydCBjb25zdCBpdGVtID0gY3NzYFxuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHR3aWR0aDogMTAwJTtcblx0ZGlzcGxheTogYmxvY2s7XG5cdG1hcmdpbjogMDtcblx0Y29sb3I6IGluaGVyaXQ7XG5gO1xuXG5leHBvcnQgY29uc3QgYm9yZGVyZWQgPSBjc3NgXG5cdGJvcmRlcjogMXB4IHNvbGlkICR7IENPTkZJRy5zdXJmYWNlQm9yZGVyQ29sb3IgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzZXBhcmF0ZWQgPSBjc3NgXG5cdD4gKjpub3QoIG1hcnF1ZWUgKSA+ICoge1xuXHRcdGJvcmRlci1ib3R0b206IDFweCBzb2xpZCAkeyBDT05GSUcuc3VyZmFjZUJvcmRlckNvbG9yIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdH1cbmA7XG5cbmNvbnN0IGJvcmRlclJhZGl1cyA9IENPTkZJRy5yYWRpdXNTbWFsbDtcblxuZXhwb3J0IGNvbnN0IHNwYWNlZEFyb3VuZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5gO1xuXG5leHBvcnQgY29uc3Qgcm91bmRlZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cblx0PiAqOmZpcnN0LW9mLXR5cGUgPiAqIHtcblx0XHRib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAkeyBib3JkZXJSYWRpdXMgfTtcblx0XHRib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdFx0Ym9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6ICR7IGJvcmRlclJhZGl1cyB9O1xuXHR9XG5gO1xuXG5jb25zdCBiYXNlRm9udEhlaWdodCA9IGBjYWxjKCR7IENPTkZJRy5mb250U2l6ZSB9ICogJHsgQ09ORklHLmZvbnRMaW5lSGVpZ2h0QmFzZSB9KWA7XG5cbi8qXG4gKiBNYXRoOlxuICogLSBVc2UgdGhlIGRlc2lyZWQgaGVpZ2h0IGFzIHRoZSBiYXNlIHZhbHVlXG4gKiAtIFN1YnRyYWN0IHRoZSBjb21wdXRlZCBoZWlnaHQgb2YgKGRlZmF1bHQpIHRleHRcbiAqIC0gU3VidHJhY3QgdGhlIGVmZmVjdHMgb2YgYm9yZGVyXG4gKiAtIERpdmlkZSB0aGUgY2FsY3VsYXRlZCBudW1iZXIgYnkgMiwgaW4gb3JkZXIgdG8gZ2V0IGFuIGluZGl2aWR1YWwgdG9wL2JvdHRvbSBwYWRkaW5nXG4gKi9cbmNvbnN0IHBhZGRpbmdZID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0IH0gLSAkeyBiYXNlRm9udEhlaWdodCB9IC0gMnB4KSAvIDIpYDtcbmNvbnN0IHBhZGRpbmdZU21hbGwgPSBgY2FsYygoJHsgQ09ORklHLmNvbnRyb2xIZWlnaHRTbWFsbCB9IC0gJHsgYmFzZUZvbnRIZWlnaHQgfSAtIDJweCkgLyAyKWA7XG5jb25zdCBwYWRkaW5nWUxhcmdlID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0TGFyZ2UgfSAtICR7IGJhc2VGb250SGVpZ2h0IH0gLSAycHgpIC8gMilgO1xuXG5leHBvcnQgY29uc3QgaXRlbVNpemVzID0ge1xuXHRzbWFsbDogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZU21hbGwgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYU21hbGwgfXB4O1xuXHRgLFxuXHRtZWRpdW06IGNzc2Bcblx0XHRwYWRkaW5nOiAkeyBwYWRkaW5nWSB9ICR7IENPTkZJRy5jb250cm9sUGFkZGluZ1ggfXB4O1xuXHRgLFxuXHRsYXJnZTogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZTGFyZ2UgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYTGFyZ2UgfXB4O1xuXHRgLFxufTtcbiJdfQ== */");
  var separated = /* @__PURE__ */ css(">*:not( marquee )>*{border-bottom:1px solid ", config_values_default.surfaceBorderColor, ";}>*:last-of-type>*{border-bottom-color:transparent;}" + (false ? "" : ";label:separated;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE4RDRCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHLCBDT0xPUlMsIGZvbnQgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCB1bnN0eWxlZEJ1dHRvbiA9ICggYXM6ICdhJyB8ICdidXR0b24nICkgPT4ge1xuXHRyZXR1cm4gY3NzYFxuXHRcdGZvbnQtc2l6ZTogJHsgZm9udCggJ2RlZmF1bHQuZm9udFNpemUnICkgfTtcblx0XHRmb250LWZhbWlseTogaW5oZXJpdDtcblx0XHRhcHBlYXJhbmNlOiBub25lO1xuXHRcdGJvcmRlcjogMXB4IHNvbGlkIHRyYW5zcGFyZW50O1xuXHRcdGN1cnNvcjogcG9pbnRlcjtcblx0XHRiYWNrZ3JvdW5kOiBub25lO1xuXHRcdHRleHQtYWxpZ246IHN0YXJ0O1xuXHRcdHRleHQtZGVjb3JhdGlvbjogJHsgYXMgPT09ICdhJyA/ICdub25lJyA6IHVuZGVmaW5lZCB9O1xuXG5cdFx0c3ZnLFxuXHRcdHBhdGgge1xuXHRcdFx0ZmlsbDogY3VycmVudENvbG9yO1xuXHRcdH1cblxuXHRcdCY6aG92ZXIge1xuXHRcdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5hY2NlbnQgfTtcblx0XHR9XG5cblx0XHQmOmZvY3VzIHtcblx0XHRcdGJveC1zaGFkb3c6IG5vbmU7XG5cdFx0XHRvdXRsaW5lOiBub25lO1xuXHRcdH1cblxuXHRcdCY6Zm9jdXMtdmlzaWJsZSB7XG5cdFx0XHRib3gtc2hhZG93OiAwIDAgMCB2YXIoIC0td3AtYWRtaW4tYm9yZGVyLXdpZHRoLWZvY3VzIClcblx0XHRcdFx0JHsgQ09MT1JTLnRoZW1lLmFjY2VudCB9O1xuXHRcdFx0Ly8gV2luZG93cyBoaWdoIGNvbnRyYXN0IG1vZGUuXG5cdFx0XHRvdXRsaW5lOiAycHggc29saWQgdHJhbnNwYXJlbnQ7XG5cdFx0XHRvdXRsaW5lLW9mZnNldDogMDtcblx0XHR9XG5cdGA7XG59O1xuXG5leHBvcnQgY29uc3QgaXRlbVdyYXBwZXIgPSBjc3NgXG5cdHdpZHRoOiAxMDAlO1xuXHRkaXNwbGF5OiBibG9jaztcbmA7XG5cbmV4cG9ydCBjb25zdCBpdGVtID0gY3NzYFxuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHR3aWR0aDogMTAwJTtcblx0ZGlzcGxheTogYmxvY2s7XG5cdG1hcmdpbjogMDtcblx0Y29sb3I6IGluaGVyaXQ7XG5gO1xuXG5leHBvcnQgY29uc3QgYm9yZGVyZWQgPSBjc3NgXG5cdGJvcmRlcjogMXB4IHNvbGlkICR7IENPTkZJRy5zdXJmYWNlQm9yZGVyQ29sb3IgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzZXBhcmF0ZWQgPSBjc3NgXG5cdD4gKjpub3QoIG1hcnF1ZWUgKSA+ICoge1xuXHRcdGJvcmRlci1ib3R0b206IDFweCBzb2xpZCAkeyBDT05GSUcuc3VyZmFjZUJvcmRlckNvbG9yIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdH1cbmA7XG5cbmNvbnN0IGJvcmRlclJhZGl1cyA9IENPTkZJRy5yYWRpdXNTbWFsbDtcblxuZXhwb3J0IGNvbnN0IHNwYWNlZEFyb3VuZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5gO1xuXG5leHBvcnQgY29uc3Qgcm91bmRlZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cblx0PiAqOmZpcnN0LW9mLXR5cGUgPiAqIHtcblx0XHRib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAkeyBib3JkZXJSYWRpdXMgfTtcblx0XHRib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdFx0Ym9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6ICR7IGJvcmRlclJhZGl1cyB9O1xuXHR9XG5gO1xuXG5jb25zdCBiYXNlRm9udEhlaWdodCA9IGBjYWxjKCR7IENPTkZJRy5mb250U2l6ZSB9ICogJHsgQ09ORklHLmZvbnRMaW5lSGVpZ2h0QmFzZSB9KWA7XG5cbi8qXG4gKiBNYXRoOlxuICogLSBVc2UgdGhlIGRlc2lyZWQgaGVpZ2h0IGFzIHRoZSBiYXNlIHZhbHVlXG4gKiAtIFN1YnRyYWN0IHRoZSBjb21wdXRlZCBoZWlnaHQgb2YgKGRlZmF1bHQpIHRleHRcbiAqIC0gU3VidHJhY3QgdGhlIGVmZmVjdHMgb2YgYm9yZGVyXG4gKiAtIERpdmlkZSB0aGUgY2FsY3VsYXRlZCBudW1iZXIgYnkgMiwgaW4gb3JkZXIgdG8gZ2V0IGFuIGluZGl2aWR1YWwgdG9wL2JvdHRvbSBwYWRkaW5nXG4gKi9cbmNvbnN0IHBhZGRpbmdZID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0IH0gLSAkeyBiYXNlRm9udEhlaWdodCB9IC0gMnB4KSAvIDIpYDtcbmNvbnN0IHBhZGRpbmdZU21hbGwgPSBgY2FsYygoJHsgQ09ORklHLmNvbnRyb2xIZWlnaHRTbWFsbCB9IC0gJHsgYmFzZUZvbnRIZWlnaHQgfSAtIDJweCkgLyAyKWA7XG5jb25zdCBwYWRkaW5nWUxhcmdlID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0TGFyZ2UgfSAtICR7IGJhc2VGb250SGVpZ2h0IH0gLSAycHgpIC8gMilgO1xuXG5leHBvcnQgY29uc3QgaXRlbVNpemVzID0ge1xuXHRzbWFsbDogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZU21hbGwgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYU21hbGwgfXB4O1xuXHRgLFxuXHRtZWRpdW06IGNzc2Bcblx0XHRwYWRkaW5nOiAkeyBwYWRkaW5nWSB9ICR7IENPTkZJRy5jb250cm9sUGFkZGluZ1ggfXB4O1xuXHRgLFxuXHRsYXJnZTogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZTGFyZ2UgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYTGFyZ2UgfXB4O1xuXHRgLFxufTtcbiJdfQ== */");
  var borderRadius2 = config_values_default.radiusSmall;
  var spacedAround = /* @__PURE__ */ css("border-radius:", borderRadius2, ";" + (false ? "" : ";label:spacedAround;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var rounded2 = /* @__PURE__ */ css("border-radius:", borderRadius2, ";>*:first-of-type>*{border-top-left-radius:", borderRadius2, ";border-top-right-radius:", borderRadius2, ";}>*:last-of-type>*{border-bottom-left-radius:", borderRadius2, ";border-bottom-right-radius:", borderRadius2, ";}" + (false ? "" : ";label:rounded;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE4RTBCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHLCBDT0xPUlMsIGZvbnQgfSBmcm9tICcuLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCB1bnN0eWxlZEJ1dHRvbiA9ICggYXM6ICdhJyB8ICdidXR0b24nICkgPT4ge1xuXHRyZXR1cm4gY3NzYFxuXHRcdGZvbnQtc2l6ZTogJHsgZm9udCggJ2RlZmF1bHQuZm9udFNpemUnICkgfTtcblx0XHRmb250LWZhbWlseTogaW5oZXJpdDtcblx0XHRhcHBlYXJhbmNlOiBub25lO1xuXHRcdGJvcmRlcjogMXB4IHNvbGlkIHRyYW5zcGFyZW50O1xuXHRcdGN1cnNvcjogcG9pbnRlcjtcblx0XHRiYWNrZ3JvdW5kOiBub25lO1xuXHRcdHRleHQtYWxpZ246IHN0YXJ0O1xuXHRcdHRleHQtZGVjb3JhdGlvbjogJHsgYXMgPT09ICdhJyA/ICdub25lJyA6IHVuZGVmaW5lZCB9O1xuXG5cdFx0c3ZnLFxuXHRcdHBhdGgge1xuXHRcdFx0ZmlsbDogY3VycmVudENvbG9yO1xuXHRcdH1cblxuXHRcdCY6aG92ZXIge1xuXHRcdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5hY2NlbnQgfTtcblx0XHR9XG5cblx0XHQmOmZvY3VzIHtcblx0XHRcdGJveC1zaGFkb3c6IG5vbmU7XG5cdFx0XHRvdXRsaW5lOiBub25lO1xuXHRcdH1cblxuXHRcdCY6Zm9jdXMtdmlzaWJsZSB7XG5cdFx0XHRib3gtc2hhZG93OiAwIDAgMCB2YXIoIC0td3AtYWRtaW4tYm9yZGVyLXdpZHRoLWZvY3VzIClcblx0XHRcdFx0JHsgQ09MT1JTLnRoZW1lLmFjY2VudCB9O1xuXHRcdFx0Ly8gV2luZG93cyBoaWdoIGNvbnRyYXN0IG1vZGUuXG5cdFx0XHRvdXRsaW5lOiAycHggc29saWQgdHJhbnNwYXJlbnQ7XG5cdFx0XHRvdXRsaW5lLW9mZnNldDogMDtcblx0XHR9XG5cdGA7XG59O1xuXG5leHBvcnQgY29uc3QgaXRlbVdyYXBwZXIgPSBjc3NgXG5cdHdpZHRoOiAxMDAlO1xuXHRkaXNwbGF5OiBibG9jaztcbmA7XG5cbmV4cG9ydCBjb25zdCBpdGVtID0gY3NzYFxuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHR3aWR0aDogMTAwJTtcblx0ZGlzcGxheTogYmxvY2s7XG5cdG1hcmdpbjogMDtcblx0Y29sb3I6IGluaGVyaXQ7XG5gO1xuXG5leHBvcnQgY29uc3QgYm9yZGVyZWQgPSBjc3NgXG5cdGJvcmRlcjogMXB4IHNvbGlkICR7IENPTkZJRy5zdXJmYWNlQm9yZGVyQ29sb3IgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBzZXBhcmF0ZWQgPSBjc3NgXG5cdD4gKjpub3QoIG1hcnF1ZWUgKSA+ICoge1xuXHRcdGJvcmRlci1ib3R0b206IDFweCBzb2xpZCAkeyBDT05GSUcuc3VyZmFjZUJvcmRlckNvbG9yIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1jb2xvcjogdHJhbnNwYXJlbnQ7XG5cdH1cbmA7XG5cbmNvbnN0IGJvcmRlclJhZGl1cyA9IENPTkZJRy5yYWRpdXNTbWFsbDtcblxuZXhwb3J0IGNvbnN0IHNwYWNlZEFyb3VuZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5gO1xuXG5leHBvcnQgY29uc3Qgcm91bmRlZCA9IGNzc2Bcblx0Ym9yZGVyLXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cblx0PiAqOmZpcnN0LW9mLXR5cGUgPiAqIHtcblx0XHRib3JkZXItdG9wLWxlZnQtcmFkaXVzOiAkeyBib3JkZXJSYWRpdXMgfTtcblx0XHRib3JkZXItdG9wLXJpZ2h0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdH1cblxuXHQ+ICo6bGFzdC1vZi10eXBlID4gKiB7XG5cdFx0Ym9yZGVyLWJvdHRvbS1sZWZ0LXJhZGl1czogJHsgYm9yZGVyUmFkaXVzIH07XG5cdFx0Ym9yZGVyLWJvdHRvbS1yaWdodC1yYWRpdXM6ICR7IGJvcmRlclJhZGl1cyB9O1xuXHR9XG5gO1xuXG5jb25zdCBiYXNlRm9udEhlaWdodCA9IGBjYWxjKCR7IENPTkZJRy5mb250U2l6ZSB9ICogJHsgQ09ORklHLmZvbnRMaW5lSGVpZ2h0QmFzZSB9KWA7XG5cbi8qXG4gKiBNYXRoOlxuICogLSBVc2UgdGhlIGRlc2lyZWQgaGVpZ2h0IGFzIHRoZSBiYXNlIHZhbHVlXG4gKiAtIFN1YnRyYWN0IHRoZSBjb21wdXRlZCBoZWlnaHQgb2YgKGRlZmF1bHQpIHRleHRcbiAqIC0gU3VidHJhY3QgdGhlIGVmZmVjdHMgb2YgYm9yZGVyXG4gKiAtIERpdmlkZSB0aGUgY2FsY3VsYXRlZCBudW1iZXIgYnkgMiwgaW4gb3JkZXIgdG8gZ2V0IGFuIGluZGl2aWR1YWwgdG9wL2JvdHRvbSBwYWRkaW5nXG4gKi9cbmNvbnN0IHBhZGRpbmdZID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0IH0gLSAkeyBiYXNlRm9udEhlaWdodCB9IC0gMnB4KSAvIDIpYDtcbmNvbnN0IHBhZGRpbmdZU21hbGwgPSBgY2FsYygoJHsgQ09ORklHLmNvbnRyb2xIZWlnaHRTbWFsbCB9IC0gJHsgYmFzZUZvbnRIZWlnaHQgfSAtIDJweCkgLyAyKWA7XG5jb25zdCBwYWRkaW5nWUxhcmdlID0gYGNhbGMoKCR7IENPTkZJRy5jb250cm9sSGVpZ2h0TGFyZ2UgfSAtICR7IGJhc2VGb250SGVpZ2h0IH0gLSAycHgpIC8gMilgO1xuXG5leHBvcnQgY29uc3QgaXRlbVNpemVzID0ge1xuXHRzbWFsbDogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZU21hbGwgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYU21hbGwgfXB4O1xuXHRgLFxuXHRtZWRpdW06IGNzc2Bcblx0XHRwYWRkaW5nOiAkeyBwYWRkaW5nWSB9ICR7IENPTkZJRy5jb250cm9sUGFkZGluZ1ggfXB4O1xuXHRgLFxuXHRsYXJnZTogY3NzYFxuXHRcdHBhZGRpbmc6ICR7IHBhZGRpbmdZTGFyZ2UgfSAkeyBDT05GSUcuY29udHJvbFBhZGRpbmdYTGFyZ2UgfXB4O1xuXHRgLFxufTtcbiJdfQ== */");
  var baseFontHeight = `calc(${config_values_default.fontSize} * ${config_values_default.fontLineHeightBase})`;
  var paddingY = `calc((${config_values_default.controlHeight} - ${baseFontHeight} - 2px) / 2)`;
  var paddingYSmall = `calc((${config_values_default.controlHeightSmall} - ${baseFontHeight} - 2px) / 2)`;
  var paddingYLarge = `calc((${config_values_default.controlHeightLarge} - ${baseFontHeight} - 2px) / 2)`;
  var itemSizes = {
    small: /* @__PURE__ */ css("padding:", paddingYSmall, " ", config_values_default.controlPaddingXSmall, "px;" + (false ? "" : ";label:small;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),
    medium: /* @__PURE__ */ css("padding:", paddingY, " ", config_values_default.controlPaddingX, "px;" + (false ? "" : ";label:medium;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),
    large: /* @__PURE__ */ css("padding:", paddingYLarge, " ", config_values_default.controlPaddingXLarge, "px;" + (false ? "" : ";label:large;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */")
  };

  // packages/components/build-module/item-group/context.mjs
  var import_element104 = __toESM(require_element(), 1);
  var ItemGroupContext = (0, import_element104.createContext)({
    size: "medium"
  });
  ItemGroupContext.displayName = "ItemGroupContext";
  var useItemGroupContext = () => (0, import_element104.useContext)(ItemGroupContext);

  // packages/components/build-module/item-group/item/hook.mjs
  function useItem(props) {
    const {
      as: asProp,
      className: className2,
      onClick,
      role = "listitem",
      size: sizeProp,
      ...otherProps
    } = useContextSystem(props, "Item");
    const {
      spacedAround: spacedAround2,
      size: contextSize
    } = useItemGroupContext();
    const size4 = sizeProp || contextSize;
    const as = asProp || (typeof onClick !== "undefined" ? "button" : "div");
    const cx2 = useCx();
    const classes = (0, import_element105.useMemo)(() => cx2((as === "button" || as === "a") && unstyledButton(as), itemSizes[size4] || itemSizes.medium, item, spacedAround2 && spacedAround, className2), [as, className2, cx2, size4, spacedAround2]);
    const wrapperClassName = cx2(itemWrapper);
    return {
      as,
      className: classes,
      onClick,
      wrapperClassName,
      role,
      ...otherProps
    };
  }

  // packages/components/build-module/item-group/item/component.mjs
  var import_jsx_runtime171 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedItem(props, forwardedRef) {
    const {
      role,
      wrapperClassName,
      ...otherProps
    } = useItem(props);
    return /* @__PURE__ */ (0, import_jsx_runtime171.jsx)("div", {
      role,
      className: wrapperClassName,
      children: /* @__PURE__ */ (0, import_jsx_runtime171.jsx)(component_default, {
        ...otherProps,
        ref: forwardedRef
      })
    });
  }
  var Item = contextConnect(UnconnectedItem, "Item");
  var component_default35 = Item;

  // packages/components/build-module/item-group/item-group/hook.mjs
  function useItemGroup(props) {
    const {
      className: className2,
      isBordered = false,
      isRounded = true,
      isSeparated = false,
      role = "list",
      ...otherProps
    } = useContextSystem(props, "ItemGroup");
    const cx2 = useCx();
    const classes = cx2(isBordered && bordered, isSeparated && separated, isRounded && rounded2, className2);
    return {
      isBordered,
      className: classes,
      role,
      isSeparated,
      ...otherProps
    };
  }

  // packages/components/build-module/item-group/item-group/component.mjs
  var import_jsx_runtime172 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedItemGroup(props, forwardedRef) {
    const {
      isBordered,
      isSeparated,
      size: sizeProp,
      ...otherProps
    } = useItemGroup(props);
    const {
      size: contextSize
    } = useItemGroupContext();
    const spacedAround2 = !isBordered && !isSeparated;
    const size4 = sizeProp || contextSize;
    const contextValue = {
      spacedAround: spacedAround2,
      size: size4
    };
    return /* @__PURE__ */ (0, import_jsx_runtime172.jsx)(ItemGroupContext.Provider, {
      value: contextValue,
      children: /* @__PURE__ */ (0, import_jsx_runtime172.jsx)(component_default, {
        ...otherProps,
        ref: forwardedRef
      })
    });
  }
  var ItemGroup = contextConnect(UnconnectedItemGroup, "ItemGroup");
  var component_default36 = ItemGroup;

  // packages/components/build-module/gradient-picker/index.mjs
  var import_i18n34 = __toESM(require_i18n(), 1);
  var import_compose42 = __toESM(require_compose(), 1);
  var import_element109 = __toESM(require_element(), 1);

  // packages/components/build-module/custom-gradient-picker/index.mjs
  var import_i18n33 = __toESM(require_i18n(), 1);
  var import_element108 = __toESM(require_element(), 1);

  // packages/components/build-module/custom-gradient-picker/gradient-bar/index.mjs
  var import_element107 = __toESM(require_element(), 1);

  // packages/components/build-module/custom-gradient-picker/gradient-bar/control-points.mjs
  var import_compose41 = __toESM(require_compose(), 1);
  var import_element106 = __toESM(require_element(), 1);
  var import_i18n31 = __toESM(require_i18n(), 1);

  // packages/components/build-module/custom-gradient-picker/gradient-bar/constants.mjs
  var GRADIENT_MARKERS_WIDTH = 16;
  var INSERT_POINT_WIDTH = 16;
  var MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_POINT = 10;
  var MINIMUM_DISTANCE_BETWEEN_POINTS = 0;
  var MINIMUM_SIGNIFICANT_MOVE = 5;
  var KEYBOARD_CONTROL_POINT_VARIATION = MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_POINT;
  var MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_MARKER = (INSERT_POINT_WIDTH + GRADIENT_MARKERS_WIDTH) / 2;

  // packages/components/build-module/custom-gradient-picker/gradient-bar/utils.mjs
  function clampPercent(value) {
    return Math.max(0, Math.min(100, value));
  }
  function isOverlapping(value, initialIndex, newPosition, minDistance = MINIMUM_DISTANCE_BETWEEN_POINTS) {
    const initialPosition = value[initialIndex].position;
    const minPosition = Math.min(initialPosition, newPosition);
    const maxPosition = Math.max(initialPosition, newPosition);
    return value.some(({
      position: position2
    }, index2) => {
      return index2 !== initialIndex && (Math.abs(position2 - newPosition) < minDistance || minPosition < position2 && position2 < maxPosition);
    });
  }
  function addControlPoint(points, position2, color2) {
    const nextIndex = points.findIndex((point) => point.position > position2);
    const newPoint = {
      color: color2,
      position: position2
    };
    const newPoints = points.slice();
    newPoints.splice(nextIndex - 1, 0, newPoint);
    return newPoints;
  }
  function removeControlPoint(points, index2) {
    return points.filter((_point, pointIndex) => {
      return pointIndex !== index2;
    });
  }
  function updateControlPoint(points, index2, newPoint) {
    const newValue = points.slice();
    newValue[index2] = newPoint;
    return newValue;
  }
  function updateControlPointPosition(points, index2, newPosition) {
    if (isOverlapping(points, index2, newPosition)) {
      return points;
    }
    const newPoint = {
      ...points[index2],
      position: newPosition
    };
    return updateControlPoint(points, index2, newPoint);
  }
  function updateControlPointColor(points, index2, newColor) {
    const newPoint = {
      ...points[index2],
      color: newColor
    };
    return updateControlPoint(points, index2, newPoint);
  }
  function updateControlPointColorByPosition(points, position2, newColor) {
    const index2 = points.findIndex((point) => point.position === position2);
    return updateControlPointColor(points, index2, newColor);
  }
  function getHorizontalRelativeGradientPosition(mouseXCoordinate, containerElement) {
    if (!containerElement) {
      return;
    }
    const {
      x: x2,
      width
    } = containerElement.getBoundingClientRect();
    const absolutePositionValue = mouseXCoordinate - x2;
    return Math.round(clampPercent(absolutePositionValue * 100 / width));
  }

  // packages/components/build-module/custom-gradient-picker/gradient-bar/control-points.mjs
  var import_jsx_runtime173 = __toESM(require_jsx_runtime(), 1);
  function ControlPointButton({
    isOpen,
    position: position2,
    color: color2,
    ...additionalProps
  }) {
    const instanceId = (0, import_compose41.useInstanceId)(ControlPointButton);
    const descriptionId = `components-custom-gradient-picker__control-point-button-description-${instanceId}`;
    return /* @__PURE__ */ (0, import_jsx_runtime173.jsxs)(import_jsx_runtime173.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime173.jsx)(button_default, {
        "aria-label": (0, import_i18n31.sprintf)(
          // translators: 1: gradient position e.g: 70. 2: gradient color code e.g: rgb(52,121,151).
          (0, import_i18n31.__)("Gradient control point at position %1$d%% with color code %2$s."),
          position2,
          color2
        ),
        "aria-describedby": descriptionId,
        "aria-haspopup": "true",
        "aria-expanded": isOpen,
        __next40pxDefaultSize: true,
        className: clsx_default("components-custom-gradient-picker__control-point-button", {
          "is-active": isOpen
        }),
        ...additionalProps
      }), /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(component_default2, {
        id: descriptionId,
        children: (0, import_i18n31.__)("Use your left or right arrow keys or drag and drop with the mouse to change the gradient position. Press the button to change the color or remove the control point.")
      })]
    });
  }
  function GradientColorPickerDropdown({
    isRenderedInSidebar,
    className: className2,
    ...props
  }) {
    const popoverProps = (0, import_element106.useMemo)(() => ({
      placement: "bottom",
      offset: 8,
      // Disabling resize as it would otherwise cause the popover to show
      // scrollbars while dragging the color picker's handle close to the
      // popover edge.
      resize: false
    }), []);
    const mergedClassName = clsx_default("components-custom-gradient-picker__control-point-dropdown", className2);
    return /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(CustomColorPickerDropdown, {
      isRenderedInSidebar,
      popoverProps,
      className: mergedClassName,
      ...props
    });
  }
  function ControlPoints({
    disableRemove,
    disableAlpha,
    gradientPickerDomRef,
    ignoreMarkerPosition,
    value: controlPoints,
    onChange,
    onStartControlPointChange,
    onStopControlPointChange,
    __experimentalIsRenderedInSidebar
  }) {
    const controlPointMoveStateRef = (0, import_element106.useRef)(void 0);
    const onMouseMove = (event) => {
      if (controlPointMoveStateRef.current === void 0 || gradientPickerDomRef.current === null) {
        return;
      }
      const relativePosition = getHorizontalRelativeGradientPosition(event.clientX, gradientPickerDomRef.current);
      const {
        initialPosition,
        index: index2,
        significantMoveHappened
      } = controlPointMoveStateRef.current;
      if (!significantMoveHappened && Math.abs(initialPosition - relativePosition) >= MINIMUM_SIGNIFICANT_MOVE) {
        controlPointMoveStateRef.current.significantMoveHappened = true;
      }
      onChange(updateControlPointPosition(controlPoints, index2, relativePosition));
    };
    const cleanEventListeners = () => {
      if (window && window.removeEventListener && controlPointMoveStateRef.current && controlPointMoveStateRef.current.listenersActivated) {
        window.removeEventListener("mousemove", onMouseMove);
        window.removeEventListener("mouseup", cleanEventListeners);
        onStopControlPointChange();
        controlPointMoveStateRef.current.listenersActivated = false;
      }
    };
    const cleanEventListenersRef = (0, import_element106.useRef)(void 0);
    cleanEventListenersRef.current = cleanEventListeners;
    (0, import_element106.useEffect)(() => {
      return () => {
        cleanEventListenersRef.current?.();
      };
    }, []);
    return /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(import_jsx_runtime173.Fragment, {
      children: controlPoints.map((point, index2) => {
        const initialPosition = point?.position;
        return ignoreMarkerPosition !== initialPosition && /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(GradientColorPickerDropdown, {
          isRenderedInSidebar: __experimentalIsRenderedInSidebar,
          onClose: onStopControlPointChange,
          renderToggle: ({
            isOpen,
            onToggle
          }) => /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(ControlPointButton, {
            onClick: () => {
              if (controlPointMoveStateRef.current && controlPointMoveStateRef.current.significantMoveHappened) {
                return;
              }
              if (isOpen) {
                onStopControlPointChange();
              } else {
                onStartControlPointChange();
              }
              onToggle();
            },
            onMouseDown: () => {
              if (window && window.addEventListener) {
                controlPointMoveStateRef.current = {
                  initialPosition,
                  index: index2,
                  significantMoveHappened: false,
                  listenersActivated: true
                };
                onStartControlPointChange();
                window.addEventListener("mousemove", onMouseMove);
                window.addEventListener("mouseup", cleanEventListeners);
              }
            },
            onKeyDown: (event) => {
              if (event.code === "ArrowLeft") {
                event.stopPropagation();
                onChange(updateControlPointPosition(controlPoints, index2, clampPercent(point.position - KEYBOARD_CONTROL_POINT_VARIATION)));
              } else if (event.code === "ArrowRight") {
                event.stopPropagation();
                onChange(updateControlPointPosition(controlPoints, index2, clampPercent(point.position + KEYBOARD_CONTROL_POINT_VARIATION)));
              }
            },
            isOpen,
            position: point.position,
            color: point.color
          }, index2),
          renderContent: ({
            onClose
          }) => /* @__PURE__ */ (0, import_jsx_runtime173.jsxs)(dropdown_content_wrapper_default, {
            paddingSize: "none",
            children: [/* @__PURE__ */ (0, import_jsx_runtime173.jsx)(LegacyAdapter, {
              enableAlpha: !disableAlpha,
              color: point.color,
              onChange: (color2) => {
                onChange(updateControlPointColor(controlPoints, index2, w(color2).toRgbString()));
              }
            }), !disableRemove && controlPoints.length > 2 && /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(component_default9, {
              className: "components-custom-gradient-picker__remove-control-point-wrapper",
              alignment: "center",
              children: /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(button_default, {
                onClick: () => {
                  onChange(removeControlPoint(controlPoints, index2));
                  onClose();
                },
                variant: "link",
                children: (0, import_i18n31.__)("Remove Control Point")
              })
            })]
          }),
          style: {
            left: `${point.position}%`,
            transform: "translateX( -50% )"
          }
        }, index2);
      })
    });
  }
  function InsertPoint({
    value: controlPoints,
    onChange,
    onOpenInserter,
    onCloseInserter,
    insertPosition,
    disableAlpha,
    __experimentalIsRenderedInSidebar
  }) {
    const [alreadyInsertedPoint, setAlreadyInsertedPoint] = (0, import_element106.useState)(false);
    return /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(GradientColorPickerDropdown, {
      isRenderedInSidebar: __experimentalIsRenderedInSidebar,
      className: "components-custom-gradient-picker__inserter",
      onClose: () => {
        onCloseInserter();
      },
      renderToggle: ({
        isOpen,
        onToggle
      }) => /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(button_default, {
        __next40pxDefaultSize: true,
        "aria-expanded": isOpen,
        "aria-haspopup": "true",
        onClick: () => {
          if (isOpen) {
            onCloseInserter();
          } else {
            setAlreadyInsertedPoint(false);
            onOpenInserter();
          }
          onToggle();
        },
        className: "components-custom-gradient-picker__insert-point-dropdown",
        icon: plus_default
      }),
      renderContent: () => /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(dropdown_content_wrapper_default, {
        paddingSize: "none",
        children: /* @__PURE__ */ (0, import_jsx_runtime173.jsx)(LegacyAdapter, {
          enableAlpha: !disableAlpha,
          onChange: (color2) => {
            if (!alreadyInsertedPoint) {
              onChange(addControlPoint(controlPoints, insertPosition, w(color2).toRgbString()));
              setAlreadyInsertedPoint(true);
            } else {
              onChange(updateControlPointColorByPosition(controlPoints, insertPosition, w(color2).toRgbString()));
            }
          }
        })
      }),
      style: insertPosition !== null ? {
        left: `${insertPosition}%`,
        transform: "translateX( -50% )"
      } : void 0
    });
  }
  ControlPoints.InsertPoint = InsertPoint;
  var control_points_default = ControlPoints;

  // packages/components/build-module/custom-gradient-picker/gradient-bar/index.mjs
  var import_jsx_runtime174 = __toESM(require_jsx_runtime(), 1);
  var customGradientBarReducer = (state, action) => {
    switch (action.type) {
      case "MOVE_INSERTER":
        if (state.id === "IDLE" || state.id === "MOVING_INSERTER") {
          return {
            id: "MOVING_INSERTER",
            insertPosition: action.insertPosition
          };
        }
        break;
      case "STOP_INSERTER_MOVE":
        if (state.id === "MOVING_INSERTER") {
          return {
            id: "IDLE"
          };
        }
        break;
      case "OPEN_INSERTER":
        if (state.id === "MOVING_INSERTER") {
          return {
            id: "INSERTING_CONTROL_POINT",
            insertPosition: state.insertPosition
          };
        }
        break;
      case "CLOSE_INSERTER":
        if (state.id === "INSERTING_CONTROL_POINT") {
          return {
            id: "IDLE"
          };
        }
        break;
      case "START_CONTROL_CHANGE":
        if (state.id === "IDLE") {
          return {
            id: "MOVING_CONTROL_POINT"
          };
        }
        break;
      case "STOP_CONTROL_CHANGE":
        if (state.id === "MOVING_CONTROL_POINT") {
          return {
            id: "IDLE"
          };
        }
        break;
    }
    return state;
  };
  var customGradientBarReducerInitialState = {
    id: "IDLE"
  };
  function CustomGradientBar({
    background,
    hasGradient,
    value: controlPoints,
    onChange,
    disableInserter = false,
    disableAlpha = false,
    __experimentalIsRenderedInSidebar = false
  }) {
    const gradientMarkersContainerDomRef = (0, import_element107.useRef)(null);
    const [gradientBarState, gradientBarStateDispatch] = (0, import_element107.useReducer)(customGradientBarReducer, customGradientBarReducerInitialState);
    const onMouseEnterAndMove = (event) => {
      if (!gradientMarkersContainerDomRef.current) {
        return;
      }
      const insertPosition = getHorizontalRelativeGradientPosition(event.clientX, gradientMarkersContainerDomRef.current);
      if (controlPoints.some(({
        position: position2
      }) => {
        return Math.abs(insertPosition - position2) < MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_POINT;
      })) {
        if (gradientBarState.id === "MOVING_INSERTER") {
          gradientBarStateDispatch({
            type: "STOP_INSERTER_MOVE"
          });
        }
        return;
      }
      gradientBarStateDispatch({
        type: "MOVE_INSERTER",
        insertPosition
      });
    };
    const onMouseLeave = () => {
      gradientBarStateDispatch({
        type: "STOP_INSERTER_MOVE"
      });
    };
    const isMovingInserter = gradientBarState.id === "MOVING_INSERTER";
    const isInsertingControlPoint = gradientBarState.id === "INSERTING_CONTROL_POINT";
    return /* @__PURE__ */ (0, import_jsx_runtime174.jsxs)("div", {
      className: clsx_default("components-custom-gradient-picker__gradient-bar", {
        "has-gradient": hasGradient
      }),
      onMouseEnter: onMouseEnterAndMove,
      onMouseMove: onMouseEnterAndMove,
      onMouseLeave,
      children: [/* @__PURE__ */ (0, import_jsx_runtime174.jsx)("div", {
        className: "components-custom-gradient-picker__gradient-bar-background",
        style: {
          background,
          opacity: hasGradient ? 1 : 0.4
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime174.jsxs)("div", {
        ref: gradientMarkersContainerDomRef,
        className: "components-custom-gradient-picker__markers-container",
        children: [!disableInserter && (isMovingInserter || isInsertingControlPoint) && /* @__PURE__ */ (0, import_jsx_runtime174.jsx)(control_points_default.InsertPoint, {
          __experimentalIsRenderedInSidebar,
          disableAlpha,
          insertPosition: gradientBarState.insertPosition,
          value: controlPoints,
          onChange,
          onOpenInserter: () => {
            gradientBarStateDispatch({
              type: "OPEN_INSERTER"
            });
          },
          onCloseInserter: () => {
            gradientBarStateDispatch({
              type: "CLOSE_INSERTER"
            });
          }
        }), /* @__PURE__ */ (0, import_jsx_runtime174.jsx)(control_points_default, {
          __experimentalIsRenderedInSidebar,
          disableAlpha,
          disableRemove: disableInserter,
          gradientPickerDomRef: gradientMarkersContainerDomRef,
          ignoreMarkerPosition: isInsertingControlPoint ? gradientBarState.insertPosition : void 0,
          value: controlPoints,
          onChange,
          onStartControlPointChange: () => {
            gradientBarStateDispatch({
              type: "START_CONTROL_CHANGE"
            });
          },
          onStopControlPointChange: () => {
            gradientBarStateDispatch({
              type: "STOP_CONTROL_CHANGE"
            });
          }
        })]
      })]
    });
  }

  // packages/components/build-module/custom-gradient-picker/utils.mjs
  var import_gradient_parser = __toESM(require_node(), 1);

  // packages/components/build-module/custom-gradient-picker/constants.mjs
  var import_i18n32 = __toESM(require_i18n(), 1);
  var DEFAULT_GRADIENT = "linear-gradient(135deg, rgba(6, 147, 227, 1) 0%, rgb(155, 81, 224) 100%)";
  var DEFAULT_LINEAR_GRADIENT_ANGLE = 180;
  var HORIZONTAL_GRADIENT_ORIENTATION = {
    type: "angular",
    value: "90"
  };
  var GRADIENT_OPTIONS = [{
    value: "linear-gradient",
    label: (0, import_i18n32.__)("Linear")
  }, {
    value: "radial-gradient",
    label: (0, import_i18n32.__)("Radial")
  }];
  var DIRECTIONAL_ORIENTATION_ANGLE_MAP = {
    top: 0,
    "top right": 45,
    "right top": 45,
    right: 90,
    "right bottom": 135,
    "bottom right": 135,
    bottom: 180,
    "bottom left": 225,
    "left bottom": 225,
    left: 270,
    "top left": 315,
    "left top": 315
  };

  // packages/components/build-module/custom-gradient-picker/serializer.mjs
  function serializeGradientColor({
    type,
    value
  }) {
    if (type === "literal") {
      return value;
    }
    if (type === "hex") {
      return `#${value}`;
    }
    if (type === "var") {
      return `var(${value})`;
    }
    if (type === "hsl") {
      const [hue, saturation, lightness] = value;
      return `hsl(${hue},${saturation}%,${lightness}%)`;
    }
    if (type === "hsla") {
      const [hue, saturation, lightness, alpha2] = value;
      return `hsla(${hue},${saturation}%,${lightness}%,${alpha2})`;
    }
    return `${type}(${value.join(",")})`;
  }
  function serializeGradientPosition(position2) {
    if (!position2) {
      return "";
    }
    const {
      value,
      type
    } = position2;
    if (type === "calc") {
      return `calc(${value})`;
    }
    return `${value}${type}`;
  }
  function serializeGradientColorStop({
    type,
    value,
    length: length2
  }) {
    return `${serializeGradientColor({
      type,
      value
    })} ${serializeGradientPosition(length2)}`;
  }
  function serializeGradientOrientation(orientation) {
    if (Array.isArray(orientation) || !orientation || orientation.type !== "angular") {
      return;
    }
    return `${orientation.value}deg`;
  }
  function serializeGradient({
    type,
    orientation,
    colorStops
  }) {
    const serializedOrientation = serializeGradientOrientation(orientation);
    const serializedColorStops = colorStops.sort((colorStop1, colorStop2) => {
      const getNumericStopValue = (colorStop) => {
        return colorStop?.length?.value === void 0 ? 0 : parseInt(colorStop.length.value);
      };
      return getNumericStopValue(colorStop1) - getNumericStopValue(colorStop2);
    }).map(serializeGradientColorStop);
    return `${type}(${[serializedOrientation, ...serializedColorStops].filter(Boolean).join(",")})`;
  }

  // packages/components/build-module/custom-gradient-picker/utils.mjs
  k([names_default]);
  function getLinearGradientRepresentation(gradientAST) {
    return serializeGradient({
      type: "linear-gradient",
      orientation: HORIZONTAL_GRADIENT_ORIENTATION,
      colorStops: gradientAST.colorStops
    });
  }
  function hasUnsupportedLength(item2) {
    return item2.length === void 0 || item2.length.type !== "%";
  }
  function getGradientAstWithDefault(value) {
    let gradientAST;
    let hasGradient = !!value;
    const valueToParse = value ?? DEFAULT_GRADIENT;
    try {
      gradientAST = import_gradient_parser.default.parse(valueToParse)[0];
    } catch (error) {
      console.warn("wp.components.CustomGradientPicker failed to parse the gradient with error", error);
      gradientAST = import_gradient_parser.default.parse(DEFAULT_GRADIENT)[0];
      hasGradient = false;
    }
    if (!Array.isArray(gradientAST.orientation) && gradientAST.orientation?.type === "directional") {
      gradientAST.orientation = {
        type: "angular",
        value: DIRECTIONAL_ORIENTATION_ANGLE_MAP[gradientAST.orientation.value].toString()
      };
    }
    if (gradientAST.colorStops.some(hasUnsupportedLength)) {
      const {
        colorStops
      } = gradientAST;
      const step = 100 / (colorStops.length - 1);
      colorStops.forEach((stop, index2) => {
        stop.length = {
          value: `${step * index2}`,
          type: "%"
        };
      });
    }
    return {
      gradientAST,
      hasGradient
    };
  }
  function getGradientAstWithControlPoints(gradientAST, newControlPoints) {
    return {
      ...gradientAST,
      colorStops: newControlPoints.map(({
        position: position2,
        color: color2
      }) => {
        const {
          r: r4,
          g: g3,
          b: b3,
          a: a3
        } = w(color2).toRgb();
        return {
          length: {
            type: "%",
            value: position2?.toString()
          },
          type: a3 < 1 ? "rgba" : "rgb",
          value: a3 < 1 ? [`${r4}`, `${g3}`, `${b3}`, `${a3}`] : [`${r4}`, `${g3}`, `${b3}`]
        };
      })
    };
  }
  function getStopCssColor(colorStop) {
    switch (colorStop.type) {
      case "hex":
        return `#${colorStop.value}`;
      case "literal":
        return colorStop.value;
      case "var":
        return `${colorStop.type}(${colorStop.value})`;
      case "rgb":
      case "rgba":
        return `${colorStop.type}(${colorStop.value.join(",")})`;
      case "hsl": {
        const [hue, saturation, lightness] = colorStop.value;
        return `hsl(${hue},${saturation}%,${lightness}%)`;
      }
      case "hsla": {
        const [hue, saturation, lightness, alpha2] = colorStop.value;
        return `hsla(${hue},${saturation}%,${lightness}%,${alpha2})`;
      }
      default:
        return "transparent";
    }
  }

  // packages/components/build-module/custom-gradient-picker/styles/custom-gradient-picker-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__20() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var SelectWrapper = /* @__PURE__ */ createStyled(component_default5, false ? {
    target: "e10bzpgi1"
  } : {
    target: "e10bzpgi1",
    label: "SelectWrapper"
  })(false ? {
    name: "1gvx10y",
    styles: "flex-grow:5"
  } : {
    name: "1gvx10y",
    styles: "flex-grow:5/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImN1c3RvbS1ncmFkaWVudC1waWNrZXItc3R5bGVzLnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTZ0QiLCJmaWxlIjoiY3VzdG9tLWdyYWRpZW50LXBpY2tlci1zdHlsZXMudHN4Iiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgRmxleEJsb2NrIH0gZnJvbSAnLi4vLi4vZmxleCc7XG5cbmV4cG9ydCBjb25zdCBTZWxlY3RXcmFwcGVyID0gc3R5bGVkKCBGbGV4QmxvY2sgKWBcblx0ZmxleC1ncm93OiA1O1xuYDtcblxuZXhwb3J0IGNvbnN0IEFjY2Vzc29yeVdyYXBwZXIgPSBzdHlsZWQoIEZsZXhCbG9jayApYFxuXHRmbGV4LWdyb3c6IDU7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__20
  });
  var AccessoryWrapper = /* @__PURE__ */ createStyled(component_default5, false ? {
    target: "e10bzpgi0"
  } : {
    target: "e10bzpgi0",
    label: "AccessoryWrapper"
  })(false ? {
    name: "1gvx10y",
    styles: "flex-grow:5"
  } : {
    name: "1gvx10y",
    styles: "flex-grow:5/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImN1c3RvbS1ncmFkaWVudC1waWNrZXItc3R5bGVzLnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFhbUQiLCJmaWxlIjoiY3VzdG9tLWdyYWRpZW50LXBpY2tlci1zdHlsZXMudHN4Iiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgRmxleEJsb2NrIH0gZnJvbSAnLi4vLi4vZmxleCc7XG5cbmV4cG9ydCBjb25zdCBTZWxlY3RXcmFwcGVyID0gc3R5bGVkKCBGbGV4QmxvY2sgKWBcblx0ZmxleC1ncm93OiA1O1xuYDtcblxuZXhwb3J0IGNvbnN0IEFjY2Vzc29yeVdyYXBwZXIgPSBzdHlsZWQoIEZsZXhCbG9jayApYFxuXHRmbGV4LWdyb3c6IDU7XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__20
  });

  // packages/components/build-module/custom-gradient-picker/index.mjs
  var import_jsx_runtime175 = __toESM(require_jsx_runtime(), 1);
  var GradientAnglePicker = ({
    gradientAST,
    hasGradient,
    onChange
  }) => {
    const angle = gradientAST?.orientation?.value ?? DEFAULT_LINEAR_GRADIENT_ANGLE;
    const onAngleChange = (newAngle) => {
      onChange(serializeGradient({
        ...gradientAST,
        orientation: {
          type: "angular",
          value: `${newAngle}`
        }
      }));
    };
    return /* @__PURE__ */ (0, import_jsx_runtime175.jsx)(angle_picker_control_default, {
      onChange: onAngleChange,
      value: hasGradient ? angle : ""
    });
  };
  var GradientTypePicker = ({
    gradientAST,
    hasGradient,
    onChange
  }) => {
    const {
      type
    } = gradientAST;
    const lastLinearOrientationAngle = (0, import_element108.useRef)(Number(HORIZONTAL_GRADIENT_ORIENTATION.value));
    if (type === "linear-gradient" && gradientAST.orientation) {
      lastLinearOrientationAngle.current = Number(gradientAST.orientation.value);
    }
    const onSetLinearGradient = () => {
      onChange(serializeGradient({
        ...gradientAST,
        orientation: {
          type: "angular",
          value: `${lastLinearOrientationAngle.current}`
        },
        type: "linear-gradient"
      }));
    };
    const onSetRadialGradient = () => {
      const {
        orientation,
        ...restGradientAST
      } = gradientAST;
      onChange(serializeGradient({
        ...restGradientAST,
        type: "radial-gradient"
      }));
    };
    const handleOnChange = (next2) => {
      if (next2 === "linear-gradient") {
        onSetLinearGradient();
      }
      if (next2 === "radial-gradient") {
        onSetRadialGradient();
      }
    };
    return /* @__PURE__ */ (0, import_jsx_runtime175.jsx)(select_control_default, {
      className: "components-custom-gradient-picker__type-picker",
      label: (0, import_i18n33.__)("Type"),
      labelPosition: "top",
      onChange: handleOnChange,
      options: GRADIENT_OPTIONS,
      value: hasGradient ? type : void 0
    });
  };
  function CustomGradientPicker({
    value,
    onChange,
    enableAlpha = true,
    __experimentalIsRenderedInSidebar = false
  }) {
    const {
      gradientAST,
      hasGradient
    } = getGradientAstWithDefault(value);
    const background = getLinearGradientRepresentation(gradientAST);
    const controlPoints = gradientAST.colorStops.map((colorStop) => {
      return {
        color: getStopCssColor(colorStop),
        // Although it's already been checked by `hasUnsupportedLength` in `getGradientAstWithDefault`,
        // TypeScript doesn't know that `colorStop.length` is not undefined here.
        // @ts-expect-error
        position: parseInt(colorStop.length.value)
      };
    });
    return /* @__PURE__ */ (0, import_jsx_runtime175.jsxs)(component_default18, {
      spacing: 4,
      className: "components-custom-gradient-picker",
      children: [/* @__PURE__ */ (0, import_jsx_runtime175.jsx)(CustomGradientBar, {
        __experimentalIsRenderedInSidebar,
        disableAlpha: !enableAlpha,
        background,
        hasGradient,
        value: controlPoints,
        onChange: (newControlPoints) => {
          onChange(serializeGradient(getGradientAstWithControlPoints(gradientAST, newControlPoints)));
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime175.jsxs)(component_default3, {
        gap: 3,
        className: "components-custom-gradient-picker__ui-line",
        children: [/* @__PURE__ */ (0, import_jsx_runtime175.jsx)(SelectWrapper, {
          children: /* @__PURE__ */ (0, import_jsx_runtime175.jsx)(GradientTypePicker, {
            gradientAST,
            hasGradient,
            onChange
          })
        }), /* @__PURE__ */ (0, import_jsx_runtime175.jsx)(AccessoryWrapper, {
          children: gradientAST.type === "linear-gradient" && /* @__PURE__ */ (0, import_jsx_runtime175.jsx)(GradientAnglePicker, {
            gradientAST,
            hasGradient,
            onChange
          })
        })]
      })]
    });
  }
  var custom_gradient_picker_default = CustomGradientPicker;

  // packages/components/build-module/gradient-picker/index.mjs
  var import_jsx_runtime176 = __toESM(require_jsx_runtime(), 1);
  var isMultipleOriginObject = (obj) => Array.isArray(obj.gradients) && !("gradient" in obj);
  var isMultipleOriginArray = (arr) => {
    return arr.length > 0 && arr.every((gradientObj) => isMultipleOriginObject(gradientObj));
  };
  function SingleOrigin({
    className: className2,
    clearGradient,
    gradients,
    onChange,
    value,
    selectedSlug,
    ...additionalProps
  }) {
    const gradientOptions = (0, import_element109.useMemo)(() => {
      return gradients.map(({
        gradient,
        name,
        slug
      }, index2) => {
        const isSelected2 = selectedSlug ? slug === selectedSlug : value === gradient;
        return /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(circular_option_picker_default2.Option, {
          value: gradient,
          isSelected: isSelected2,
          tooltipText: name || // translators: %s: gradient code e.g: "linear-gradient(90deg, rgba(98,16,153,1) 0%, rgba(172,110,22,1) 100%);".
          (0, import_i18n34.sprintf)((0, import_i18n34.__)("Gradient code: %s"), gradient),
          style: {
            color: "rgba( 0,0,0,0 )",
            background: gradient
          },
          onClick: isSelected2 ? clearGradient : () => onChange(gradient, index2, slug),
          "aria-label": name ? (
            // translators: %s: The name of the gradient e.g: "Angular red to blue".
            (0, import_i18n34.sprintf)((0, import_i18n34.__)("Gradient: %s"), name)
          ) : (
            // translators: %s: gradient code e.g: "linear-gradient(90deg, rgba(98,16,153,1) 0%, rgba(172,110,22,1) 100%);".
            (0, import_i18n34.sprintf)((0, import_i18n34.__)("Gradient code: %s"), gradient)
          )
        }, slug);
      });
    }, [gradients, value, onChange, clearGradient, selectedSlug]);
    return /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(circular_option_picker_default2.OptionGroup, {
      className: className2,
      options: gradientOptions,
      ...additionalProps
    });
  }
  function MultipleOrigin({
    className: className2,
    clearGradient,
    gradients,
    onChange,
    value,
    selectedSlug,
    headingLevel
  }) {
    const instanceId = (0, import_compose42.useInstanceId)(MultipleOrigin);
    return /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(component_default18, {
      spacing: 3,
      className: className2,
      children: gradients.map(({
        name,
        gradients: gradientSet
      }, index2) => {
        const id3 = `color-palette-${instanceId}-${index2}`;
        return /* @__PURE__ */ (0, import_jsx_runtime176.jsxs)(component_default18, {
          spacing: 2,
          children: [/* @__PURE__ */ (0, import_jsx_runtime176.jsx)(ColorHeading, {
            level: headingLevel,
            id: id3,
            children: name
          }), /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(SingleOrigin, {
            clearGradient,
            gradients: gradientSet,
            onChange: (gradient, _index, slug) => onChange(gradient, index2, slug),
            value,
            selectedSlug,
            "aria-labelledby": id3
          })]
        }, index2);
      })
    });
  }
  function Component3(props) {
    const {
      asButtons,
      loop,
      actions,
      headingLevel,
      "aria-label": ariaLabel,
      "aria-labelledby": ariaLabelledby,
      ...additionalProps
    } = props;
    const options2 = isMultipleOriginArray(props.gradients) ? /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(MultipleOrigin, {
      headingLevel,
      ...additionalProps
    }) : /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(SingleOrigin, {
      ...additionalProps
    });
    const {
      metaProps,
      labelProps
    } = getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby);
    return /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(circular_option_picker_default2, {
      ...metaProps,
      ...labelProps,
      actions,
      options: options2
    });
  }
  function GradientPicker({
    className: className2,
    gradients = [],
    onChange,
    value,
    clearable = true,
    enableAlpha = true,
    disableCustomGradients = false,
    __experimentalIsRenderedInSidebar,
    headingLevel = 2,
    ...additionalProps
  }) {
    const clearGradient = (0, import_element109.useCallback)(() => onChange(void 0), [onChange]);
    return /* @__PURE__ */ (0, import_jsx_runtime176.jsxs)(component_default18, {
      spacing: gradients.length ? 4 : 0,
      children: [!disableCustomGradients && /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(custom_gradient_picker_default, {
        __experimentalIsRenderedInSidebar,
        enableAlpha,
        value,
        onChange
      }), (gradients.length > 0 || clearable) && /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(Component3, {
        ...additionalProps,
        className: className2,
        clearGradient,
        gradients,
        onChange,
        value,
        actions: clearable && !disableCustomGradients && /* @__PURE__ */ (0, import_jsx_runtime176.jsx)(circular_option_picker_default2.ButtonAction, {
          onClick: clearGradient,
          accessibleWhenDisabled: true,
          disabled: !value,
          children: (0, import_i18n34.__)("Clear")
        }),
        headingLevel
      })]
    });
  }
  var gradient_picker_default = GradientPicker;

  // packages/components/build-module/navigable-container/menu.mjs
  var import_element111 = __toESM(require_element(), 1);

  // packages/components/build-module/navigable-container/container.mjs
  var import_element110 = __toESM(require_element(), 1);
  var import_compose43 = __toESM(require_compose(), 1);
  var import_dom5 = __toESM(require_dom(), 1);
  var import_jsx_runtime177 = __toESM(require_jsx_runtime(), 1);
  var noop12 = () => {
  };
  var MENU_ITEM_ROLES = ["menuitem", "menuitemradio", "menuitemcheckbox"];
  function cycleValue(value, total, offset4) {
    const nextValue = value + offset4;
    if (nextValue < 0) {
      return total + nextValue;
    } else if (nextValue >= total) {
      return nextValue - total;
    }
    return nextValue;
  }
  function getFocusableContext(container, target, tabbableOnly) {
    const finder = tabbableOnly ? import_dom5.focus.tabbable : import_dom5.focus.focusable;
    const focusables = finder.find(container);
    const index2 = focusables.indexOf(target);
    if (index2 > -1) {
      return {
        index: index2,
        target,
        focusables
      };
    }
    return null;
  }
  function UnforwardedNavigableContainer({
    children,
    stopNavigationEvents,
    eventToOffset,
    onNavigate = noop12,
    onKeyDown,
    cycle = true,
    onlyBrowserTabstops,
    ...restProps
  }, ref) {
    const containerRef = (0, import_element110.useRef)(null);
    (0, import_element110.useEffect)(() => {
      const container = containerRef.current;
      if (!container) {
        return;
      }
      function handleKeyDown(event) {
        if (onKeyDown) {
          onKeyDown(event);
        }
        const offset4 = eventToOffset(event);
        if (offset4 !== void 0 && stopNavigationEvents) {
          event.stopImmediatePropagation();
          const targetRole = event.target?.getAttribute("role");
          const targetHasMenuItemRole = !!targetRole && MENU_ITEM_ROLES.includes(targetRole);
          if (targetHasMenuItemRole) {
            event.preventDefault();
          }
        }
        if (!offset4) {
          return;
        }
        const activeElement = event.target?.ownerDocument?.activeElement;
        if (!activeElement) {
          return;
        }
        const context = getFocusableContext(container, activeElement, !!onlyBrowserTabstops);
        if (!context) {
          return;
        }
        const {
          index: index2,
          focusables
        } = context;
        const nextIndex = cycle ? cycleValue(index2, focusables.length, offset4) : index2 + offset4;
        if (nextIndex >= 0 && nextIndex < focusables.length) {
          focusables[nextIndex].focus();
          onNavigate(nextIndex, focusables[nextIndex]);
          if (event.code === "Tab") {
            event.preventDefault();
          }
        }
      }
      container.addEventListener("keydown", handleKeyDown);
      return () => {
        container.removeEventListener("keydown", handleKeyDown);
      };
    }, [onKeyDown, eventToOffset, stopNavigationEvents, cycle, onNavigate, onlyBrowserTabstops]);
    const mergedRef = (0, import_compose43.useMergeRefs)([containerRef, ref]);
    return /* @__PURE__ */ (0, import_jsx_runtime177.jsx)("div", {
      ref: mergedRef,
      ...restProps,
      children
    });
  }
  var NavigableContainer = (0, import_element110.forwardRef)(UnforwardedNavigableContainer);
  NavigableContainer.displayName = "NavigableContainer";
  var container_default = NavigableContainer;

  // packages/components/build-module/navigable-container/menu.mjs
  var import_jsx_runtime178 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedNavigableMenu({
    role = "menu",
    orientation = "vertical",
    ...rest
  }, ref) {
    const eventToOffset = (evt) => {
      const {
        code
      } = evt;
      let next2 = ["ArrowDown"];
      let previous = ["ArrowUp"];
      if (orientation === "horizontal") {
        next2 = ["ArrowRight"];
        previous = ["ArrowLeft"];
      }
      if (orientation === "both") {
        next2 = ["ArrowRight", "ArrowDown"];
        previous = ["ArrowLeft", "ArrowUp"];
      }
      if (next2.includes(code)) {
        return 1;
      } else if (previous.includes(code)) {
        return -1;
      } else if (["ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight"].includes(code)) {
        return 0;
      }
      return void 0;
    };
    return /* @__PURE__ */ (0, import_jsx_runtime178.jsx)(container_default, {
      ref,
      stopNavigationEvents: true,
      onlyBrowserTabstops: false,
      role,
      "aria-orientation": role !== "presentation" && (orientation === "vertical" || orientation === "horizontal") ? orientation : void 0,
      eventToOffset,
      ...rest
    });
  }
  var NavigableMenu = (0, import_element111.forwardRef)(UnforwardedNavigableMenu);
  NavigableMenu.displayName = "NavigableMenu";
  var menu_default2 = NavigableMenu;

  // packages/components/build-module/navigable-container/tabbable.mjs
  var import_element112 = __toESM(require_element(), 1);
  var import_jsx_runtime179 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedTabbableContainer({
    eventToOffset,
    ...props
  }, ref) {
    const innerEventToOffset = (evt) => {
      const {
        code,
        shiftKey
      } = evt;
      if ("Tab" === code) {
        return shiftKey ? -1 : 1;
      }
      if (eventToOffset) {
        return eventToOffset(evt);
      }
      return void 0;
    };
    return /* @__PURE__ */ (0, import_jsx_runtime179.jsx)(container_default, {
      ref,
      stopNavigationEvents: true,
      onlyBrowserTabstops: true,
      eventToOffset: innerEventToOffset,
      ...props
    });
  }
  var TabbableContainer = (0, import_element112.forwardRef)(UnforwardedTabbableContainer);
  TabbableContainer.displayName = "TabbableContainer";
  var tabbable_default = TabbableContainer;

  // packages/components/build-module/dropdown-menu/index.mjs
  var import_jsx_runtime180 = __toESM(require_jsx_runtime(), 1);
  function mergeProps2(defaultProps = {}, props = {}) {
    const mergedProps = {
      ...defaultProps,
      ...props
    };
    if (props.className && defaultProps.className) {
      mergedProps.className = clsx_default(props.className, defaultProps.className);
    }
    return mergedProps;
  }
  function isFunction2(maybeFunc) {
    return typeof maybeFunc === "function";
  }
  function UnconnectedDropdownMenu(dropdownMenuProps) {
    const {
      children,
      className: className2,
      controls,
      icon = menu_default,
      label,
      popoverProps,
      toggleProps,
      menuProps,
      disableOpenOnArrowDown = false,
      text,
      noIcons,
      open,
      defaultOpen,
      onToggle: onToggleProp,
      // Context
      variant
    } = useContextSystem(dropdownMenuProps, "DropdownMenu");
    if (!controls?.length && !isFunction2(children)) {
      return null;
    }
    let controlSets;
    if (controls?.length) {
      controlSets = controls;
      if (!Array.isArray(controlSets[0])) {
        controlSets = [controls];
      }
    }
    const mergedPopoverProps = mergeProps2({
      className: "components-dropdown-menu__popover",
      variant
    }, popoverProps);
    return /* @__PURE__ */ (0, import_jsx_runtime180.jsx)(dropdown_default, {
      className: className2,
      popoverProps: mergedPopoverProps,
      renderToggle: ({
        isOpen,
        onToggle
      }) => {
        const openOnArrowDown = (event) => {
          if (disableOpenOnArrowDown) {
            return;
          }
          if (!isOpen && event.code === "ArrowDown") {
            event.preventDefault();
            onToggle();
          }
        };
        const {
          as: Toggle = button_default,
          ...restToggleProps
        } = toggleProps ?? {};
        const mergedToggleProps = mergeProps2({
          className: clsx_default("components-dropdown-menu__toggle", {
            "is-opened": isOpen
          })
        }, restToggleProps);
        return /* @__PURE__ */ (0, import_jsx_runtime180.jsx)(Toggle, {
          ...mergedToggleProps,
          icon,
          onClick: (event) => {
            onToggle();
            if (mergedToggleProps.onClick) {
              mergedToggleProps.onClick(event);
            }
          },
          onKeyDown: (event) => {
            openOnArrowDown(event);
            if (mergedToggleProps.onKeyDown) {
              mergedToggleProps.onKeyDown(event);
            }
          },
          "aria-haspopup": "true",
          "aria-expanded": isOpen,
          label,
          text,
          showTooltip: toggleProps?.showTooltip ?? true,
          children: mergedToggleProps.children
        });
      },
      renderContent: (props) => {
        const mergedMenuProps = mergeProps2({
          "aria-label": label,
          className: clsx_default("components-dropdown-menu__menu", {
            "no-icons": noIcons
          })
        }, menuProps);
        return /* @__PURE__ */ (0, import_jsx_runtime180.jsxs)(menu_default2, {
          ...mergedMenuProps,
          role: "menu",
          children: [isFunction2(children) ? children(props) : null, controlSets?.flatMap((controlSet, indexOfSet) => controlSet.map((control, indexOfControl) => /* @__PURE__ */ (0, import_jsx_runtime180.jsx)(button_default, {
            size: "compact",
            onClick: (event) => {
              event.stopPropagation();
              props.onClose();
              if (control.onClick) {
                control.onClick();
              }
            },
            className: clsx_default("components-dropdown-menu__menu-item", {
              "has-separator": indexOfSet > 0 && indexOfControl === 0,
              "is-active": control.isActive,
              "is-icon-only": !control.title
            }),
            icon: control.icon,
            label: control.label,
            "aria-checked": control.role === "menuitemcheckbox" || control.role === "menuitemradio" ? control.isActive : void 0,
            role: control.role === "menuitemcheckbox" || control.role === "menuitemradio" ? control.role : "menuitem",
            accessibleWhenDisabled: true,
            disabled: control.isDisabled,
            children: control.title
          }, [indexOfSet, indexOfControl].join())))]
        });
      },
      open,
      defaultOpen,
      onToggle: onToggleProp
    });
  }
  var DropdownMenu = contextConnectWithoutRef(UnconnectedDropdownMenu, "DropdownMenu");
  var dropdown_menu_default = DropdownMenu;

  // packages/components/build-module/palette-edit/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__21() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var IndicatorStyled = /* @__PURE__ */ createStyled(color_indicator_default, false ? {
    target: "e1lpqc908"
  } : {
    target: "e1lpqc908",
    label: "IndicatorStyled"
  })("&&{flex-shrink:0;width:", space(6), ";height:", space(6), ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var NameInputControl = /* @__PURE__ */ createStyled(input_control_default, false ? {
    target: "e1lpqc907"
  } : {
    target: "e1lpqc907",
    label: "NameInputControl"
  })(Container, "{background:", COLORS.gray[100], ";border-radius:", config_values_default.radiusXSmall, ";", Input, Input, Input, Input, "{height:", space(8), ";}", BackdropUI, BackdropUI, BackdropUI, "{border-color:transparent;box-shadow:none;}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var NameContainer = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1lpqc906"
  } : {
    target: "e1lpqc906",
    label: "NameContainer"
  })("line-height:", space(8), ";margin-left:", space(2), ";margin-right:", space(2), ";white-space:nowrap;overflow:hidden;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var PaletteHeading = /* @__PURE__ */ createStyled(component_default19, false ? {
    target: "e1lpqc905"
  } : {
    target: "e1lpqc905",
    label: "PaletteHeading"
  })("text-transform:uppercase;line-height:", space(6), ";font-weight:", config_values_default.fontWeightEmphasis, ";&&&{font-size:11px;margin-bottom:0;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var PaletteActionsContainer = /* @__PURE__ */ createStyled(component_default, false ? {
    target: "e1lpqc904"
  } : {
    target: "e1lpqc904",
    label: "PaletteActionsContainer"
  })("height:", space(6), ";display:flex;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var PaletteEditContents = /* @__PURE__ */ createStyled(component_default, false ? {
    target: "e1lpqc903"
  } : {
    target: "e1lpqc903",
    label: "PaletteEditContents"
  })("margin-top:", space(2), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var PaletteEditStyles = /* @__PURE__ */ createStyled(component_default, false ? {
    target: "e1lpqc902"
  } : {
    target: "e1lpqc902",
    label: "PaletteEditStyles"
  })(false ? {
    name: "u6wnko",
    styles: "&&&{.components-button.has-icon{min-width:0;padding:0;}}"
  } : {
    name: "u6wnko",
    styles: "&&&{.components-button.has-icon{min-width:0;padding:0;}}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__21
  });
  var DoneButton = /* @__PURE__ */ createStyled(button_default, false ? {
    target: "e1lpqc901"
  } : {
    target: "e1lpqc901",
    label: "DoneButton"
  })("&&{color:", COLORS.theme.accent, ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var RemoveButton = /* @__PURE__ */ createStyled(button_default, false ? {
    target: "e1lpqc900"
  } : {
    target: "e1lpqc900",
    label: "RemoveButton"
  })("&&{margin-top:", space(1), ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));

  // packages/components/build-module/palette-edit/index.mjs
  var import_jsx_runtime181 = __toESM(require_jsx_runtime(), 1);
  var DEFAULT_COLOR = "#000";
  function NameInput({
    value,
    onChange,
    label
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(NameInputControl, {
      size: "compact",
      label,
      hideLabelFromVision: true,
      value,
      onChange
    });
  }
  function deduplicateElementSlugs(elements2) {
    const slugCounts = {};
    return elements2.map((element) => {
      let newSlug;
      const {
        slug
      } = element;
      slugCounts[slug] = (slugCounts[slug] || 0) + 1;
      if (slugCounts[slug] > 1) {
        newSlug = `${slug}-${slugCounts[slug] - 1}`;
      }
      return {
        ...element,
        slug: newSlug ?? slug
      };
    });
  }
  function getNameAndSlugForPosition(elements2, slugPrefix) {
    const nameRegex = new RegExp(`^${slugPrefix}color-([\\d]+)$`);
    const position2 = elements2.reduce((previousValue, currentValue) => {
      if (typeof currentValue?.slug === "string") {
        const matches = currentValue?.slug.match(nameRegex);
        if (matches) {
          const id3 = parseInt(matches[1], 10);
          if (id3 >= previousValue) {
            return id3 + 1;
          }
        }
      }
      return previousValue;
    }, 1);
    return {
      name: (0, import_i18n35.sprintf)(
        /* translators: %d: is an id for a custom color */
        (0, import_i18n35.__)("Color %d"),
        position2
      ),
      slug: `${slugPrefix}color-${position2}`
    };
  }
  function ColorPickerPopover({
    isGradient,
    element,
    onChange,
    popoverProps: receivedPopoverProps,
    onClose = () => {
    }
  }) {
    const popoverProps = (0, import_element113.useMemo)(() => ({
      shift: true,
      offset: 20,
      // Disabling resize as it would otherwise cause the popover to show
      // scrollbars while dragging the color picker's handle close to the
      // popover edge.
      resize: false,
      placement: "left-start",
      ...receivedPopoverProps,
      className: clsx_default("components-palette-edit__popover", receivedPopoverProps?.className)
    }), [receivedPopoverProps]);
    return /* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(popover_default, {
      ...popoverProps,
      onClose,
      children: [!isGradient && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(LegacyAdapter, {
        color: element.color,
        enableAlpha: true,
        onChange: (newColor) => {
          onChange({
            ...element,
            color: newColor
          });
        }
      }), isGradient && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)("div", {
        className: "components-palette-edit__popover-gradient-picker",
        children: /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(custom_gradient_picker_default, {
          __experimentalIsRenderedInSidebar: true,
          value: element.gradient,
          onChange: (newGradient) => {
            onChange({
              ...element,
              gradient: newGradient
            });
          }
        })
      })]
    });
  }
  function Option2({
    canOnlyChangeValues,
    element,
    onChange,
    onRemove,
    popoverProps: receivedPopoverProps,
    slugPrefix,
    isGradient
  }) {
    const value = isGradient ? element.gradient : element.color;
    const [isEditingColor, setIsEditingColor] = (0, import_element113.useState)(false);
    const [popoverAnchor, setPopoverAnchor] = (0, import_element113.useState)(null);
    const popoverProps = (0, import_element113.useMemo)(() => ({
      ...receivedPopoverProps,
      // Use the custom palette color item as the popover anchor.
      anchor: popoverAnchor
    }), [popoverAnchor, receivedPopoverProps]);
    return /* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(component_default35, {
      ref: setPopoverAnchor,
      size: "small",
      children: [/* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(component_default9, {
        justify: "flex-start",
        children: [/* @__PURE__ */ (0, import_jsx_runtime181.jsx)(button_default, {
          size: "small",
          onClick: () => {
            setIsEditingColor(true);
          },
          "aria-label": (0, import_i18n35.sprintf)(
            // translators: %s is a color or gradient name, e.g. "Red".
            (0, import_i18n35.__)("Edit: %s"),
            element.name.trim().length ? element.name : value || ""
          ),
          style: {
            padding: 0
          },
          children: /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(IndicatorStyled, {
            colorValue: value
          })
        }), /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(component_default5, {
          children: !canOnlyChangeValues ? /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(NameInput, {
            label: isGradient ? (0, import_i18n35.__)("Gradient name") : (0, import_i18n35.__)("Color name"),
            value: element.name,
            onChange: (nextName) => onChange({
              ...element,
              name: nextName,
              slug: slugPrefix + kebabCase(nextName ?? "")
            })
          }) : /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(NameContainer, {
            children: element.name.trim().length ? element.name : (
              /* Fall back to non-breaking space to maintain height */
              "\xA0"
            )
          })
        }), !canOnlyChangeValues && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(component_default4, {
          children: /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(RemoveButton, {
            size: "small",
            icon: line_solid_default,
            label: (0, import_i18n35.sprintf)(
              // translators: %s is a color or gradient name, e.g. "Red".
              (0, import_i18n35.__)("Remove color: %s"),
              element.name.trim().length ? element.name : value || ""
            ),
            onClick: onRemove
          })
        })]
      }), isEditingColor && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(ColorPickerPopover, {
        isGradient,
        onChange,
        element,
        popoverProps,
        onClose: () => setIsEditingColor(false)
      })]
    });
  }
  function PaletteEditListView({
    elements: elements2,
    onChange,
    canOnlyChangeValues,
    slugPrefix,
    isGradient,
    popoverProps,
    addColorRef
  }) {
    const elementsReferenceRef = (0, import_element113.useRef)(void 0);
    (0, import_element113.useEffect)(() => {
      elementsReferenceRef.current = elements2;
    }, [elements2]);
    const debounceOnChange = (0, import_compose44.useDebounce)((updatedElements) => onChange(deduplicateElementSlugs(updatedElements)), 100);
    return /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(component_default18, {
      spacing: 3,
      children: /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(component_default36, {
        isRounded: true,
        isBordered: true,
        isSeparated: true,
        children: elements2.map((element, index2) => /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(Option2, {
          isGradient,
          canOnlyChangeValues,
          element,
          onChange: (newElement) => {
            debounceOnChange(elements2.map((currentElement, currentIndex) => {
              if (currentIndex === index2) {
                return newElement;
              }
              return currentElement;
            }));
          },
          onRemove: () => {
            const newElements = elements2.filter((_currentElement, currentIndex) => {
              if (currentIndex === index2) {
                return false;
              }
              return true;
            });
            onChange(newElements.length ? newElements : void 0);
            addColorRef.current?.focus();
          },
          slugPrefix,
          popoverProps
        }, index2))
      })
    });
  }
  var EMPTY_ARRAY = [];
  function PaletteEdit({
    gradients,
    colors = EMPTY_ARRAY,
    onChange,
    paletteLabel,
    paletteLabelHeadingLevel = 2,
    emptyMessage,
    canOnlyChangeValues,
    canReset,
    slugPrefix = "",
    popoverProps
  }) {
    const isGradient = !!gradients;
    const elements2 = isGradient ? gradients : colors;
    const [isEditing, setIsEditing] = (0, import_element113.useState)(false);
    const [editingElement, setEditingElement] = (0, import_element113.useState)(null);
    const isAdding = isEditing && !!editingElement && elements2[editingElement] && !elements2[editingElement].slug;
    const elementsLength = elements2.length;
    const hasElements = elementsLength > 0;
    const debounceOnChange = (0, import_compose44.useDebounce)(onChange, 100);
    const onSelectPaletteItem = (0, import_element113.useCallback)((value, newEditingElementIndex) => {
      const selectedElement = newEditingElementIndex === void 0 ? void 0 : elements2[newEditingElementIndex];
      const key = isGradient ? "gradient" : "color";
      if (!!selectedElement && selectedElement[key] === value) {
        setEditingElement(newEditingElementIndex);
      } else {
        setIsEditing(true);
      }
    }, [isGradient, elements2]);
    const addColorRef = (0, import_element113.useRef)(null);
    return /* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(PaletteEditStyles, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(component_default9, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime181.jsx)(PaletteHeading, {
          level: paletteLabelHeadingLevel,
          children: paletteLabel
        }), /* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(PaletteActionsContainer, {
          children: [hasElements && isEditing && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(DoneButton, {
            size: "small",
            onClick: () => {
              setIsEditing(false);
              setEditingElement(null);
            },
            children: (0, import_i18n35.__)("Done")
          }), !canOnlyChangeValues && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(button_default, {
            ref: addColorRef,
            size: "small",
            isPressed: isAdding,
            icon: plus_default,
            label: isGradient ? (0, import_i18n35.__)("Add gradient") : (0, import_i18n35.__)("Add color"),
            onClick: () => {
              const {
                name,
                slug
              } = getNameAndSlugForPosition(elements2, slugPrefix);
              if (!!gradients) {
                onChange([...gradients, {
                  gradient: DEFAULT_GRADIENT,
                  name,
                  slug
                }]);
              } else {
                onChange([...colors, {
                  color: DEFAULT_COLOR,
                  name,
                  slug
                }]);
              }
              setIsEditing(true);
              setEditingElement(elements2.length);
            }
          }), hasElements && (!isEditing || !canOnlyChangeValues || canReset) && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(dropdown_menu_default, {
            icon: more_vertical_default,
            label: isGradient ? (0, import_i18n35.__)("Gradient options") : (0, import_i18n35.__)("Color options"),
            toggleProps: {
              size: "small"
            },
            children: ({
              onClose
            }) => /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(import_jsx_runtime181.Fragment, {
              children: /* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(menu_default2, {
                role: "menu",
                children: [!isEditing && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(button_default, {
                  __next40pxDefaultSize: true,
                  variant: "tertiary",
                  onClick: () => {
                    setIsEditing(true);
                    onClose();
                  },
                  className: "components-palette-edit__menu-button",
                  children: (0, import_i18n35.__)("Show details")
                }), !canOnlyChangeValues && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(button_default, {
                  __next40pxDefaultSize: true,
                  variant: "tertiary",
                  onClick: () => {
                    setEditingElement(null);
                    setIsEditing(false);
                    onChange();
                    onClose();
                  },
                  className: "components-palette-edit__menu-button",
                  children: isGradient ? (0, import_i18n35.__)("Remove all gradients") : (0, import_i18n35.__)("Remove all colors")
                }), canReset && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(button_default, {
                  __next40pxDefaultSize: true,
                  className: "components-palette-edit__menu-button",
                  variant: "tertiary",
                  onClick: () => {
                    setEditingElement(null);
                    onChange();
                    onClose();
                  },
                  children: isGradient ? (0, import_i18n35.__)("Reset gradient") : (0, import_i18n35.__)("Reset colors")
                })]
              })
            })
          })]
        })]
      }), hasElements && /* @__PURE__ */ (0, import_jsx_runtime181.jsxs)(PaletteEditContents, {
        children: [isEditing && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(PaletteEditListView, {
          canOnlyChangeValues,
          elements: elements2,
          onChange,
          slugPrefix,
          isGradient,
          popoverProps,
          addColorRef
        }), !isEditing && editingElement !== null && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(ColorPickerPopover, {
          isGradient,
          onClose: () => setEditingElement(null),
          onChange: (newElement) => {
            debounceOnChange(
              // @ts-expect-error TODO: Don't know how to resolve
              elements2.map((currentElement, currentIndex) => {
                if (currentIndex === editingElement) {
                  return newElement;
                }
                return currentElement;
              })
            );
          },
          element: elements2[editingElement ?? -1],
          popoverProps
        }), !isEditing && (isGradient ? /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(gradient_picker_default, {
          gradients,
          onChange: onSelectPaletteItem,
          clearable: false,
          disableCustomGradients: true
        }) : /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(color_palette_default, {
          colors,
          onChange: onSelectPaletteItem,
          clearable: false,
          disableCustomColors: true
        }))]
      }), !hasElements && emptyMessage && /* @__PURE__ */ (0, import_jsx_runtime181.jsx)(PaletteEditContents, {
        children: emptyMessage
      })]
    });
  }
  var palette_edit_default = PaletteEdit;

  // packages/components/build-module/combobox-control/index.mjs
  var import_i18n37 = __toESM(require_i18n(), 1);
  var import_element117 = __toESM(require_element(), 1);
  var import_compose47 = __toESM(require_compose(), 1);
  var import_a11y5 = __toESM(require_a11y(), 1);

  // packages/components/build-module/combobox-control/styles.mjs
  var InputWrapperFlex = /* @__PURE__ */ createStyled(component_default3, false ? {
    target: "evuatpg0"
  } : {
    target: "evuatpg0",
    label: "InputWrapperFlex"
  })("height:38px;padding-left:", space(2), ";padding-right:", space(2), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJOEMiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuaW1wb3J0IHsgRmxleCB9IGZyb20gJy4uL2ZsZXgnO1xuaW1wb3J0IHsgc3BhY2UgfSBmcm9tICcuLi91dGlscy9zcGFjZSc7XG5cbmV4cG9ydCBjb25zdCBJbnB1dFdyYXBwZXJGbGV4ID0gc3R5bGVkKCBGbGV4IClgXG5cdGhlaWdodDogMzhweDsgLy8gNDBweCAtIDJweCB2ZXJ0aWNhbCBib3JkZXJzIG9uIHBhcmVudCBjb250YWluZXJcblx0cGFkZGluZy1sZWZ0OiAkeyBzcGFjZSggMiApIH07XG5cdHBhZGRpbmctcmlnaHQ6ICR7IHNwYWNlKCAyICkgfTtcbmA7XG4iXX0= */"));

  // packages/components/build-module/form-token-field/token-input.mjs
  var import_element114 = __toESM(require_element(), 1);
  var import_jsx_runtime182 = __toESM(require_jsx_runtime(), 1);
  function UnForwardedTokenInput(props, ref) {
    const {
      value,
      isExpanded,
      instanceId,
      selectedSuggestionIndex,
      className: className2,
      onChange,
      onFocus,
      onBlur,
      "aria-describedby": ariaDescribedBy,
      ...restProps
    } = props;
    const [hasFocus2, setHasFocus] = (0, import_element114.useState)(false);
    const size4 = value ? value.length + 1 : 0;
    const onChangeHandler = (event) => {
      if (onChange) {
        onChange({
          value: event.target.value
        });
      }
    };
    const onFocusHandler = (e3) => {
      setHasFocus(true);
      onFocus?.(e3);
    };
    const onBlurHandler = (e3) => {
      setHasFocus(false);
      onBlur?.(e3);
    };
    return /* @__PURE__ */ (0, import_jsx_runtime182.jsx)("input", {
      ref,
      id: `components-form-token-input-${instanceId}`,
      type: "text",
      ...restProps,
      value: value || "",
      onChange: onChangeHandler,
      onFocus: onFocusHandler,
      onBlur: onBlurHandler,
      size: size4,
      className: clsx_default(className2, "components-form-token-field__input"),
      autoComplete: "off",
      role: "combobox",
      "aria-expanded": isExpanded,
      "aria-autocomplete": "list",
      "aria-owns": isExpanded ? `components-form-token-suggestions-${instanceId}` : void 0,
      "aria-activedescendant": (
        // Only add the `aria-activedescendant` attribute when:
        // - the user is actively interacting with the input (`hasFocus`)
        // - there is a selected suggestion (`selectedSuggestionIndex !== -1`)
        // - the list of suggestions are rendered in the DOM (`isExpanded`)
        hasFocus2 && selectedSuggestionIndex !== -1 && isExpanded ? `components-form-token-suggestions-${instanceId}-${selectedSuggestionIndex}` : void 0
      ),
      "aria-describedby": ariaDescribedBy
    });
  }
  var TokenInput = (0, import_element114.forwardRef)(UnForwardedTokenInput);
  TokenInput.displayName = "TokenInput";
  var token_input_default = TokenInput;

  // packages/components/build-module/form-token-field/suggestions-list.mjs
  var import_compose45 = __toESM(require_compose(), 1);
  var import_i18n36 = __toESM(require_i18n(), 1);
  var import_jsx_runtime183 = __toESM(require_jsx_runtime(), 1);
  var handleMouseDown = (e3) => {
    e3.preventDefault();
  };
  function SuggestionsList({
    selectedIndex,
    scrollIntoView,
    match: match4,
    onHover,
    onSelect,
    suggestions = [],
    displayTransform,
    instanceId,
    __experimentalRenderItem
  }) {
    const listRef = (0, import_compose45.useRefEffect)((listNode) => {
      if (selectedIndex > -1 && scrollIntoView && listNode.children[selectedIndex]) {
        listNode.children[selectedIndex].scrollIntoView({
          behavior: "instant",
          block: "nearest",
          inline: "nearest"
        });
      }
    }, [selectedIndex, scrollIntoView]);
    const handleHover = (suggestion) => {
      return () => {
        onHover?.(suggestion);
      };
    };
    const handleClick = (suggestion) => {
      return () => {
        onSelect?.(suggestion);
      };
    };
    const computeSuggestionMatch = (suggestion) => {
      const matchText = displayTransform(match4).normalize("NFKC").toLocaleLowerCase();
      if (matchText.length === 0) {
        return null;
      }
      const transformedSuggestion = displayTransform(suggestion);
      const indexOfMatch = transformedSuggestion.normalize("NFKC").toLocaleLowerCase().indexOf(matchText);
      return {
        suggestionBeforeMatch: transformedSuggestion.substring(0, indexOfMatch),
        suggestionMatch: transformedSuggestion.substring(indexOfMatch, indexOfMatch + matchText.length),
        suggestionAfterMatch: transformedSuggestion.substring(indexOfMatch + matchText.length)
      };
    };
    return /* @__PURE__ */ (0, import_jsx_runtime183.jsxs)("ul", {
      ref: listRef,
      className: "components-form-token-field__suggestions-list",
      id: `components-form-token-suggestions-${instanceId}`,
      role: "listbox",
      children: [suggestions.map((suggestion, index2) => {
        const matchText = computeSuggestionMatch(suggestion);
        const isSelected2 = index2 === selectedIndex;
        const isDisabled = typeof suggestion === "object" && suggestion?.disabled;
        const key = typeof suggestion === "object" && "value" in suggestion ? suggestion?.value : displayTransform(suggestion);
        const className2 = clsx_default("components-form-token-field__suggestion", {
          "is-selected": isSelected2
        });
        let output;
        if (typeof __experimentalRenderItem === "function") {
          output = __experimentalRenderItem({
            item: suggestion
          });
        } else if (matchText) {
          output = /* @__PURE__ */ (0, import_jsx_runtime183.jsxs)("span", {
            "aria-label": displayTransform(suggestion),
            children: [matchText.suggestionBeforeMatch, /* @__PURE__ */ (0, import_jsx_runtime183.jsx)("strong", {
              className: "components-form-token-field__suggestion-match",
              children: matchText.suggestionMatch
            }), matchText.suggestionAfterMatch]
          });
        } else {
          output = displayTransform(suggestion);
        }
        return /* @__PURE__ */ (0, import_jsx_runtime183.jsx)("li", {
          id: `components-form-token-suggestions-${instanceId}-${index2}`,
          role: "option",
          className: className2,
          onMouseDown: handleMouseDown,
          onClick: handleClick(suggestion),
          onMouseEnter: handleHover(suggestion),
          "aria-selected": index2 === selectedIndex,
          "aria-disabled": isDisabled,
          children: output
        }, key);
      }), suggestions.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime183.jsx)("li", {
        className: "components-form-token-field__suggestion is-empty",
        children: (0, import_i18n36.__)("No items found")
      })]
    });
  }
  var suggestions_list_default = SuggestionsList;

  // packages/components/build-module/higher-order/with-focus-outside/index.mjs
  var import_element115 = __toESM(require_element(), 1);
  var import_compose46 = __toESM(require_compose(), 1);
  var import_jsx_runtime184 = __toESM(require_jsx_runtime(), 1);
  var with_focus_outside_default = (0, import_compose46.createHigherOrderComponent)((WrappedComponent) => function WithFocusOutside(props) {
    const [handleFocusOutside, setHandleFocusOutside] = (0, import_element115.useState)(void 0);
    const bindFocusOutsideHandler = (0, import_element115.useCallback)((node2) => setHandleFocusOutside(() => node2?.handleFocusOutside ? node2.handleFocusOutside.bind(node2) : void 0), []);
    return /* @__PURE__ */ (0, import_jsx_runtime184.jsx)("div", {
      ...(0, import_compose46.__experimentalUseFocusOutside)(handleFocusOutside),
      children: /* @__PURE__ */ (0, import_jsx_runtime184.jsx)(WrappedComponent, {
        ref: bindFocusOutsideHandler,
        ...props
      })
    });
  }, "withFocusOutside");

  // packages/components/build-module/spinner/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__22() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var spinAnimation = keyframes2`
	from {
		transform: rotate(0deg);
	}
	to {
		transform: rotate(360deg);
	}
 `;
  var StyledSpinner = /* @__PURE__ */ createStyled("svg", false ? {
    target: "ea4tfvq2"
  } : {
    target: "ea4tfvq2",
    label: "StyledSpinner"
  })("width:", config_values_default.spinnerSize, "px;height:", config_values_default.spinnerSize, "px;display:inline-block;margin:5px 11px 0;position:relative;color:", COLORS.theme.accent, ";overflow:visible;opacity:1;background-color:transparent;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFvQnVDIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbmltcG9ydCB7IGNzcywga2V5ZnJhbWVzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBDT0xPUlMsIENPTkZJRyB9IGZyb20gJy4uL3V0aWxzJztcblxuY29uc3Qgc3BpbkFuaW1hdGlvbiA9IGtleWZyYW1lc2Bcblx0ZnJvbSB7XG5cdFx0dHJhbnNmb3JtOiByb3RhdGUoMGRlZyk7XG5cdH1cblx0dG8ge1xuXHRcdHRyYW5zZm9ybTogcm90YXRlKDM2MGRlZyk7XG5cdH1cbiBgO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkU3Bpbm5lciA9IHN0eWxlZC5zdmdgXG5cdHdpZHRoOiAkeyBDT05GSUcuc3Bpbm5lclNpemUgfXB4O1xuXHRoZWlnaHQ6ICR7IENPTkZJRy5zcGlubmVyU2l6ZSB9cHg7XG5cdGRpc3BsYXk6IGlubGluZS1ibG9jaztcblx0bWFyZ2luOiA1cHggMTFweCAwO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuYWNjZW50IH07XG5cdG92ZXJmbG93OiB2aXNpYmxlO1xuXHRvcGFjaXR5OiAxO1xuXHRiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDtcbmA7XG5cbmNvbnN0IGNvbW1vblBhdGhQcm9wcyA9IGNzc2Bcblx0ZmlsbDogdHJhbnNwYXJlbnQ7XG5cdHN0cm9rZS13aWR0aDogMS41cHg7XG5gO1xuXG4vLyBUT0RPOiBzaG91bGQgdXNlIHRoZSBgc3Ryb2tlLXN1cmZhY2UtbmV1dHJhbGAgV1BEUyB0b2tlbiB3aGVuIHJlZmFjdG9yZWQgdG8gU0NTUyBtb2R1bGVzXG5leHBvcnQgY29uc3QgU3Bpbm5lclRyYWNrID0gc3R5bGVkLmNpcmNsZWBcblx0JHsgY29tbW9uUGF0aFByb3BzIH07XG5cdHN0cm9rZTogJHsgQ09MT1JTLmdyYXlbIDMwMCBdIH07XG5gO1xuXG5leHBvcnQgY29uc3QgU3Bpbm5lckluZGljYXRvciA9IHN0eWxlZC5wYXRoYFxuXHQkeyBjb21tb25QYXRoUHJvcHMgfTtcblx0c3Ryb2tlOiBjdXJyZW50Q29sb3I7XG5cdHN0cm9rZS1saW5lY2FwOiByb3VuZDtcblx0dHJhbnNmb3JtLW9yaWdpbjogNTAlIDUwJTtcblx0YW5pbWF0aW9uOiAxLjRzIGxpbmVhciBpbmZpbml0ZSBib3RoICR7IHNwaW5BbmltYXRpb24gfTtcbmA7XG4iXX0= */"));
  var commonPathProps = false ? {
    name: "9s4963",
    styles: "fill:transparent;stroke-width:1.5px"
  } : {
    name: "o2zng0-commonPathProps",
    styles: "fill:transparent;stroke-width:1.5px;label:commonPathProps;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFnQzJCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbmltcG9ydCB7IGNzcywga2V5ZnJhbWVzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBDT0xPUlMsIENPTkZJRyB9IGZyb20gJy4uL3V0aWxzJztcblxuY29uc3Qgc3BpbkFuaW1hdGlvbiA9IGtleWZyYW1lc2Bcblx0ZnJvbSB7XG5cdFx0dHJhbnNmb3JtOiByb3RhdGUoMGRlZyk7XG5cdH1cblx0dG8ge1xuXHRcdHRyYW5zZm9ybTogcm90YXRlKDM2MGRlZyk7XG5cdH1cbiBgO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkU3Bpbm5lciA9IHN0eWxlZC5zdmdgXG5cdHdpZHRoOiAkeyBDT05GSUcuc3Bpbm5lclNpemUgfXB4O1xuXHRoZWlnaHQ6ICR7IENPTkZJRy5zcGlubmVyU2l6ZSB9cHg7XG5cdGRpc3BsYXk6IGlubGluZS1ibG9jaztcblx0bWFyZ2luOiA1cHggMTFweCAwO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuYWNjZW50IH07XG5cdG92ZXJmbG93OiB2aXNpYmxlO1xuXHRvcGFjaXR5OiAxO1xuXHRiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDtcbmA7XG5cbmNvbnN0IGNvbW1vblBhdGhQcm9wcyA9IGNzc2Bcblx0ZmlsbDogdHJhbnNwYXJlbnQ7XG5cdHN0cm9rZS13aWR0aDogMS41cHg7XG5gO1xuXG4vLyBUT0RPOiBzaG91bGQgdXNlIHRoZSBgc3Ryb2tlLXN1cmZhY2UtbmV1dHJhbGAgV1BEUyB0b2tlbiB3aGVuIHJlZmFjdG9yZWQgdG8gU0NTUyBtb2R1bGVzXG5leHBvcnQgY29uc3QgU3Bpbm5lclRyYWNrID0gc3R5bGVkLmNpcmNsZWBcblx0JHsgY29tbW9uUGF0aFByb3BzIH07XG5cdHN0cm9rZTogJHsgQ09MT1JTLmdyYXlbIDMwMCBdIH07XG5gO1xuXG5leHBvcnQgY29uc3QgU3Bpbm5lckluZGljYXRvciA9IHN0eWxlZC5wYXRoYFxuXHQkeyBjb21tb25QYXRoUHJvcHMgfTtcblx0c3Ryb2tlOiBjdXJyZW50Q29sb3I7XG5cdHN0cm9rZS1saW5lY2FwOiByb3VuZDtcblx0dHJhbnNmb3JtLW9yaWdpbjogNTAlIDUwJTtcblx0YW5pbWF0aW9uOiAxLjRzIGxpbmVhciBpbmZpbml0ZSBib3RoICR7IHNwaW5BbmltYXRpb24gfTtcbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__22
  };
  var SpinnerTrack = /* @__PURE__ */ createStyled("circle", false ? {
    target: "ea4tfvq1"
  } : {
    target: "ea4tfvq1",
    label: "SpinnerTrack"
  })(commonPathProps, ";stroke:", COLORS.gray[300], ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQ3lDIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbmltcG9ydCB7IGNzcywga2V5ZnJhbWVzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBDT0xPUlMsIENPTkZJRyB9IGZyb20gJy4uL3V0aWxzJztcblxuY29uc3Qgc3BpbkFuaW1hdGlvbiA9IGtleWZyYW1lc2Bcblx0ZnJvbSB7XG5cdFx0dHJhbnNmb3JtOiByb3RhdGUoMGRlZyk7XG5cdH1cblx0dG8ge1xuXHRcdHRyYW5zZm9ybTogcm90YXRlKDM2MGRlZyk7XG5cdH1cbiBgO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkU3Bpbm5lciA9IHN0eWxlZC5zdmdgXG5cdHdpZHRoOiAkeyBDT05GSUcuc3Bpbm5lclNpemUgfXB4O1xuXHRoZWlnaHQ6ICR7IENPTkZJRy5zcGlubmVyU2l6ZSB9cHg7XG5cdGRpc3BsYXk6IGlubGluZS1ibG9jaztcblx0bWFyZ2luOiA1cHggMTFweCAwO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuYWNjZW50IH07XG5cdG92ZXJmbG93OiB2aXNpYmxlO1xuXHRvcGFjaXR5OiAxO1xuXHRiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDtcbmA7XG5cbmNvbnN0IGNvbW1vblBhdGhQcm9wcyA9IGNzc2Bcblx0ZmlsbDogdHJhbnNwYXJlbnQ7XG5cdHN0cm9rZS13aWR0aDogMS41cHg7XG5gO1xuXG4vLyBUT0RPOiBzaG91bGQgdXNlIHRoZSBgc3Ryb2tlLXN1cmZhY2UtbmV1dHJhbGAgV1BEUyB0b2tlbiB3aGVuIHJlZmFjdG9yZWQgdG8gU0NTUyBtb2R1bGVzXG5leHBvcnQgY29uc3QgU3Bpbm5lclRyYWNrID0gc3R5bGVkLmNpcmNsZWBcblx0JHsgY29tbW9uUGF0aFByb3BzIH07XG5cdHN0cm9rZTogJHsgQ09MT1JTLmdyYXlbIDMwMCBdIH07XG5gO1xuXG5leHBvcnQgY29uc3QgU3Bpbm5lckluZGljYXRvciA9IHN0eWxlZC5wYXRoYFxuXHQkeyBjb21tb25QYXRoUHJvcHMgfTtcblx0c3Ryb2tlOiBjdXJyZW50Q29sb3I7XG5cdHN0cm9rZS1saW5lY2FwOiByb3VuZDtcblx0dHJhbnNmb3JtLW9yaWdpbjogNTAlIDUwJTtcblx0YW5pbWF0aW9uOiAxLjRzIGxpbmVhciBpbmZpbml0ZSBib3RoICR7IHNwaW5BbmltYXRpb24gfTtcbmA7XG4iXX0= */"));
  var SpinnerIndicator = /* @__PURE__ */ createStyled("path", false ? {
    target: "ea4tfvq0"
  } : {
    target: "ea4tfvq0",
    label: "SpinnerIndicator"
  })(commonPathProps, ";stroke:currentColor;stroke-linecap:round;transform-origin:50% 50%;animation:1.4s linear infinite both ", spinAnimation, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUEyQzJDIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcbmltcG9ydCB7IGNzcywga2V5ZnJhbWVzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBDT0xPUlMsIENPTkZJRyB9IGZyb20gJy4uL3V0aWxzJztcblxuY29uc3Qgc3BpbkFuaW1hdGlvbiA9IGtleWZyYW1lc2Bcblx0ZnJvbSB7XG5cdFx0dHJhbnNmb3JtOiByb3RhdGUoMGRlZyk7XG5cdH1cblx0dG8ge1xuXHRcdHRyYW5zZm9ybTogcm90YXRlKDM2MGRlZyk7XG5cdH1cbiBgO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkU3Bpbm5lciA9IHN0eWxlZC5zdmdgXG5cdHdpZHRoOiAkeyBDT05GSUcuc3Bpbm5lclNpemUgfXB4O1xuXHRoZWlnaHQ6ICR7IENPTkZJRy5zcGlubmVyU2l6ZSB9cHg7XG5cdGRpc3BsYXk6IGlubGluZS1ibG9jaztcblx0bWFyZ2luOiA1cHggMTFweCAwO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuYWNjZW50IH07XG5cdG92ZXJmbG93OiB2aXNpYmxlO1xuXHRvcGFjaXR5OiAxO1xuXHRiYWNrZ3JvdW5kLWNvbG9yOiB0cmFuc3BhcmVudDtcbmA7XG5cbmNvbnN0IGNvbW1vblBhdGhQcm9wcyA9IGNzc2Bcblx0ZmlsbDogdHJhbnNwYXJlbnQ7XG5cdHN0cm9rZS13aWR0aDogMS41cHg7XG5gO1xuXG4vLyBUT0RPOiBzaG91bGQgdXNlIHRoZSBgc3Ryb2tlLXN1cmZhY2UtbmV1dHJhbGAgV1BEUyB0b2tlbiB3aGVuIHJlZmFjdG9yZWQgdG8gU0NTUyBtb2R1bGVzXG5leHBvcnQgY29uc3QgU3Bpbm5lclRyYWNrID0gc3R5bGVkLmNpcmNsZWBcblx0JHsgY29tbW9uUGF0aFByb3BzIH07XG5cdHN0cm9rZTogJHsgQ09MT1JTLmdyYXlbIDMwMCBdIH07XG5gO1xuXG5leHBvcnQgY29uc3QgU3Bpbm5lckluZGljYXRvciA9IHN0eWxlZC5wYXRoYFxuXHQkeyBjb21tb25QYXRoUHJvcHMgfTtcblx0c3Ryb2tlOiBjdXJyZW50Q29sb3I7XG5cdHN0cm9rZS1saW5lY2FwOiByb3VuZDtcblx0dHJhbnNmb3JtLW9yaWdpbjogNTAlIDUwJTtcblx0YW5pbWF0aW9uOiAxLjRzIGxpbmVhciBpbmZpbml0ZSBib3RoICR7IHNwaW5BbmltYXRpb24gfTtcbmA7XG4iXX0= */"));

  // packages/components/build-module/spinner/index.mjs
  var import_element116 = __toESM(require_element(), 1);
  var import_jsx_runtime185 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedSpinner({
    className: className2,
    ...props
  }, forwardedRef) {
    return /* @__PURE__ */ (0, import_jsx_runtime185.jsxs)(StyledSpinner, {
      className: clsx_default("components-spinner", className2),
      viewBox: "0 0 100 100",
      width: "16",
      height: "16",
      xmlns: "http://www.w3.org/2000/svg",
      role: "presentation",
      focusable: "false",
      ...props,
      ref: forwardedRef,
      children: [/* @__PURE__ */ (0, import_jsx_runtime185.jsx)(SpinnerTrack, {
        cx: "50",
        cy: "50",
        r: "50",
        vectorEffect: "non-scaling-stroke"
      }), /* @__PURE__ */ (0, import_jsx_runtime185.jsx)(SpinnerIndicator, {
        d: "m 50 0 a 50 50 0 0 1 50 50",
        vectorEffect: "non-scaling-stroke"
      })]
    });
  }
  var Spinner = (0, import_element116.forwardRef)(UnforwardedSpinner);
  Spinner.displayName = "Spinner";
  var spinner_default = Spinner;

  // packages/components/build-module/combobox-control/index.mjs
  var import_jsx_runtime186 = __toESM(require_jsx_runtime(), 1);
  var noop13 = () => {
  };
  var DetectOutside = with_focus_outside_default(class DetectOutsideComponent extends import_element117.Component {
    handleFocusOutside(event) {
      this.props.onFocusOutside(event);
    }
    render() {
      return this.props.children;
    }
  });
  var getIndexOfMatchingSuggestion = (selectedSuggestion, matchingSuggestions) => selectedSuggestion === null ? -1 : matchingSuggestions.indexOf(selectedSuggestion);
  function ComboboxControl(props) {
    const {
      value: valueProp,
      label,
      options: options2,
      onChange: onChangeProp,
      onFilterValueChange = noop13,
      hideLabelFromVision,
      help,
      allowReset = true,
      className: className2,
      isLoading = false,
      messages = {
        selected: (0, import_i18n37.__)("Item selected.")
      },
      __experimentalRenderItem,
      expandOnFocus = true,
      placeholder
    } = props;
    const [value, setValue] = useControlledValue({
      value: valueProp,
      onChange: onChangeProp
    });
    const currentOption = options2.find((option) => option.value === value);
    const currentLabel = currentOption?.label ?? "";
    const instanceId = (0, import_compose47.useInstanceId)(ComboboxControl, "combobox-control");
    const [selectedSuggestion, setSelectedSuggestion] = (0, import_element117.useState)(currentOption || null);
    const [isExpanded, setIsExpanded] = (0, import_element117.useState)(false);
    const [inputHasFocus, setInputHasFocus] = (0, import_element117.useState)(false);
    const [inputValue, setInputValue] = (0, import_element117.useState)("");
    const inputContainer = (0, import_element117.useRef)(null);
    const matchingSuggestions = (0, import_element117.useMemo)(() => {
      const startsWithMatch = [];
      const containsMatch = [];
      const match4 = normalizeTextString(inputValue);
      options2.forEach((option) => {
        const index2 = normalizeTextString(option.label).indexOf(match4);
        if (index2 === 0) {
          startsWithMatch.push(option);
        } else if (index2 > 0) {
          containsMatch.push(option);
        }
      });
      return startsWithMatch.concat(containsMatch);
    }, [inputValue, options2]);
    const onSuggestionSelected = (newSelectedSuggestion) => {
      if (newSelectedSuggestion.disabled) {
        return;
      }
      setValue(newSelectedSuggestion.value);
      (0, import_a11y5.speak)(messages.selected, "assertive");
      setSelectedSuggestion(newSelectedSuggestion);
      setInputValue("");
      setIsExpanded(false);
    };
    const handleArrowNavigation = (offset4 = 1) => {
      const index2 = getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions);
      let nextIndex = index2 + offset4;
      if (nextIndex < 0) {
        nextIndex = matchingSuggestions.length - 1;
      } else if (nextIndex >= matchingSuggestions.length) {
        nextIndex = 0;
      }
      setSelectedSuggestion(matchingSuggestions[nextIndex]);
      setIsExpanded(true);
    };
    const onKeyDown = withIgnoreIMEEvents((event) => {
      let preventDefault = false;
      if (event.defaultPrevented) {
        return;
      }
      switch (event.code) {
        case "Enter":
          if (selectedSuggestion) {
            onSuggestionSelected(selectedSuggestion);
            preventDefault = true;
          }
          break;
        case "ArrowUp":
          handleArrowNavigation(-1);
          preventDefault = true;
          break;
        case "ArrowDown":
          handleArrowNavigation(1);
          preventDefault = true;
          break;
        case "Escape":
          setIsExpanded(false);
          setSelectedSuggestion(null);
          preventDefault = true;
          break;
        default:
          break;
      }
      if (preventDefault) {
        event.preventDefault();
      }
    });
    const onBlur = () => {
      setInputHasFocus(false);
    };
    const onFocus = () => {
      setInputHasFocus(true);
      if (expandOnFocus) {
        setIsExpanded(true);
      }
      onFilterValueChange("");
      setInputValue("");
    };
    const onClick = () => {
      setIsExpanded(true);
    };
    const onFocusOutside = () => {
      setIsExpanded(false);
    };
    const onInputChange = (event) => {
      const text = event.value;
      setInputValue(text);
      onFilterValueChange(text);
      if (inputHasFocus) {
        setIsExpanded(true);
      }
    };
    const handleOnReset = () => {
      setValue(null);
      inputContainer.current?.focus();
    };
    const handleResetStopPropagation = (event) => {
      event.stopPropagation();
    };
    (0, import_element117.useEffect)(() => {
      const hasMatchingSuggestions = matchingSuggestions.length > 0;
      const hasSelectedMatchingSuggestions = getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions) > 0;
      if (hasMatchingSuggestions && !hasSelectedMatchingSuggestions) {
        setSelectedSuggestion(matchingSuggestions[0]);
      }
    }, [matchingSuggestions, selectedSuggestion]);
    (0, import_element117.useEffect)(() => {
      const hasMatchingSuggestions = matchingSuggestions.length > 0;
      if (isExpanded) {
        const message2 = hasMatchingSuggestions ? (0, import_i18n37.sprintf)(
          /* translators: %d: number of results. */
          (0, import_i18n37._n)("%d result found, use up and down arrow keys to navigate.", "%d results found, use up and down arrow keys to navigate.", matchingSuggestions.length),
          matchingSuggestions.length
        ) : (0, import_i18n37.__)("No results.");
        (0, import_a11y5.speak)(message2, "polite");
      }
    }, [matchingSuggestions, isExpanded]);
    return /* @__PURE__ */ (0, import_jsx_runtime186.jsx)(DetectOutside, {
      onFocusOutside,
      children: /* @__PURE__ */ (0, import_jsx_runtime186.jsx)(base_control_default, {
        className: clsx_default(className2, "components-combobox-control"),
        label,
        id: `components-form-token-input-${instanceId}`,
        hideLabelFromVision,
        help,
        children: /* @__PURE__ */ (0, import_jsx_runtime186.jsxs)("div", {
          className: "components-combobox-control__suggestions-container",
          tabIndex: -1,
          onKeyDown,
          children: [/* @__PURE__ */ (0, import_jsx_runtime186.jsxs)(InputWrapperFlex, {
            children: [/* @__PURE__ */ (0, import_jsx_runtime186.jsx)(component_default5, {
              children: /* @__PURE__ */ (0, import_jsx_runtime186.jsx)(token_input_default, {
                className: "components-combobox-control__input",
                instanceId,
                ref: inputContainer,
                placeholder,
                value: isExpanded ? inputValue : currentLabel,
                onFocus,
                onBlur,
                onClick,
                isExpanded,
                selectedSuggestionIndex: getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions),
                onChange: onInputChange,
                "aria-describedby": help ? (
                  // TODO: Refactor `TokenInput` to not use hardcoded IDs.
                  `components-form-token-input-${instanceId}__help`
                ) : void 0
              })
            }), isLoading && /* @__PURE__ */ (0, import_jsx_runtime186.jsx)(spinner_default, {}), allowReset && Boolean(value) && !isExpanded && /* @__PURE__ */ (0, import_jsx_runtime186.jsx)(button_default, {
              size: "small",
              icon: close_small_default,
              onClick: handleOnReset,
              onKeyDown: handleResetStopPropagation,
              label: (0, import_i18n37.__)("Reset")
            })]
          }), isExpanded && !isLoading && /* @__PURE__ */ (0, import_jsx_runtime186.jsx)(suggestions_list_default, {
            instanceId,
            match: {
              label: inputValue,
              value: ""
            },
            displayTransform: (suggestion) => suggestion.label,
            suggestions: matchingSuggestions,
            selectedIndex: getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions),
            onHover: setSelectedSuggestion,
            onSelect: onSuggestionSelected,
            scrollIntoView: true,
            __experimentalRenderItem
          })]
        })
      })
    });
  }
  var combobox_control_default = ComboboxControl;

  // packages/components/build-module/composite/legacy/index.mjs
  var import_element118 = __toESM(require_element(), 1);
  var import_compose48 = __toESM(require_compose(), 1);
  var import_deprecated12 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime187 = __toESM(require_jsx_runtime(), 1);
  function mapLegacyStatePropsToComponentProps(legacyProps) {
    if (legacyProps.state) {
      const {
        state,
        ...rest
      } = legacyProps;
      const {
        store,
        ...props
      } = mapLegacyStatePropsToComponentProps(state);
      return {
        ...rest,
        ...props,
        store
      };
    }
    return legacyProps;
  }
  var LEGACY_TO_NEW_DISPLAY_NAME = {
    __unstableComposite: "Composite",
    __unstableCompositeGroup: "Composite.Group or Composite.Row",
    __unstableCompositeItem: "Composite.Item",
    __unstableUseCompositeState: "Composite"
  };
  function proxyComposite(ProxiedComponent, propMap = {}) {
    const displayName = ProxiedComponent.displayName ?? "";
    const Component7 = (legacyProps) => {
      (0, import_deprecated12.default)(`wp.components.${displayName}`, {
        since: "6.7",
        alternative: LEGACY_TO_NEW_DISPLAY_NAME.hasOwnProperty(displayName) ? LEGACY_TO_NEW_DISPLAY_NAME[displayName] : void 0
      });
      const {
        store,
        ...rest
      } = mapLegacyStatePropsToComponentProps(legacyProps);
      let props = rest;
      props = {
        ...props,
        id: (0, import_compose48.useInstanceId)(store, props.baseId, props.id)
      };
      Object.entries(propMap).forEach(([from2, to]) => {
        if (props.hasOwnProperty(from2)) {
          Object.assign(props, {
            [to]: props[from2]
          });
          delete props[from2];
        }
      });
      delete props.baseId;
      return /* @__PURE__ */ (0, import_jsx_runtime187.jsx)(ProxiedComponent, {
        ...props,
        store
      });
    };
    Component7.displayName = displayName;
    return Component7;
  }
  var UnproxiedCompositeGroup = (0, import_element118.forwardRef)(({
    role,
    ...props
  }, ref) => {
    const Component7 = role === "row" ? Composite22.Row : Composite22.Group;
    return /* @__PURE__ */ (0, import_jsx_runtime187.jsx)(Component7, {
      ref,
      role,
      ...props
    });
  });
  var Composite4 = proxyComposite(Object.assign(Composite22, {
    displayName: "__unstableComposite"
  }), {
    baseId: "id"
  });
  var CompositeGroup4 = proxyComposite(Object.assign(UnproxiedCompositeGroup, {
    displayName: "__unstableCompositeGroup"
  }));
  var CompositeItem4 = proxyComposite(Object.assign(Composite22.Item, {
    displayName: "__unstableCompositeItem"
  }), {
    focusable: "accessibleWhenDisabled"
  });
  function useCompositeState(legacyStateOptions = {}) {
    (0, import_deprecated12.default)(`wp.components.__unstableUseCompositeState`, {
      since: "6.7",
      alternative: LEGACY_TO_NEW_DISPLAY_NAME.__unstableUseCompositeState
    });
    const {
      baseId,
      currentId: defaultActiveId,
      orientation,
      rtl: rtl2 = false,
      loop: focusLoop = false,
      wrap: focusWrap = false,
      shift: focusShift = false,
      unstable_virtual: virtualFocus
    } = legacyStateOptions;
    return {
      baseId: (0, import_compose48.useInstanceId)(Composite4, "composite", baseId),
      store: useCompositeStore({
        defaultActiveId,
        rtl: rtl2,
        orientation,
        focusLoop,
        focusShift,
        focusWrap,
        virtualFocus
      })
    };
  }

  // packages/components/build-module/confirm-dialog/component.mjs
  var import_i18n39 = __toESM(require_i18n(), 1);
  var import_element122 = __toESM(require_element(), 1);

  // packages/components/build-module/modal/index.mjs
  var import_element121 = __toESM(require_element(), 1);
  var import_compose50 = __toESM(require_compose(), 1);
  var import_i18n38 = __toESM(require_i18n(), 1);
  var import_dom6 = __toESM(require_dom(), 1);

  // packages/components/build-module/modal/aria-helper.mjs
  var LIVE_REGION_ARIA_ROLES = /* @__PURE__ */ new Set(["alert", "status", "log", "marquee", "timer"]);
  var hiddenElementsByDepth = [];
  function modalize(modalElement) {
    const elements2 = Array.from(document.body.children);
    const hiddenElements = [];
    hiddenElementsByDepth.push(hiddenElements);
    for (const element of elements2) {
      if (element === modalElement) {
        continue;
      }
      if (elementShouldBeHidden(element)) {
        element.setAttribute("aria-hidden", "true");
        hiddenElements.push(element);
      }
    }
  }
  function elementShouldBeHidden(element) {
    const role = element.getAttribute("role");
    return !(element.tagName === "SCRIPT" || element.hasAttribute("hidden") || element.hasAttribute("aria-hidden") || element.hasAttribute("aria-live") || role && LIVE_REGION_ARIA_ROLES.has(role));
  }
  function unmodalize() {
    const hiddenElements = hiddenElementsByDepth.pop();
    if (!hiddenElements) {
      return;
    }
    for (const element of hiddenElements) {
      element.removeAttribute("aria-hidden");
    }
  }

  // packages/components/build-module/modal/use-modal-exit-animation.mjs
  var import_compose49 = __toESM(require_compose(), 1);
  var import_element119 = __toESM(require_element(), 1);
  var import_warning6 = __toESM(require_warning(), 1);
  var FRAME_ANIMATION_DURATION_MS = Number.parseInt(config_values_default.transitionDuration);
  var EXIT_ANIMATION_NAME = "components-modal__disappear-animation";
  function useModalExitAnimation() {
    const frameRef = (0, import_element119.useRef)(null);
    const [isAnimatingOut, setIsAnimatingOut] = (0, import_element119.useState)(false);
    const isReducedMotion = (0, import_compose49.useReducedMotion)();
    const closeModal = (0, import_element119.useCallback)(() => new Promise((closeModalResolve) => {
      const frameEl = frameRef.current;
      if (isReducedMotion) {
        closeModalResolve();
        return;
      }
      if (!frameEl) {
        true ? (0, import_warning6.default)("wp.components.Modal: the Modal component can't be closed with an exit animation because of a missing reference to the modal frame element.") : void 0;
        closeModalResolve();
        return;
      }
      let handleAnimationEnd;
      const startAnimation = () => new Promise((animationResolve) => {
        handleAnimationEnd = (e3) => {
          if (e3.animationName === EXIT_ANIMATION_NAME) {
            animationResolve();
          }
        };
        frameEl.addEventListener("animationend", handleAnimationEnd);
        setIsAnimatingOut(true);
      });
      const animationTimeout = () => new Promise((timeoutResolve) => {
        setTimeout(
          () => timeoutResolve(),
          // Allow an extra 20% of the animation duration for the
          // animationend event to fire, in case the animation frame is
          // slightly delayes by some other events in the event loop.
          FRAME_ANIMATION_DURATION_MS * 1.2
        );
      });
      Promise.race([startAnimation(), animationTimeout()]).then(() => {
        if (handleAnimationEnd) {
          frameEl.removeEventListener("animationend", handleAnimationEnd);
        }
        setIsAnimatingOut(false);
        closeModalResolve();
      });
    }), [isReducedMotion]);
    return {
      overlayClassname: isAnimatingOut ? "is-animating-out" : void 0,
      frameRef,
      closeModal
    };
  }

  // packages/components/build-module/modal/context.mjs
  var import_element120 = __toESM(require_element(), 1);
  var ModalContext = (0, import_element120.createContext)(/* @__PURE__ */ new Set());
  ModalContext.displayName = "ModalContext";

  // packages/components/build-module/modal/index.mjs
  var import_jsx_runtime188 = __toESM(require_jsx_runtime(), 1);
  var bodyOpenClasses = /* @__PURE__ */ new Map();
  function UnforwardedModal(props, forwardedRef) {
    const {
      bodyOpenClassName = "modal-open",
      role = "dialog",
      title = null,
      focusOnMount = true,
      shouldCloseOnEsc = true,
      shouldCloseOnClickOutside = true,
      isDismissible = true,
      /* Accessibility. */
      aria = {
        labelledby: void 0,
        describedby: void 0
      },
      onRequestClose,
      icon,
      closeButtonLabel,
      children,
      style: style2,
      overlayClassName: overlayClassnameProp,
      className: className2,
      contentLabel,
      onKeyDown,
      isFullScreen = false,
      size: size4,
      headerActions = null,
      __experimentalHideHeader = false
    } = props;
    const ref = (0, import_element121.useRef)(null);
    const instanceId = (0, import_compose50.useInstanceId)(Modal);
    const headingId = title ? `components-modal-header-${instanceId}` : aria.labelledby;
    const focusOnMountRef = (0, import_compose50.useFocusOnMount)(focusOnMount === "firstContentElement" ? "firstElement" : focusOnMount);
    const constrainedTabbingRef = (0, import_compose50.useConstrainedTabbing)();
    const focusReturnRef = (0, import_compose50.useFocusReturn)();
    const contentRef = (0, import_element121.useRef)(null);
    const childrenContainerRef = (0, import_element121.useRef)(null);
    const [hasScrolledContent, setHasScrolledContent] = (0, import_element121.useState)(false);
    const [hasScrollableContent, setHasScrollableContent] = (0, import_element121.useState)(false);
    let sizeClass;
    if (isFullScreen || size4 === "fill") {
      sizeClass = "is-full-screen";
    } else if (size4) {
      sizeClass = `has-size-${size4}`;
    }
    const isContentScrollable = (0, import_element121.useCallback)(() => {
      if (!contentRef.current) {
        return;
      }
      const closestScrollContainer = (0, import_dom6.getScrollContainer)(contentRef.current);
      if (contentRef.current === closestScrollContainer) {
        setHasScrollableContent(true);
      } else {
        setHasScrollableContent(false);
      }
    }, [contentRef]);
    (0, import_element121.useEffect)(() => {
      modalize(ref.current);
      return () => unmodalize();
    }, []);
    const onRequestCloseRef = (0, import_element121.useRef)(void 0);
    (0, import_element121.useEffect)(() => {
      onRequestCloseRef.current = onRequestClose;
    }, [onRequestClose]);
    const dismissers = (0, import_element121.useContext)(ModalContext);
    const [nestedDismissers] = (0, import_element121.useState)(() => /* @__PURE__ */ new Set());
    (0, import_element121.useEffect)(() => {
      dismissers.add(onRequestCloseRef);
      for (const dismisser of dismissers) {
        if (dismisser !== onRequestCloseRef) {
          dismisser.current?.();
        }
      }
      return () => {
        for (const dismisser of nestedDismissers) {
          dismisser.current?.();
        }
        dismissers.delete(onRequestCloseRef);
      };
    }, [dismissers, nestedDismissers]);
    (0, import_element121.useEffect)(() => {
      const theClass = bodyOpenClassName;
      const oneMore = 1 + (bodyOpenClasses.get(theClass) ?? 0);
      bodyOpenClasses.set(theClass, oneMore);
      document.body.classList.add(bodyOpenClassName);
      return () => {
        const oneLess = bodyOpenClasses.get(theClass) - 1;
        if (oneLess === 0) {
          document.body.classList.remove(theClass);
          bodyOpenClasses.delete(theClass);
        } else {
          bodyOpenClasses.set(theClass, oneLess);
        }
      };
    }, [bodyOpenClassName]);
    const {
      closeModal,
      frameRef,
      overlayClassname
    } = useModalExitAnimation();
    (0, import_element121.useLayoutEffect)(() => {
      if (!window.ResizeObserver || !childrenContainerRef.current) {
        return;
      }
      const resizeObserver = new ResizeObserver(isContentScrollable);
      resizeObserver.observe(childrenContainerRef.current);
      isContentScrollable();
      return () => {
        resizeObserver.disconnect();
      };
    }, [isContentScrollable, childrenContainerRef]);
    function handleEscapeKeyDown(event) {
      if (shouldCloseOnEsc && (event.code === "Escape" || event.key === "Escape") && !event.defaultPrevented) {
        event.preventDefault();
        closeModal().then(() => onRequestClose(event));
      }
    }
    const onContentContainerScroll = (0, import_element121.useCallback)((e3) => {
      const scrollY2 = e3?.currentTarget?.scrollTop ?? -1;
      if (!hasScrolledContent && scrollY2 > 0) {
        setHasScrolledContent(true);
      } else if (hasScrolledContent && scrollY2 <= 0) {
        setHasScrolledContent(false);
      }
    }, [hasScrolledContent]);
    let pressTarget = null;
    const overlayPressHandlers = {
      onPointerDown: (event) => {
        if (event.target === event.currentTarget) {
          pressTarget = event.target;
          event.preventDefault();
        }
      },
      // Closes the modal with two exceptions. 1. Opening the context menu on
      // the overlay. 2. Pressing on the overlay then dragging the pointer
      // over the modal and releasing. Due to the modal being a child of the
      // overlay, such a gesture is a `click` on the overlay and cannot be
      // excepted by a `click` handler. Thus the tactic of handling
      // `pointerup` and comparing its target to that of the `pointerdown`.
      onPointerUp: ({
        target,
        button
      }) => {
        const isSameTarget = target === pressTarget;
        pressTarget = null;
        if (button === 0 && isSameTarget) {
          closeModal().then(() => onRequestClose());
        }
      }
    };
    const modal = (
      // eslint-disable-next-line jsx-a11y/no-static-element-interactions
      /* @__PURE__ */ (0, import_jsx_runtime188.jsx)("div", {
        ref: (0, import_compose50.useMergeRefs)([ref, forwardedRef]),
        className: clsx_default("components-modal__screen-overlay", overlayClassname, overlayClassnameProp),
        onKeyDown: withIgnoreIMEEvents(handleEscapeKeyDown),
        ...shouldCloseOnClickOutside ? overlayPressHandlers : {},
        children: /* @__PURE__ */ (0, import_jsx_runtime188.jsx)(style_provider_default, {
          document,
          children: /* @__PURE__ */ (0, import_jsx_runtime188.jsx)("div", {
            className: clsx_default("components-modal__frame", sizeClass, className2),
            style: style2,
            ref: (0, import_compose50.useMergeRefs)([frameRef, constrainedTabbingRef, focusReturnRef, focusOnMount !== "firstContentElement" ? focusOnMountRef : null]),
            role,
            "aria-label": contentLabel,
            "aria-labelledby": contentLabel ? void 0 : headingId,
            "aria-describedby": aria.describedby,
            tabIndex: -1,
            onKeyDown,
            children: /* @__PURE__ */ (0, import_jsx_runtime188.jsxs)("div", {
              className: clsx_default("components-modal__content", {
                "hide-header": __experimentalHideHeader,
                "is-scrollable": hasScrollableContent,
                "has-scrolled-content": hasScrolledContent
              }),
              role: "document",
              onScroll: onContentContainerScroll,
              ref: contentRef,
              "aria-label": hasScrollableContent ? (0, import_i18n38.__)("Scrollable section") : void 0,
              tabIndex: hasScrollableContent ? 0 : void 0,
              children: [!__experimentalHideHeader && /* @__PURE__ */ (0, import_jsx_runtime188.jsxs)("div", {
                className: "components-modal__header",
                children: [/* @__PURE__ */ (0, import_jsx_runtime188.jsxs)("div", {
                  className: "components-modal__header-heading-container",
                  children: [icon && /* @__PURE__ */ (0, import_jsx_runtime188.jsx)("span", {
                    className: "components-modal__icon-container",
                    "aria-hidden": true,
                    children: icon
                  }), title && /* @__PURE__ */ (0, import_jsx_runtime188.jsx)("h1", {
                    id: headingId,
                    className: "components-modal__header-heading",
                    children: title
                  })]
                }), headerActions, isDismissible && /* @__PURE__ */ (0, import_jsx_runtime188.jsxs)(import_jsx_runtime188.Fragment, {
                  children: [/* @__PURE__ */ (0, import_jsx_runtime188.jsx)(component_default6, {
                    marginBottom: 0,
                    marginLeft: 2
                  }), /* @__PURE__ */ (0, import_jsx_runtime188.jsx)(button_default, {
                    size: "compact",
                    onClick: (event) => closeModal().then(() => onRequestClose(event)),
                    icon: close_default,
                    label: closeButtonLabel || (0, import_i18n38.__)("Close")
                  })]
                })]
              }), /* @__PURE__ */ (0, import_jsx_runtime188.jsx)("div", {
                ref: (0, import_compose50.useMergeRefs)([childrenContainerRef, focusOnMount === "firstContentElement" ? focusOnMountRef : null]),
                className: "components-modal__children-container",
                children
              })]
            })
          })
        })
      })
    );
    return (0, import_element121.createPortal)(/* @__PURE__ */ (0, import_jsx_runtime188.jsx)(ModalContext.Provider, {
      value: nestedDismissers,
      children: modal
    }), document.body);
  }
  var Modal = (0, import_element121.forwardRef)(UnforwardedModal);
  Modal.displayName = "Modal";
  var modal_default = Modal;

  // packages/components/build-module/confirm-dialog/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__23() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var wrapper2 = false ? {
    name: "7g5ii0",
    styles: "&&{z-index:1000001;}"
  } : {
    name: "1gucf3d-wrapper",
    styles: "&&{z-index:1000001;};label:wrapper;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFhMEIiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuXG4vKipcbiAqIFRoZSB6LWluZGV4IGZvciBDb25maXJtRGlhbG9nIGlzIGJlaW5nIHNldCBoZXJlIGluc3RlYWQgb2YgaW5cbiAqIHBhY2thZ2VzL2Jhc2Utc3R5bGVzL196LWluZGV4LnNjc3MsIGJlY2F1c2UgdGhpcyBjb21wb25lbnQgdXNlc1xuICogZW1vdGlvbiBpbnN0ZWFkIG9mIHNhc3MuXG4gKlxuICogQ29uZmlybURpYWxvZyBuZWVkcyB0aGlzIGhpZ2hlciB6LWluZGV4IHRvIGVuc3VyZSBpdCByZW5kZXJzIG9uIHRvcCBvZlxuICogYW55IHBhcmVudCBQb3BvdmVyIGNvbXBvbmVudC5cbiAqL1xuZXhwb3J0IGNvbnN0IHdyYXBwZXIgPSBjc3NgXG5cdCYmIHtcblx0XHR6LWluZGV4OiAxMDAwMDAxO1xuXHR9XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__23
  };

  // packages/components/build-module/confirm-dialog/component.mjs
  var import_jsx_runtime189 = __toESM(require_jsx_runtime(), 1);
  var UnconnectedConfirmDialog = (props, forwardedRef) => {
    const {
      isOpen: isOpenProp,
      onConfirm,
      onCancel,
      children,
      confirmButtonText,
      cancelButtonText,
      isBusy,
      ...otherProps
    } = useContextSystem(props, "ConfirmDialog");
    const cx2 = useCx();
    const wrapperClassName = cx2(wrapper2);
    const cancelButtonRef = (0, import_element122.useRef)(null);
    const confirmButtonRef = (0, import_element122.useRef)(null);
    const [isOpen, setIsOpen] = (0, import_element122.useState)();
    const [shouldSelfClose, setShouldSelfClose] = (0, import_element122.useState)();
    (0, import_element122.useEffect)(() => {
      const isIsOpenSet = typeof isOpenProp !== "undefined";
      setIsOpen(isIsOpenSet ? isOpenProp : true);
      setShouldSelfClose(!isIsOpenSet);
    }, [isOpenProp]);
    const handleEvent = (0, import_element122.useCallback)((callback) => (event) => {
      callback?.(event);
      if (shouldSelfClose) {
        setIsOpen(false);
      }
    }, [shouldSelfClose, setIsOpen]);
    const handleEnter = (0, import_element122.useCallback)((event) => {
      const isConfirmOrCancelButton = event.target === cancelButtonRef.current || event.target === confirmButtonRef.current;
      if (!isConfirmOrCancelButton && event.key === "Enter") {
        handleEvent(onConfirm)(event);
      }
    }, [handleEvent, onConfirm]);
    const cancelLabel = cancelButtonText ?? (0, import_i18n39.__)("Cancel");
    const confirmLabel = confirmButtonText ?? (0, import_i18n39.__)("OK");
    return /* @__PURE__ */ (0, import_jsx_runtime189.jsx)(import_jsx_runtime189.Fragment, {
      children: isOpen && /* @__PURE__ */ (0, import_jsx_runtime189.jsx)(modal_default, {
        onRequestClose: handleEvent(onCancel),
        onKeyDown: handleEnter,
        closeButtonLabel: cancelLabel,
        isDismissible: true,
        ref: forwardedRef,
        overlayClassName: wrapperClassName,
        __experimentalHideHeader: true,
        ...otherProps,
        children: /* @__PURE__ */ (0, import_jsx_runtime189.jsxs)(component_default18, {
          spacing: 8,
          children: [/* @__PURE__ */ (0, import_jsx_runtime189.jsx)(component_default8, {
            children
          }), /* @__PURE__ */ (0, import_jsx_runtime189.jsxs)(component_default3, {
            direction: "row",
            justify: "flex-end",
            children: [/* @__PURE__ */ (0, import_jsx_runtime189.jsx)(button_default, {
              __next40pxDefaultSize: true,
              ref: cancelButtonRef,
              variant: "tertiary",
              onClick: handleEvent(onCancel),
              accessibleWhenDisabled: true,
              disabled: isBusy,
              children: cancelLabel
            }), /* @__PURE__ */ (0, import_jsx_runtime189.jsx)(button_default, {
              __next40pxDefaultSize: true,
              ref: confirmButtonRef,
              variant: "primary",
              onClick: handleEvent(onConfirm),
              accessibleWhenDisabled: true,
              disabled: isBusy,
              isBusy,
              children: confirmLabel
            })]
          })]
        })
      })
    });
  };
  var ConfirmDialog = contextConnect(UnconnectedConfirmDialog, "ConfirmDialog");
  var component_default37 = ConfirmDialog;

  // packages/components/build-module/custom-select-control/index.mjs
  var import_compose51 = __toESM(require_compose(), 1);
  var import_i18n41 = __toESM(require_i18n(), 1);

  // packages/components/build-module/custom-select-control-v2/custom-select.mjs
  var import_element123 = __toESM(require_element(), 1);
  var import_i18n40 = __toESM(require_i18n(), 1);

  // packages/components/build-module/custom-select-control-v2/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__24() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var INLINE_PADDING = {
    compact: config_values_default.controlPaddingXSmall,
    small: config_values_default.controlPaddingXSmall,
    default: config_values_default.controlPaddingX
  };
  var getSelectSize = (size4, heightProperty) => {
    const sizes = {
      compact: {
        [heightProperty]: 32,
        paddingInlineStart: INLINE_PADDING.compact,
        paddingInlineEnd: INLINE_PADDING.compact + chevronIconSize
      },
      default: {
        [heightProperty]: 40,
        paddingInlineStart: INLINE_PADDING.default,
        paddingInlineEnd: INLINE_PADDING.default + chevronIconSize
      },
      small: {
        [heightProperty]: 24,
        paddingInlineStart: INLINE_PADDING.small,
        paddingInlineEnd: INLINE_PADDING.small + chevronIconSize
      }
    };
    return sizes[size4] || sizes.default;
  };
  var getSelectItemSize = (size4) => {
    const checkmarkCorrection = 6;
    const sizes = {
      compact: {
        paddingInlineStart: INLINE_PADDING.compact,
        paddingInlineEnd: INLINE_PADDING.compact - checkmarkCorrection
      },
      default: {
        paddingInlineStart: INLINE_PADDING.default,
        paddingInlineEnd: INLINE_PADDING.default - checkmarkCorrection
      },
      small: {
        paddingInlineStart: INLINE_PADDING.small,
        paddingInlineEnd: INLINE_PADDING.small - checkmarkCorrection
      }
    };
    return sizes[size4] || sizes.default;
  };
  var Select22 = /* @__PURE__ */ createStyled(Select, false ? {
    // Do not forward `hasCustomRenderProp` to the underlying Ariakit.Select component
    shouldForwardProp: (prop) => prop !== "hasCustomRenderProp",
    target: "e1p3eej77"
  } : {
    // Do not forward `hasCustomRenderProp` to the underlying Ariakit.Select component
    shouldForwardProp: (prop) => prop !== "hasCustomRenderProp",
    target: "e1p3eej77",
    label: "Select"
  })(({
    size: size4,
    hasCustomRenderProp
  }) => /* @__PURE__ */ css("display:block;background-color:", COLORS.theme.background, ";border:none;color:", COLORS.theme.foreground, ";cursor:pointer;font-family:inherit;text-align:start;user-select:none;width:100%;&[data-focus-visible]{outline:none;}", getSelectSize(size4, hasCustomRenderProp ? "minHeight" : "height"), " ", !hasCustomRenderProp && truncateStyles, " ", fontSizeStyles({
    inputSize: size4
  }), ";" + (false ? "" : ";label:Select;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var slideDown = keyframes2({
    "0%": {
      transform: `translateY(-${DROPDOWN_MOTION_CSS.SLIDE_DISTANCE})`
    },
    "100%": {
      transform: "translateY(0)"
    }
  });
  var fadeIn = keyframes2({
    "0%": {
      opacity: 0
    },
    "100%": {
      opacity: 1
    }
  });
  var SelectPopover22 = /* @__PURE__ */ createStyled(SelectPopover, false ? {
    target: "e1p3eej76"
  } : {
    target: "e1p3eej76",
    label: "SelectPopover"
  })("display:flex;flex-direction:column;background-color:", COLORS.theme.background, ";border-radius:", config_values_default.radiusSmall, ";border:1px solid ", COLORS.theme.foreground, ";box-shadow:", config_values_default.elevationMedium, ";z-index:1000000;max-height:min( var( --popover-available-height, 400px ), 400px );overflow:auto;overscroll-behavior:contain;min-width:min-content;&[data-open]{@media not ( prefers-reduced-motion ){animation-name:", slideDown, ",", fadeIn, ";animation-duration:", DROPDOWN_MOTION_CSS.SLIDE_DURATION, ",", DROPDOWN_MOTION_CSS.FADE_DURATION, ";animation-timing-function:", DROPDOWN_MOTION_CSS.SLIDE_EASING, ",", DROPDOWN_MOTION_CSS.FADE_EASING, ";will-change:transform,opacity;}}&[data-focus-visible]{outline:none;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var SelectItem22 = /* @__PURE__ */ createStyled(SelectItem, false ? {
    target: "e1p3eej75"
  } : {
    target: "e1p3eej75",
    label: "SelectItem"
  })(({
    size: size4
  }) => /* @__PURE__ */ css("cursor:default;display:flex;align-items:center;justify-content:space-between;font-size:", config_values_default.fontSize, ";line-height:28px;padding-block:", space(2), ";scroll-margin:", space(1), ";user-select:none;&[aria-disabled='true']{cursor:not-allowed;}&[data-active-item]{background-color:", COLORS.theme.gray[300], ";}", getSelectItemSize(size4), ";" + (false ? "" : ";label:SelectItem;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var truncateStyles = false ? {
    name: "1h52dri",
    styles: "overflow:hidden;text-overflow:ellipsis;white-space:nowrap"
  } : {
    name: "5u3cjr-truncateStyles",
    styles: "overflow:hidden;text-overflow:ellipsis;white-space:nowrap;label:truncateStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__24
  };
  var SelectedExperimentalHintWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1p3eej74"
  } : {
    target: "e1p3eej74",
    label: "SelectedExperimentalHintWrapper"
  })(truncateStyles, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var SelectedExperimentalHintItem = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1p3eej73"
  } : {
    target: "e1p3eej73",
    label: "SelectedExperimentalHintItem"
  })("color:", COLORS.theme.gray[600], ";margin-inline-start:", space(2), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var WithHintItemWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1p3eej72"
  } : {
    target: "e1p3eej72",
    label: "WithHintItemWrapper"
  })("display:flex;justify-content:space-between;align-items:center;flex-wrap:wrap;flex:1;column-gap:", space(4), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var WithHintItemHint = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1p3eej71"
  } : {
    target: "e1p3eej71",
    label: "WithHintItemHint"
  })("color:", COLORS.theme.gray[600], ";text-align:initial;line-height:", config_values_default.fontLineHeightBase, ";padding-inline-end:", space(1), ";margin-block:", space(1), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var SelectedItemCheck = /* @__PURE__ */ createStyled(SelectItemCheck, false ? {
    target: "e1p3eej70"
  } : {
    target: "e1p3eej70",
    label: "SelectedItemCheck"
  })("display:flex;align-items:center;margin-inline-start:", space(2), ";fill:currentColor;align-self:start;margin-block-start:2px;font-size:0;", WithHintItemWrapper, "~&,&:not(:empty){font-size:24px;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // packages/components/build-module/custom-select-control-v2/custom-select.mjs
  var import_jsx_runtime190 = __toESM(require_jsx_runtime(), 1);
  var CustomSelectContext = (0, import_element123.createContext)(void 0);
  CustomSelectContext.displayName = "CustomSelectContext";
  function defaultRenderSelectedValue(value) {
    const isValueEmpty2 = Array.isArray(value) ? value.length === 0 : value === void 0 || value === null;
    if (isValueEmpty2) {
      return (0, import_i18n40.__)("Select an item");
    }
    if (Array.isArray(value)) {
      return value.length === 1 ? value[0] : (0, import_i18n40.sprintf)(
        // translators: %d: number of items selected (it will always be 2 or more items)
        (0, import_i18n40._n)("%d item selected", "%d items selected", value.length),
        value.length
      );
    }
    return value;
  }
  var CustomSelectButton = ({
    renderSelectedValue,
    size: size4 = "default",
    store,
    ...restProps
  }) => {
    const {
      value: currentValue
    } = useStoreState(store);
    const computedRenderSelectedValue = (0, import_element123.useMemo)(() => renderSelectedValue ?? defaultRenderSelectedValue, [renderSelectedValue]);
    return /* @__PURE__ */ (0, import_jsx_runtime190.jsx)(Select22, {
      ...restProps,
      size: size4,
      hasCustomRenderProp: !!renderSelectedValue,
      store,
      children: computedRenderSelectedValue(currentValue)
    });
  };
  function CustomSelect(props) {
    const {
      children,
      hideLabelFromVision = false,
      label,
      size: size4,
      store,
      className: className2,
      isLegacy = false,
      ...restProps
    } = props;
    const onSelectPopoverKeyDown = (0, import_element123.useCallback)((e3) => {
      if (isLegacy) {
        e3.stopPropagation();
      }
    }, [isLegacy]);
    const contextValue = (0, import_element123.useMemo)(() => ({
      store,
      size: size4
    }), [store, size4]);
    return (
      // Where should `restProps` be forwarded to?
      /* @__PURE__ */ (0, import_jsx_runtime190.jsxs)("div", {
        className: className2,
        children: [/* @__PURE__ */ (0, import_jsx_runtime190.jsx)(SelectLabel, {
          store,
          render: hideLabelFromVision ? (
            // @ts-expect-error `children` are passed via the render prop
            /* @__PURE__ */ (0, import_jsx_runtime190.jsx)(component_default2, {})
          ) : (
            // @ts-expect-error `children` are passed via the render prop
            /* @__PURE__ */ (0, import_jsx_runtime190.jsx)(base_control_default.VisualLabel, {
              as: "div"
            })
          ),
          children: label
        }), /* @__PURE__ */ (0, import_jsx_runtime190.jsxs)(input_base_default, {
          size: size4,
          suffix: /* @__PURE__ */ (0, import_jsx_runtime190.jsx)(chevron_down_default2, {}),
          children: [/* @__PURE__ */ (0, import_jsx_runtime190.jsx)(CustomSelectButton, {
            ...restProps,
            size: size4,
            store,
            showOnKeyDown: !isLegacy
          }), /* @__PURE__ */ (0, import_jsx_runtime190.jsx)(SelectPopover22, {
            gutter: 12,
            store,
            sameWidth: true,
            slide: false,
            onKeyDown: onSelectPopoverKeyDown,
            flip: !isLegacy,
            children: /* @__PURE__ */ (0, import_jsx_runtime190.jsx)(CustomSelectContext.Provider, {
              value: contextValue,
              children
            })
          })]
        })]
      })
    );
  }
  var custom_select_default = CustomSelect;

  // packages/components/build-module/custom-select-control-v2/item.mjs
  var import_element124 = __toESM(require_element(), 1);
  var import_jsx_runtime191 = __toESM(require_jsx_runtime(), 1);
  function CustomSelectItem({
    children,
    ...props
  }) {
    const customSelectContext = (0, import_element124.useContext)(CustomSelectContext);
    return /* @__PURE__ */ (0, import_jsx_runtime191.jsxs)(SelectItem22, {
      store: customSelectContext?.store,
      size: customSelectContext?.size ?? "default",
      ...props,
      children: [children ?? props.value, /* @__PURE__ */ (0, import_jsx_runtime191.jsx)(SelectedItemCheck, {
        children: /* @__PURE__ */ (0, import_jsx_runtime191.jsx)(icon_default2, {
          icon: check_default
        })
      })]
    });
  }
  CustomSelectItem.displayName = "CustomSelectControlV2.Item";
  var item_default = CustomSelectItem;

  // packages/components/build-module/custom-select-control/index.mjs
  var import_jsx_runtime192 = __toESM(require_jsx_runtime(), 1);
  function useDeprecatedProps5({
    __experimentalShowSelectedHint,
    ...otherProps
  }) {
    return {
      showSelectedHint: __experimentalShowSelectedHint,
      ...otherProps
    };
  }
  function applyOptionDeprecations({
    __experimentalHint,
    ...rest
  }) {
    return {
      hint: __experimentalHint,
      ...rest
    };
  }
  function getDescribedBy(currentName, describedBy) {
    if (describedBy) {
      return describedBy;
    }
    return (0, import_i18n41.sprintf)((0, import_i18n41.__)("Currently selected: %s"), currentName);
  }
  function CustomSelectControl(props) {
    const {
      // Prevent passing legacy props to internal component.
      __next40pxDefaultSize: _next40pxDefaultSize,
      __shouldNotWarnDeprecated36pxSize: _shouldNotWarnDeprecated36pxSize,
      describedBy,
      options: options2,
      onChange,
      size: size4 = "default",
      value,
      className: classNameProp,
      showSelectedHint = false,
      ...restProps
    } = useDeprecatedProps5(props);
    const descriptionId = (0, import_compose51.useInstanceId)(CustomSelectControl, "custom-select-control__description");
    const store = useSelectStore({
      async setValue(nextValue) {
        const nextOption = options2.find((item2) => item2.key === nextValue);
        if (!onChange || !nextOption) {
          return;
        }
        await Promise.resolve();
        const state = store.getState();
        const changeObject = {
          highlightedIndex: state.renderedItems.findIndex((item2) => item2.value === nextValue),
          inputValue: "",
          isOpen: state.open,
          selectedItem: nextOption,
          type: ""
        };
        onChange(changeObject);
      },
      value: value?.key,
      // Setting the first option as a default value when no value is provided
      // is already done natively by the underlying Ariakit component,
      // but doing this explicitly avoids the `onChange` callback from firing
      // on initial render, thus making this implementation closer to the v1.
      defaultValue: options2[0]?.key
    });
    const children = options2.map(applyOptionDeprecations).map(({
      name,
      key,
      hint,
      style: style2,
      className: className2
    }) => {
      const withHint = /* @__PURE__ */ (0, import_jsx_runtime192.jsxs)(WithHintItemWrapper, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime192.jsx)("span", {
          children: name
        }), /* @__PURE__ */ (0, import_jsx_runtime192.jsx)(WithHintItemHint, {
          // Keeping the classname for legacy reasons
          className: "components-custom-select-control__item-hint",
          children: hint
        })]
      });
      return /* @__PURE__ */ (0, import_jsx_runtime192.jsx)(item_default, {
        value: key,
        children: hint ? withHint : name,
        style: style2,
        className: clsx_default(
          className2,
          // Keeping the classnames for legacy reasons
          "components-custom-select-control__item",
          {
            "has-hint": hint
          }
        )
      }, key);
    });
    const currentValue = useStoreState(store, "value");
    const selectedOption = options2?.map(applyOptionDeprecations)?.find(({
      key
    }) => currentValue === key) ?? options2[0];
    const renderSelectedValue = () => {
      if (!showSelectedHint || !selectedOption.hint) {
        return selectedOption?.name;
      }
      return /* @__PURE__ */ (0, import_jsx_runtime192.jsxs)(SelectedExperimentalHintWrapper, {
        children: [selectedOption?.name, /* @__PURE__ */ (0, import_jsx_runtime192.jsx)(SelectedExperimentalHintItem, {
          // Keeping the classname for legacy reasons
          className: "components-custom-select-control__hint",
          children: selectedOption?.hint
        })]
      });
    };
    return /* @__PURE__ */ (0, import_jsx_runtime192.jsxs)(import_jsx_runtime192.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime192.jsx)(custom_select_default, {
        "aria-describedby": descriptionId,
        renderSelectedValue,
        size: size4 === "__unstable-large" ? "default" : size4,
        store,
        className: clsx_default(
          // Keeping the classname for legacy reasons
          "components-custom-select-control",
          classNameProp
        ),
        isLegacy: true,
        ...restProps,
        children
      }), /* @__PURE__ */ (0, import_jsx_runtime192.jsx)(component_default2, {
        children: /* @__PURE__ */ (0, import_jsx_runtime192.jsx)("span", {
          id: descriptionId,
          children: getDescribedBy(selectedOption?.name, describedBy)
        })
      })]
    });
  }
  var custom_select_control_default = CustomSelectControl;

  // node_modules/date-fns/constants.js
  var daysInYear = 365.2425;
  var maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1e3;
  var minTime = -maxTime;
  var millisecondsInWeek = 6048e5;
  var millisecondsInDay = 864e5;
  var secondsInHour = 3600;
  var secondsInDay = secondsInHour * 24;
  var secondsInWeek = secondsInDay * 7;
  var secondsInYear = secondsInDay * daysInYear;
  var secondsInMonth = secondsInYear / 12;
  var secondsInQuarter = secondsInMonth * 3;
  var constructFromSymbol = /* @__PURE__ */ Symbol.for("constructDateFrom");

  // node_modules/date-fns/constructFrom.js
  function constructFrom(date, value) {
    if (typeof date === "function") return date(value);
    if (date && typeof date === "object" && constructFromSymbol in date)
      return date[constructFromSymbol](value);
    if (date instanceof Date) return new date.constructor(value);
    return new Date(value);
  }

  // node_modules/date-fns/toDate.js
  function toDate(argument, context) {
    return constructFrom(context || argument, argument);
  }

  // node_modules/date-fns/addDays.js
  function addDays(date, amount, options2) {
    const _date = toDate(date, options2?.in);
    if (isNaN(amount)) return constructFrom(options2?.in || date, NaN);
    if (!amount) return _date;
    _date.setDate(_date.getDate() + amount);
    return _date;
  }

  // node_modules/date-fns/addMonths.js
  function addMonths(date, amount, options2) {
    const _date = toDate(date, options2?.in);
    if (isNaN(amount)) return constructFrom(options2?.in || date, NaN);
    if (!amount) {
      return _date;
    }
    const dayOfMonth = _date.getDate();
    const endOfDesiredMonth = constructFrom(options2?.in || date, _date.getTime());
    endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
    const daysInMonth = endOfDesiredMonth.getDate();
    if (dayOfMonth >= daysInMonth) {
      return endOfDesiredMonth;
    } else {
      _date.setFullYear(
        endOfDesiredMonth.getFullYear(),
        endOfDesiredMonth.getMonth(),
        dayOfMonth
      );
      return _date;
    }
  }

  // node_modules/date-fns/_lib/defaultOptions.js
  var defaultOptions2 = {};
  function getDefaultOptions() {
    return defaultOptions2;
  }

  // node_modules/date-fns/startOfWeek.js
  function startOfWeek(date, options2) {
    const defaultOptions3 = getDefaultOptions();
    const weekStartsOn = options2?.weekStartsOn ?? options2?.locale?.options?.weekStartsOn ?? defaultOptions3.weekStartsOn ?? defaultOptions3.locale?.options?.weekStartsOn ?? 0;
    const _date = toDate(date, options2?.in);
    const day = _date.getDay();
    const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
    _date.setDate(_date.getDate() - diff);
    _date.setHours(0, 0, 0, 0);
    return _date;
  }

  // node_modules/date-fns/startOfISOWeek.js
  function startOfISOWeek(date, options2) {
    return startOfWeek(date, { ...options2, weekStartsOn: 1 });
  }

  // node_modules/date-fns/getISOWeekYear.js
  function getISOWeekYear(date, options2) {
    const _date = toDate(date, options2?.in);
    const year = _date.getFullYear();
    const fourthOfJanuaryOfNextYear = constructFrom(_date, 0);
    fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
    fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
    const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
    const fourthOfJanuaryOfThisYear = constructFrom(_date, 0);
    fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
    fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
    const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
    if (_date.getTime() >= startOfNextYear.getTime()) {
      return year + 1;
    } else if (_date.getTime() >= startOfThisYear.getTime()) {
      return year;
    } else {
      return year - 1;
    }
  }

  // node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js
  function getTimezoneOffsetInMilliseconds(date) {
    const _date = toDate(date);
    const utcDate = new Date(
      Date.UTC(
        _date.getFullYear(),
        _date.getMonth(),
        _date.getDate(),
        _date.getHours(),
        _date.getMinutes(),
        _date.getSeconds(),
        _date.getMilliseconds()
      )
    );
    utcDate.setUTCFullYear(_date.getFullYear());
    return +date - +utcDate;
  }

  // node_modules/date-fns/_lib/normalizeDates.js
  function normalizeDates(context, ...dates) {
    const normalize2 = constructFrom.bind(
      null,
      context || dates.find((date) => typeof date === "object")
    );
    return dates.map(normalize2);
  }

  // node_modules/date-fns/startOfDay.js
  function startOfDay(date, options2) {
    const _date = toDate(date, options2?.in);
    _date.setHours(0, 0, 0, 0);
    return _date;
  }

  // node_modules/date-fns/differenceInCalendarDays.js
  function differenceInCalendarDays(laterDate, earlierDate, options2) {
    const [laterDate_, earlierDate_] = normalizeDates(
      options2?.in,
      laterDate,
      earlierDate
    );
    const laterStartOfDay = startOfDay(laterDate_);
    const earlierStartOfDay = startOfDay(earlierDate_);
    const laterTimestamp = +laterStartOfDay - getTimezoneOffsetInMilliseconds(laterStartOfDay);
    const earlierTimestamp = +earlierStartOfDay - getTimezoneOffsetInMilliseconds(earlierStartOfDay);
    return Math.round((laterTimestamp - earlierTimestamp) / millisecondsInDay);
  }

  // node_modules/date-fns/startOfISOWeekYear.js
  function startOfISOWeekYear(date, options2) {
    const year = getISOWeekYear(date, options2);
    const fourthOfJanuary = constructFrom(options2?.in || date, 0);
    fourthOfJanuary.setFullYear(year, 0, 4);
    fourthOfJanuary.setHours(0, 0, 0, 0);
    return startOfISOWeek(fourthOfJanuary);
  }

  // node_modules/date-fns/addWeeks.js
  function addWeeks(date, amount, options2) {
    return addDays(date, amount * 7, options2);
  }

  // node_modules/date-fns/addYears.js
  function addYears(date, amount, options2) {
    return addMonths(date, amount * 12, options2);
  }

  // node_modules/date-fns/max.js
  function max2(dates, options2) {
    let result;
    let context = options2?.in;
    dates.forEach((date) => {
      if (!context && typeof date === "object")
        context = constructFrom.bind(null, date);
      const date_ = toDate(date, context);
      if (!result || result < date_ || isNaN(+date_)) result = date_;
    });
    return constructFrom(context, result || NaN);
  }

  // node_modules/date-fns/min.js
  function min2(dates, options2) {
    let result;
    let context = options2?.in;
    dates.forEach((date) => {
      if (!context && typeof date === "object")
        context = constructFrom.bind(null, date);
      const date_ = toDate(date, context);
      if (!result || result > date_ || isNaN(+date_)) result = date_;
    });
    return constructFrom(context, result || NaN);
  }

  // node_modules/date-fns/isSameDay.js
  function isSameDay(laterDate, earlierDate, options2) {
    const [dateLeft_, dateRight_] = normalizeDates(
      options2?.in,
      laterDate,
      earlierDate
    );
    return +startOfDay(dateLeft_) === +startOfDay(dateRight_);
  }

  // node_modules/date-fns/isDate.js
  function isDate(value) {
    return value instanceof Date || typeof value === "object" && Object.prototype.toString.call(value) === "[object Date]";
  }

  // node_modules/date-fns/isValid.js
  function isValid(date) {
    return !(!isDate(date) && typeof date !== "number" || isNaN(+toDate(date)));
  }

  // node_modules/date-fns/differenceInCalendarMonths.js
  function differenceInCalendarMonths(laterDate, earlierDate, options2) {
    const [laterDate_, earlierDate_] = normalizeDates(
      options2?.in,
      laterDate,
      earlierDate
    );
    const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
    const monthsDiff = laterDate_.getMonth() - earlierDate_.getMonth();
    return yearsDiff * 12 + monthsDiff;
  }

  // node_modules/date-fns/endOfMonth.js
  function endOfMonth(date, options2) {
    const _date = toDate(date, options2?.in);
    const month = _date.getMonth();
    _date.setFullYear(_date.getFullYear(), month + 1, 0);
    _date.setHours(23, 59, 59, 999);
    return _date;
  }

  // node_modules/date-fns/_lib/normalizeInterval.js
  function normalizeInterval(context, interval) {
    const [start, end] = normalizeDates(context, interval.start, interval.end);
    return { start, end };
  }

  // node_modules/date-fns/eachDayOfInterval.js
  function eachDayOfInterval(interval, options2) {
    const { start, end } = normalizeInterval(options2?.in, interval);
    let reversed = +start > +end;
    const endTime = reversed ? +start : +end;
    const date = reversed ? end : start;
    date.setHours(0, 0, 0, 0);
    let step = options2?.step ?? 1;
    if (!step) return [];
    if (step < 0) {
      step = -step;
      reversed = !reversed;
    }
    const dates = [];
    while (+date <= endTime) {
      dates.push(constructFrom(start, date));
      date.setDate(date.getDate() + step);
      date.setHours(0, 0, 0, 0);
    }
    return reversed ? dates.reverse() : dates;
  }

  // node_modules/date-fns/eachMonthOfInterval.js
  function eachMonthOfInterval(interval, options2) {
    const { start, end } = normalizeInterval(options2?.in, interval);
    let reversed = +start > +end;
    const endTime = reversed ? +start : +end;
    const date = reversed ? end : start;
    date.setHours(0, 0, 0, 0);
    date.setDate(1);
    let step = options2?.step ?? 1;
    if (!step) return [];
    if (step < 0) {
      step = -step;
      reversed = !reversed;
    }
    const dates = [];
    while (+date <= endTime) {
      dates.push(constructFrom(start, date));
      date.setMonth(date.getMonth() + step);
    }
    return reversed ? dates.reverse() : dates;
  }

  // node_modules/date-fns/eachWeekOfInterval.js
  function eachWeekOfInterval(interval, options2) {
    const { start, end } = normalizeInterval(options2?.in, interval);
    let reversed = +start > +end;
    const startDateWeek = reversed ? startOfWeek(end, options2) : startOfWeek(start, options2);
    const endDateWeek = reversed ? startOfWeek(start, options2) : startOfWeek(end, options2);
    startDateWeek.setHours(15);
    endDateWeek.setHours(15);
    const endTime = +endDateWeek.getTime();
    let currentDate = startDateWeek;
    let step = options2?.step ?? 1;
    if (!step) return [];
    if (step < 0) {
      step = -step;
      reversed = !reversed;
    }
    const dates = [];
    while (+currentDate <= endTime) {
      currentDate.setHours(0);
      dates.push(constructFrom(start, currentDate));
      currentDate = addWeeks(currentDate, step);
      currentDate.setHours(15);
    }
    return reversed ? dates.reverse() : dates;
  }

  // node_modules/date-fns/startOfMonth.js
  function startOfMonth(date, options2) {
    const _date = toDate(date, options2?.in);
    _date.setDate(1);
    _date.setHours(0, 0, 0, 0);
    return _date;
  }

  // node_modules/date-fns/endOfYear.js
  function endOfYear(date, options2) {
    const _date = toDate(date, options2?.in);
    const year = _date.getFullYear();
    _date.setFullYear(year + 1, 0, 0);
    _date.setHours(23, 59, 59, 999);
    return _date;
  }

  // node_modules/date-fns/startOfYear.js
  function startOfYear(date, options2) {
    const date_ = toDate(date, options2?.in);
    date_.setFullYear(date_.getFullYear(), 0, 1);
    date_.setHours(0, 0, 0, 0);
    return date_;
  }

  // node_modules/date-fns/endOfWeek.js
  function endOfWeek(date, options2) {
    const defaultOptions3 = getDefaultOptions();
    const weekStartsOn = options2?.weekStartsOn ?? options2?.locale?.options?.weekStartsOn ?? defaultOptions3.weekStartsOn ?? defaultOptions3.locale?.options?.weekStartsOn ?? 0;
    const _date = toDate(date, options2?.in);
    const day = _date.getDay();
    const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
    _date.setDate(_date.getDate() + diff);
    _date.setHours(23, 59, 59, 999);
    return _date;
  }

  // node_modules/date-fns/endOfISOWeek.js
  function endOfISOWeek(date, options2) {
    return endOfWeek(date, { ...options2, weekStartsOn: 1 });
  }

  // node_modules/date-fns/locale/en-US/_lib/formatDistance.js
  var formatDistanceLocale = {
    lessThanXSeconds: {
      one: "less than a second",
      other: "less than {{count}} seconds"
    },
    xSeconds: {
      one: "1 second",
      other: "{{count}} seconds"
    },
    halfAMinute: "half a minute",
    lessThanXMinutes: {
      one: "less than a minute",
      other: "less than {{count}} minutes"
    },
    xMinutes: {
      one: "1 minute",
      other: "{{count}} minutes"
    },
    aboutXHours: {
      one: "about 1 hour",
      other: "about {{count}} hours"
    },
    xHours: {
      one: "1 hour",
      other: "{{count}} hours"
    },
    xDays: {
      one: "1 day",
      other: "{{count}} days"
    },
    aboutXWeeks: {
      one: "about 1 week",
      other: "about {{count}} weeks"
    },
    xWeeks: {
      one: "1 week",
      other: "{{count}} weeks"
    },
    aboutXMonths: {
      one: "about 1 month",
      other: "about {{count}} months"
    },
    xMonths: {
      one: "1 month",
      other: "{{count}} months"
    },
    aboutXYears: {
      one: "about 1 year",
      other: "about {{count}} years"
    },
    xYears: {
      one: "1 year",
      other: "{{count}} years"
    },
    overXYears: {
      one: "over 1 year",
      other: "over {{count}} years"
    },
    almostXYears: {
      one: "almost 1 year",
      other: "almost {{count}} years"
    }
  };
  var formatDistance = (token2, count, options2) => {
    let result;
    const tokenValue = formatDistanceLocale[token2];
    if (typeof tokenValue === "string") {
      result = tokenValue;
    } else if (count === 1) {
      result = tokenValue.one;
    } else {
      result = tokenValue.other.replace("{{count}}", count.toString());
    }
    if (options2?.addSuffix) {
      if (options2.comparison && options2.comparison > 0) {
        return "in " + result;
      } else {
        return result + " ago";
      }
    }
    return result;
  };

  // node_modules/date-fns/locale/_lib/buildFormatLongFn.js
  function buildFormatLongFn(args) {
    return (options2 = {}) => {
      const width = options2.width ? String(options2.width) : args.defaultWidth;
      const format2 = args.formats[width] || args.formats[args.defaultWidth];
      return format2;
    };
  }

  // node_modules/date-fns/locale/en-US/_lib/formatLong.js
  var dateFormats = {
    full: "EEEE, MMMM do, y",
    long: "MMMM do, y",
    medium: "MMM d, y",
    short: "MM/dd/yyyy"
  };
  var timeFormats = {
    full: "h:mm:ss a zzzz",
    long: "h:mm:ss a z",
    medium: "h:mm:ss a",
    short: "h:mm a"
  };
  var dateTimeFormats = {
    full: "{{date}} 'at' {{time}}",
    long: "{{date}} 'at' {{time}}",
    medium: "{{date}}, {{time}}",
    short: "{{date}}, {{time}}"
  };
  var formatLong = {
    date: buildFormatLongFn({
      formats: dateFormats,
      defaultWidth: "full"
    }),
    time: buildFormatLongFn({
      formats: timeFormats,
      defaultWidth: "full"
    }),
    dateTime: buildFormatLongFn({
      formats: dateTimeFormats,
      defaultWidth: "full"
    })
  };

  // node_modules/date-fns/locale/en-US/_lib/formatRelative.js
  var formatRelativeLocale = {
    lastWeek: "'last' eeee 'at' p",
    yesterday: "'yesterday at' p",
    today: "'today at' p",
    tomorrow: "'tomorrow at' p",
    nextWeek: "eeee 'at' p",
    other: "P"
  };
  var formatRelative = (token2, _date, _baseDate, _options) => formatRelativeLocale[token2];

  // node_modules/date-fns/locale/_lib/buildLocalizeFn.js
  function buildLocalizeFn(args) {
    return (value, options2) => {
      const context = options2?.context ? String(options2.context) : "standalone";
      let valuesArray;
      if (context === "formatting" && args.formattingValues) {
        const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
        const width = options2?.width ? String(options2.width) : defaultWidth;
        valuesArray = args.formattingValues[width] || args.formattingValues[defaultWidth];
      } else {
        const defaultWidth = args.defaultWidth;
        const width = options2?.width ? String(options2.width) : args.defaultWidth;
        valuesArray = args.values[width] || args.values[defaultWidth];
      }
      const index2 = args.argumentCallback ? args.argumentCallback(value) : value;
      return valuesArray[index2];
    };
  }

  // node_modules/date-fns/locale/en-US/_lib/localize.js
  var eraValues = {
    narrow: ["B", "A"],
    abbreviated: ["BC", "AD"],
    wide: ["Before Christ", "Anno Domini"]
  };
  var quarterValues = {
    narrow: ["1", "2", "3", "4"],
    abbreviated: ["Q1", "Q2", "Q3", "Q4"],
    wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"]
  };
  var monthValues = {
    narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
    abbreviated: [
      "Jan",
      "Feb",
      "Mar",
      "Apr",
      "May",
      "Jun",
      "Jul",
      "Aug",
      "Sep",
      "Oct",
      "Nov",
      "Dec"
    ],
    wide: [
      "January",
      "February",
      "March",
      "April",
      "May",
      "June",
      "July",
      "August",
      "September",
      "October",
      "November",
      "December"
    ]
  };
  var dayValues = {
    narrow: ["S", "M", "T", "W", "T", "F", "S"],
    short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
    abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
    wide: [
      "Sunday",
      "Monday",
      "Tuesday",
      "Wednesday",
      "Thursday",
      "Friday",
      "Saturday"
    ]
  };
  var dayPeriodValues = {
    narrow: {
      am: "a",
      pm: "p",
      midnight: "mi",
      noon: "n",
      morning: "morning",
      afternoon: "afternoon",
      evening: "evening",
      night: "night"
    },
    abbreviated: {
      am: "AM",
      pm: "PM",
      midnight: "midnight",
      noon: "noon",
      morning: "morning",
      afternoon: "afternoon",
      evening: "evening",
      night: "night"
    },
    wide: {
      am: "a.m.",
      pm: "p.m.",
      midnight: "midnight",
      noon: "noon",
      morning: "morning",
      afternoon: "afternoon",
      evening: "evening",
      night: "night"
    }
  };
  var formattingDayPeriodValues = {
    narrow: {
      am: "a",
      pm: "p",
      midnight: "mi",
      noon: "n",
      morning: "in the morning",
      afternoon: "in the afternoon",
      evening: "in the evening",
      night: "at night"
    },
    abbreviated: {
      am: "AM",
      pm: "PM",
      midnight: "midnight",
      noon: "noon",
      morning: "in the morning",
      afternoon: "in the afternoon",
      evening: "in the evening",
      night: "at night"
    },
    wide: {
      am: "a.m.",
      pm: "p.m.",
      midnight: "midnight",
      noon: "noon",
      morning: "in the morning",
      afternoon: "in the afternoon",
      evening: "in the evening",
      night: "at night"
    }
  };
  var ordinalNumber = (dirtyNumber, _options) => {
    const number2 = Number(dirtyNumber);
    const rem100 = number2 % 100;
    if (rem100 > 20 || rem100 < 10) {
      switch (rem100 % 10) {
        case 1:
          return number2 + "st";
        case 2:
          return number2 + "nd";
        case 3:
          return number2 + "rd";
      }
    }
    return number2 + "th";
  };
  var localize = {
    ordinalNumber,
    era: buildLocalizeFn({
      values: eraValues,
      defaultWidth: "wide"
    }),
    quarter: buildLocalizeFn({
      values: quarterValues,
      defaultWidth: "wide",
      argumentCallback: (quarter) => quarter - 1
    }),
    month: buildLocalizeFn({
      values: monthValues,
      defaultWidth: "wide"
    }),
    day: buildLocalizeFn({
      values: dayValues,
      defaultWidth: "wide"
    }),
    dayPeriod: buildLocalizeFn({
      values: dayPeriodValues,
      defaultWidth: "wide",
      formattingValues: formattingDayPeriodValues,
      defaultFormattingWidth: "wide"
    })
  };

  // node_modules/date-fns/locale/_lib/buildMatchFn.js
  function buildMatchFn(args) {
    return (string, options2 = {}) => {
      const width = options2.width;
      const matchPattern = width && args.matchPatterns[width] || args.matchPatterns[args.defaultMatchWidth];
      const matchResult = string.match(matchPattern);
      if (!matchResult) {
        return null;
      }
      const matchedString = matchResult[0];
      const parsePatterns = width && args.parsePatterns[width] || args.parsePatterns[args.defaultParseWidth];
      const key = Array.isArray(parsePatterns) ? findIndex(parsePatterns, (pattern) => pattern.test(matchedString)) : (
        // [TODO] -- I challenge you to fix the type
        findKey(parsePatterns, (pattern) => pattern.test(matchedString))
      );
      let value;
      value = args.valueCallback ? args.valueCallback(key) : key;
      value = options2.valueCallback ? (
        // [TODO] -- I challenge you to fix the type
        options2.valueCallback(value)
      ) : value;
      const rest = string.slice(matchedString.length);
      return { value, rest };
    };
  }
  function findKey(object, predicate) {
    for (const key in object) {
      if (Object.prototype.hasOwnProperty.call(object, key) && predicate(object[key])) {
        return key;
      }
    }
    return void 0;
  }
  function findIndex(array, predicate) {
    for (let key = 0; key < array.length; key++) {
      if (predicate(array[key])) {
        return key;
      }
    }
    return void 0;
  }

  // node_modules/date-fns/locale/_lib/buildMatchPatternFn.js
  function buildMatchPatternFn(args) {
    return (string, options2 = {}) => {
      const matchResult = string.match(args.matchPattern);
      if (!matchResult) return null;
      const matchedString = matchResult[0];
      const parseResult = string.match(args.parsePattern);
      if (!parseResult) return null;
      let value = args.valueCallback ? args.valueCallback(parseResult[0]) : parseResult[0];
      value = options2.valueCallback ? options2.valueCallback(value) : value;
      const rest = string.slice(matchedString.length);
      return { value, rest };
    };
  }

  // node_modules/date-fns/locale/en-US/_lib/match.js
  var matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
  var parseOrdinalNumberPattern = /\d+/i;
  var matchEraPatterns = {
    narrow: /^(b|a)/i,
    abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
    wide: /^(before christ|before common era|anno domini|common era)/i
  };
  var parseEraPatterns = {
    any: [/^b/i, /^(a|c)/i]
  };
  var matchQuarterPatterns = {
    narrow: /^[1234]/i,
    abbreviated: /^q[1234]/i,
    wide: /^[1234](th|st|nd|rd)? quarter/i
  };
  var parseQuarterPatterns = {
    any: [/1/i, /2/i, /3/i, /4/i]
  };
  var matchMonthPatterns = {
    narrow: /^[jfmasond]/i,
    abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
    wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i
  };
  var parseMonthPatterns = {
    narrow: [
      /^j/i,
      /^f/i,
      /^m/i,
      /^a/i,
      /^m/i,
      /^j/i,
      /^j/i,
      /^a/i,
      /^s/i,
      /^o/i,
      /^n/i,
      /^d/i
    ],
    any: [
      /^ja/i,
      /^f/i,
      /^mar/i,
      /^ap/i,
      /^may/i,
      /^jun/i,
      /^jul/i,
      /^au/i,
      /^s/i,
      /^o/i,
      /^n/i,
      /^d/i
    ]
  };
  var matchDayPatterns = {
    narrow: /^[smtwf]/i,
    short: /^(su|mo|tu|we|th|fr|sa)/i,
    abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
    wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i
  };
  var parseDayPatterns = {
    narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
    any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i]
  };
  var matchDayPeriodPatterns = {
    narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
    any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i
  };
  var parseDayPeriodPatterns = {
    any: {
      am: /^a/i,
      pm: /^p/i,
      midnight: /^mi/i,
      noon: /^no/i,
      morning: /morning/i,
      afternoon: /afternoon/i,
      evening: /evening/i,
      night: /night/i
    }
  };
  var match2 = {
    ordinalNumber: buildMatchPatternFn({
      matchPattern: matchOrdinalNumberPattern,
      parsePattern: parseOrdinalNumberPattern,
      valueCallback: (value) => parseInt(value, 10)
    }),
    era: buildMatchFn({
      matchPatterns: matchEraPatterns,
      defaultMatchWidth: "wide",
      parsePatterns: parseEraPatterns,
      defaultParseWidth: "any"
    }),
    quarter: buildMatchFn({
      matchPatterns: matchQuarterPatterns,
      defaultMatchWidth: "wide",
      parsePatterns: parseQuarterPatterns,
      defaultParseWidth: "any",
      valueCallback: (index2) => index2 + 1
    }),
    month: buildMatchFn({
      matchPatterns: matchMonthPatterns,
      defaultMatchWidth: "wide",
      parsePatterns: parseMonthPatterns,
      defaultParseWidth: "any"
    }),
    day: buildMatchFn({
      matchPatterns: matchDayPatterns,
      defaultMatchWidth: "wide",
      parsePatterns: parseDayPatterns,
      defaultParseWidth: "any"
    }),
    dayPeriod: buildMatchFn({
      matchPatterns: matchDayPeriodPatterns,
      defaultMatchWidth: "any",
      parsePatterns: parseDayPeriodPatterns,
      defaultParseWidth: "any"
    })
  };

  // node_modules/date-fns/locale/en-US.js
  var enUS = {
    code: "en-US",
    formatDistance,
    formatLong,
    formatRelative,
    localize,
    match: match2,
    options: {
      weekStartsOn: 0,
      firstWeekContainsDate: 1
    }
  };

  // node_modules/date-fns/getDayOfYear.js
  function getDayOfYear(date, options2) {
    const _date = toDate(date, options2?.in);
    const diff = differenceInCalendarDays(_date, startOfYear(_date));
    const dayOfYear = diff + 1;
    return dayOfYear;
  }

  // node_modules/date-fns/getISOWeek.js
  function getISOWeek(date, options2) {
    const _date = toDate(date, options2?.in);
    const diff = +startOfISOWeek(_date) - +startOfISOWeekYear(_date);
    return Math.round(diff / millisecondsInWeek) + 1;
  }

  // node_modules/date-fns/getWeekYear.js
  function getWeekYear(date, options2) {
    const _date = toDate(date, options2?.in);
    const year = _date.getFullYear();
    const defaultOptions3 = getDefaultOptions();
    const firstWeekContainsDate = options2?.firstWeekContainsDate ?? options2?.locale?.options?.firstWeekContainsDate ?? defaultOptions3.firstWeekContainsDate ?? defaultOptions3.locale?.options?.firstWeekContainsDate ?? 1;
    const firstWeekOfNextYear = constructFrom(options2?.in || date, 0);
    firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
    firstWeekOfNextYear.setHours(0, 0, 0, 0);
    const startOfNextYear = startOfWeek(firstWeekOfNextYear, options2);
    const firstWeekOfThisYear = constructFrom(options2?.in || date, 0);
    firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
    firstWeekOfThisYear.setHours(0, 0, 0, 0);
    const startOfThisYear = startOfWeek(firstWeekOfThisYear, options2);
    if (+_date >= +startOfNextYear) {
      return year + 1;
    } else if (+_date >= +startOfThisYear) {
      return year;
    } else {
      return year - 1;
    }
  }

  // node_modules/date-fns/startOfWeekYear.js
  function startOfWeekYear(date, options2) {
    const defaultOptions3 = getDefaultOptions();
    const firstWeekContainsDate = options2?.firstWeekContainsDate ?? options2?.locale?.options?.firstWeekContainsDate ?? defaultOptions3.firstWeekContainsDate ?? defaultOptions3.locale?.options?.firstWeekContainsDate ?? 1;
    const year = getWeekYear(date, options2);
    const firstWeek = constructFrom(options2?.in || date, 0);
    firstWeek.setFullYear(year, 0, firstWeekContainsDate);
    firstWeek.setHours(0, 0, 0, 0);
    const _date = startOfWeek(firstWeek, options2);
    return _date;
  }

  // node_modules/date-fns/getWeek.js
  function getWeek(date, options2) {
    const _date = toDate(date, options2?.in);
    const diff = +startOfWeek(_date, options2) - +startOfWeekYear(_date, options2);
    return Math.round(diff / millisecondsInWeek) + 1;
  }

  // node_modules/date-fns/_lib/addLeadingZeros.js
  function addLeadingZeros(number2, targetLength) {
    const sign = number2 < 0 ? "-" : "";
    const output = Math.abs(number2).toString().padStart(targetLength, "0");
    return sign + output;
  }

  // node_modules/date-fns/_lib/format/lightFormatters.js
  var lightFormatters = {
    // Year
    y(date, token2) {
      const signedYear = date.getFullYear();
      const year = signedYear > 0 ? signedYear : 1 - signedYear;
      return addLeadingZeros(token2 === "yy" ? year % 100 : year, token2.length);
    },
    // Month
    M(date, token2) {
      const month = date.getMonth();
      return token2 === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
    },
    // Day of the month
    d(date, token2) {
      return addLeadingZeros(date.getDate(), token2.length);
    },
    // AM or PM
    a(date, token2) {
      const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
      switch (token2) {
        case "a":
        case "aa":
          return dayPeriodEnumValue.toUpperCase();
        case "aaa":
          return dayPeriodEnumValue;
        case "aaaaa":
          return dayPeriodEnumValue[0];
        case "aaaa":
        default:
          return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
      }
    },
    // Hour [1-12]
    h(date, token2) {
      return addLeadingZeros(date.getHours() % 12 || 12, token2.length);
    },
    // Hour [0-23]
    H(date, token2) {
      return addLeadingZeros(date.getHours(), token2.length);
    },
    // Minute
    m(date, token2) {
      return addLeadingZeros(date.getMinutes(), token2.length);
    },
    // Second
    s(date, token2) {
      return addLeadingZeros(date.getSeconds(), token2.length);
    },
    // Fraction of second
    S(date, token2) {
      const numberOfDigits = token2.length;
      const milliseconds = date.getMilliseconds();
      const fractionalSeconds = Math.trunc(
        milliseconds * Math.pow(10, numberOfDigits - 3)
      );
      return addLeadingZeros(fractionalSeconds, token2.length);
    }
  };

  // node_modules/date-fns/_lib/format/formatters.js
  var dayPeriodEnum = {
    am: "am",
    pm: "pm",
    midnight: "midnight",
    noon: "noon",
    morning: "morning",
    afternoon: "afternoon",
    evening: "evening",
    night: "night"
  };
  var formatters = {
    // Era
    G: function(date, token2, localize2) {
      const era = date.getFullYear() > 0 ? 1 : 0;
      switch (token2) {
        // AD, BC
        case "G":
        case "GG":
        case "GGG":
          return localize2.era(era, { width: "abbreviated" });
        // A, B
        case "GGGGG":
          return localize2.era(era, { width: "narrow" });
        // Anno Domini, Before Christ
        case "GGGG":
        default:
          return localize2.era(era, { width: "wide" });
      }
    },
    // Year
    y: function(date, token2, localize2) {
      if (token2 === "yo") {
        const signedYear = date.getFullYear();
        const year = signedYear > 0 ? signedYear : 1 - signedYear;
        return localize2.ordinalNumber(year, { unit: "year" });
      }
      return lightFormatters.y(date, token2);
    },
    // Local week-numbering year
    Y: function(date, token2, localize2, options2) {
      const signedWeekYear = getWeekYear(date, options2);
      const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
      if (token2 === "YY") {
        const twoDigitYear = weekYear % 100;
        return addLeadingZeros(twoDigitYear, 2);
      }
      if (token2 === "Yo") {
        return localize2.ordinalNumber(weekYear, { unit: "year" });
      }
      return addLeadingZeros(weekYear, token2.length);
    },
    // ISO week-numbering year
    R: function(date, token2) {
      const isoWeekYear = getISOWeekYear(date);
      return addLeadingZeros(isoWeekYear, token2.length);
    },
    // Extended year. This is a single number designating the year of this calendar system.
    // The main difference between `y` and `u` localizers are B.C. years:
    // | Year | `y` | `u` |
    // |------|-----|-----|
    // | AC 1 |   1 |   1 |
    // | BC 1 |   1 |   0 |
    // | BC 2 |   2 |  -1 |
    // Also `yy` always returns the last two digits of a year,
    // while `uu` pads single digit years to 2 characters and returns other years unchanged.
    u: function(date, token2) {
      const year = date.getFullYear();
      return addLeadingZeros(year, token2.length);
    },
    // Quarter
    Q: function(date, token2, localize2) {
      const quarter = Math.ceil((date.getMonth() + 1) / 3);
      switch (token2) {
        // 1, 2, 3, 4
        case "Q":
          return String(quarter);
        // 01, 02, 03, 04
        case "QQ":
          return addLeadingZeros(quarter, 2);
        // 1st, 2nd, 3rd, 4th
        case "Qo":
          return localize2.ordinalNumber(quarter, { unit: "quarter" });
        // Q1, Q2, Q3, Q4
        case "QQQ":
          return localize2.quarter(quarter, {
            width: "abbreviated",
            context: "formatting"
          });
        // 1, 2, 3, 4 (narrow quarter; could be not numerical)
        case "QQQQQ":
          return localize2.quarter(quarter, {
            width: "narrow",
            context: "formatting"
          });
        // 1st quarter, 2nd quarter, ...
        case "QQQQ":
        default:
          return localize2.quarter(quarter, {
            width: "wide",
            context: "formatting"
          });
      }
    },
    // Stand-alone quarter
    q: function(date, token2, localize2) {
      const quarter = Math.ceil((date.getMonth() + 1) / 3);
      switch (token2) {
        // 1, 2, 3, 4
        case "q":
          return String(quarter);
        // 01, 02, 03, 04
        case "qq":
          return addLeadingZeros(quarter, 2);
        // 1st, 2nd, 3rd, 4th
        case "qo":
          return localize2.ordinalNumber(quarter, { unit: "quarter" });
        // Q1, Q2, Q3, Q4
        case "qqq":
          return localize2.quarter(quarter, {
            width: "abbreviated",
            context: "standalone"
          });
        // 1, 2, 3, 4 (narrow quarter; could be not numerical)
        case "qqqqq":
          return localize2.quarter(quarter, {
            width: "narrow",
            context: "standalone"
          });
        // 1st quarter, 2nd quarter, ...
        case "qqqq":
        default:
          return localize2.quarter(quarter, {
            width: "wide",
            context: "standalone"
          });
      }
    },
    // Month
    M: function(date, token2, localize2) {
      const month = date.getMonth();
      switch (token2) {
        case "M":
        case "MM":
          return lightFormatters.M(date, token2);
        // 1st, 2nd, ..., 12th
        case "Mo":
          return localize2.ordinalNumber(month + 1, { unit: "month" });
        // Jan, Feb, ..., Dec
        case "MMM":
          return localize2.month(month, {
            width: "abbreviated",
            context: "formatting"
          });
        // J, F, ..., D
        case "MMMMM":
          return localize2.month(month, {
            width: "narrow",
            context: "formatting"
          });
        // January, February, ..., December
        case "MMMM":
        default:
          return localize2.month(month, { width: "wide", context: "formatting" });
      }
    },
    // Stand-alone month
    L: function(date, token2, localize2) {
      const month = date.getMonth();
      switch (token2) {
        // 1, 2, ..., 12
        case "L":
          return String(month + 1);
        // 01, 02, ..., 12
        case "LL":
          return addLeadingZeros(month + 1, 2);
        // 1st, 2nd, ..., 12th
        case "Lo":
          return localize2.ordinalNumber(month + 1, { unit: "month" });
        // Jan, Feb, ..., Dec
        case "LLL":
          return localize2.month(month, {
            width: "abbreviated",
            context: "standalone"
          });
        // J, F, ..., D
        case "LLLLL":
          return localize2.month(month, {
            width: "narrow",
            context: "standalone"
          });
        // January, February, ..., December
        case "LLLL":
        default:
          return localize2.month(month, { width: "wide", context: "standalone" });
      }
    },
    // Local week of year
    w: function(date, token2, localize2, options2) {
      const week = getWeek(date, options2);
      if (token2 === "wo") {
        return localize2.ordinalNumber(week, { unit: "week" });
      }
      return addLeadingZeros(week, token2.length);
    },
    // ISO week of year
    I: function(date, token2, localize2) {
      const isoWeek = getISOWeek(date);
      if (token2 === "Io") {
        return localize2.ordinalNumber(isoWeek, { unit: "week" });
      }
      return addLeadingZeros(isoWeek, token2.length);
    },
    // Day of the month
    d: function(date, token2, localize2) {
      if (token2 === "do") {
        return localize2.ordinalNumber(date.getDate(), { unit: "date" });
      }
      return lightFormatters.d(date, token2);
    },
    // Day of year
    D: function(date, token2, localize2) {
      const dayOfYear = getDayOfYear(date);
      if (token2 === "Do") {
        return localize2.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
      }
      return addLeadingZeros(dayOfYear, token2.length);
    },
    // Day of week
    E: function(date, token2, localize2) {
      const dayOfWeek = date.getDay();
      switch (token2) {
        // Tue
        case "E":
        case "EE":
        case "EEE":
          return localize2.day(dayOfWeek, {
            width: "abbreviated",
            context: "formatting"
          });
        // T
        case "EEEEE":
          return localize2.day(dayOfWeek, {
            width: "narrow",
            context: "formatting"
          });
        // Tu
        case "EEEEEE":
          return localize2.day(dayOfWeek, {
            width: "short",
            context: "formatting"
          });
        // Tuesday
        case "EEEE":
        default:
          return localize2.day(dayOfWeek, {
            width: "wide",
            context: "formatting"
          });
      }
    },
    // Local day of week
    e: function(date, token2, localize2, options2) {
      const dayOfWeek = date.getDay();
      const localDayOfWeek = (dayOfWeek - options2.weekStartsOn + 8) % 7 || 7;
      switch (token2) {
        // Numerical value (Nth day of week with current locale or weekStartsOn)
        case "e":
          return String(localDayOfWeek);
        // Padded numerical value
        case "ee":
          return addLeadingZeros(localDayOfWeek, 2);
        // 1st, 2nd, ..., 7th
        case "eo":
          return localize2.ordinalNumber(localDayOfWeek, { unit: "day" });
        case "eee":
          return localize2.day(dayOfWeek, {
            width: "abbreviated",
            context: "formatting"
          });
        // T
        case "eeeee":
          return localize2.day(dayOfWeek, {
            width: "narrow",
            context: "formatting"
          });
        // Tu
        case "eeeeee":
          return localize2.day(dayOfWeek, {
            width: "short",
            context: "formatting"
          });
        // Tuesday
        case "eeee":
        default:
          return localize2.day(dayOfWeek, {
            width: "wide",
            context: "formatting"
          });
      }
    },
    // Stand-alone local day of week
    c: function(date, token2, localize2, options2) {
      const dayOfWeek = date.getDay();
      const localDayOfWeek = (dayOfWeek - options2.weekStartsOn + 8) % 7 || 7;
      switch (token2) {
        // Numerical value (same as in `e`)
        case "c":
          return String(localDayOfWeek);
        // Padded numerical value
        case "cc":
          return addLeadingZeros(localDayOfWeek, token2.length);
        // 1st, 2nd, ..., 7th
        case "co":
          return localize2.ordinalNumber(localDayOfWeek, { unit: "day" });
        case "ccc":
          return localize2.day(dayOfWeek, {
            width: "abbreviated",
            context: "standalone"
          });
        // T
        case "ccccc":
          return localize2.day(dayOfWeek, {
            width: "narrow",
            context: "standalone"
          });
        // Tu
        case "cccccc":
          return localize2.day(dayOfWeek, {
            width: "short",
            context: "standalone"
          });
        // Tuesday
        case "cccc":
        default:
          return localize2.day(dayOfWeek, {
            width: "wide",
            context: "standalone"
          });
      }
    },
    // ISO day of week
    i: function(date, token2, localize2) {
      const dayOfWeek = date.getDay();
      const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
      switch (token2) {
        // 2
        case "i":
          return String(isoDayOfWeek);
        // 02
        case "ii":
          return addLeadingZeros(isoDayOfWeek, token2.length);
        // 2nd
        case "io":
          return localize2.ordinalNumber(isoDayOfWeek, { unit: "day" });
        // Tue
        case "iii":
          return localize2.day(dayOfWeek, {
            width: "abbreviated",
            context: "formatting"
          });
        // T
        case "iiiii":
          return localize2.day(dayOfWeek, {
            width: "narrow",
            context: "formatting"
          });
        // Tu
        case "iiiiii":
          return localize2.day(dayOfWeek, {
            width: "short",
            context: "formatting"
          });
        // Tuesday
        case "iiii":
        default:
          return localize2.day(dayOfWeek, {
            width: "wide",
            context: "formatting"
          });
      }
    },
    // AM or PM
    a: function(date, token2, localize2) {
      const hours = date.getHours();
      const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
      switch (token2) {
        case "a":
        case "aa":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "abbreviated",
            context: "formatting"
          });
        case "aaa":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "abbreviated",
            context: "formatting"
          }).toLowerCase();
        case "aaaaa":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "narrow",
            context: "formatting"
          });
        case "aaaa":
        default:
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "wide",
            context: "formatting"
          });
      }
    },
    // AM, PM, midnight, noon
    b: function(date, token2, localize2) {
      const hours = date.getHours();
      let dayPeriodEnumValue;
      if (hours === 12) {
        dayPeriodEnumValue = dayPeriodEnum.noon;
      } else if (hours === 0) {
        dayPeriodEnumValue = dayPeriodEnum.midnight;
      } else {
        dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
      }
      switch (token2) {
        case "b":
        case "bb":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "abbreviated",
            context: "formatting"
          });
        case "bbb":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "abbreviated",
            context: "formatting"
          }).toLowerCase();
        case "bbbbb":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "narrow",
            context: "formatting"
          });
        case "bbbb":
        default:
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "wide",
            context: "formatting"
          });
      }
    },
    // in the morning, in the afternoon, in the evening, at night
    B: function(date, token2, localize2) {
      const hours = date.getHours();
      let dayPeriodEnumValue;
      if (hours >= 17) {
        dayPeriodEnumValue = dayPeriodEnum.evening;
      } else if (hours >= 12) {
        dayPeriodEnumValue = dayPeriodEnum.afternoon;
      } else if (hours >= 4) {
        dayPeriodEnumValue = dayPeriodEnum.morning;
      } else {
        dayPeriodEnumValue = dayPeriodEnum.night;
      }
      switch (token2) {
        case "B":
        case "BB":
        case "BBB":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "abbreviated",
            context: "formatting"
          });
        case "BBBBB":
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "narrow",
            context: "formatting"
          });
        case "BBBB":
        default:
          return localize2.dayPeriod(dayPeriodEnumValue, {
            width: "wide",
            context: "formatting"
          });
      }
    },
    // Hour [1-12]
    h: function(date, token2, localize2) {
      if (token2 === "ho") {
        let hours = date.getHours() % 12;
        if (hours === 0) hours = 12;
        return localize2.ordinalNumber(hours, { unit: "hour" });
      }
      return lightFormatters.h(date, token2);
    },
    // Hour [0-23]
    H: function(date, token2, localize2) {
      if (token2 === "Ho") {
        return localize2.ordinalNumber(date.getHours(), { unit: "hour" });
      }
      return lightFormatters.H(date, token2);
    },
    // Hour [0-11]
    K: function(date, token2, localize2) {
      const hours = date.getHours() % 12;
      if (token2 === "Ko") {
        return localize2.ordinalNumber(hours, { unit: "hour" });
      }
      return addLeadingZeros(hours, token2.length);
    },
    // Hour [1-24]
    k: function(date, token2, localize2) {
      let hours = date.getHours();
      if (hours === 0) hours = 24;
      if (token2 === "ko") {
        return localize2.ordinalNumber(hours, { unit: "hour" });
      }
      return addLeadingZeros(hours, token2.length);
    },
    // Minute
    m: function(date, token2, localize2) {
      if (token2 === "mo") {
        return localize2.ordinalNumber(date.getMinutes(), { unit: "minute" });
      }
      return lightFormatters.m(date, token2);
    },
    // Second
    s: function(date, token2, localize2) {
      if (token2 === "so") {
        return localize2.ordinalNumber(date.getSeconds(), { unit: "second" });
      }
      return lightFormatters.s(date, token2);
    },
    // Fraction of second
    S: function(date, token2) {
      return lightFormatters.S(date, token2);
    },
    // Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
    X: function(date, token2, _localize) {
      const timezoneOffset = date.getTimezoneOffset();
      if (timezoneOffset === 0) {
        return "Z";
      }
      switch (token2) {
        // Hours and optional minutes
        case "X":
          return formatTimezoneWithOptionalMinutes(timezoneOffset);
        // Hours, minutes and optional seconds without `:` delimiter
        // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
        // so this token always has the same output as `XX`
        case "XXXX":
        case "XX":
          return formatTimezone(timezoneOffset);
        // Hours, minutes and optional seconds with `:` delimiter
        // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
        // so this token always has the same output as `XXX`
        case "XXXXX":
        case "XXX":
        // Hours and minutes with `:` delimiter
        default:
          return formatTimezone(timezoneOffset, ":");
      }
    },
    // Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
    x: function(date, token2, _localize) {
      const timezoneOffset = date.getTimezoneOffset();
      switch (token2) {
        // Hours and optional minutes
        case "x":
          return formatTimezoneWithOptionalMinutes(timezoneOffset);
        // Hours, minutes and optional seconds without `:` delimiter
        // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
        // so this token always has the same output as `xx`
        case "xxxx":
        case "xx":
          return formatTimezone(timezoneOffset);
        // Hours, minutes and optional seconds with `:` delimiter
        // Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
        // so this token always has the same output as `xxx`
        case "xxxxx":
        case "xxx":
        // Hours and minutes with `:` delimiter
        default:
          return formatTimezone(timezoneOffset, ":");
      }
    },
    // Timezone (GMT)
    O: function(date, token2, _localize) {
      const timezoneOffset = date.getTimezoneOffset();
      switch (token2) {
        // Short
        case "O":
        case "OO":
        case "OOO":
          return "GMT" + formatTimezoneShort(timezoneOffset, ":");
        // Long
        case "OOOO":
        default:
          return "GMT" + formatTimezone(timezoneOffset, ":");
      }
    },
    // Timezone (specific non-location)
    z: function(date, token2, _localize) {
      const timezoneOffset = date.getTimezoneOffset();
      switch (token2) {
        // Short
        case "z":
        case "zz":
        case "zzz":
          return "GMT" + formatTimezoneShort(timezoneOffset, ":");
        // Long
        case "zzzz":
        default:
          return "GMT" + formatTimezone(timezoneOffset, ":");
      }
    },
    // Seconds timestamp
    t: function(date, token2, _localize) {
      const timestamp = Math.trunc(+date / 1e3);
      return addLeadingZeros(timestamp, token2.length);
    },
    // Milliseconds timestamp
    T: function(date, token2, _localize) {
      return addLeadingZeros(+date, token2.length);
    }
  };
  function formatTimezoneShort(offset4, delimiter2 = "") {
    const sign = offset4 > 0 ? "-" : "+";
    const absOffset = Math.abs(offset4);
    const hours = Math.trunc(absOffset / 60);
    const minutes = absOffset % 60;
    if (minutes === 0) {
      return sign + String(hours);
    }
    return sign + String(hours) + delimiter2 + addLeadingZeros(minutes, 2);
  }
  function formatTimezoneWithOptionalMinutes(offset4, delimiter2) {
    if (offset4 % 60 === 0) {
      const sign = offset4 > 0 ? "-" : "+";
      return sign + addLeadingZeros(Math.abs(offset4) / 60, 2);
    }
    return formatTimezone(offset4, delimiter2);
  }
  function formatTimezone(offset4, delimiter2 = "") {
    const sign = offset4 > 0 ? "-" : "+";
    const absOffset = Math.abs(offset4);
    const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
    const minutes = addLeadingZeros(absOffset % 60, 2);
    return sign + hours + delimiter2 + minutes;
  }

  // node_modules/date-fns/_lib/format/longFormatters.js
  var dateLongFormatter = (pattern, formatLong2) => {
    switch (pattern) {
      case "P":
        return formatLong2.date({ width: "short" });
      case "PP":
        return formatLong2.date({ width: "medium" });
      case "PPP":
        return formatLong2.date({ width: "long" });
      case "PPPP":
      default:
        return formatLong2.date({ width: "full" });
    }
  };
  var timeLongFormatter = (pattern, formatLong2) => {
    switch (pattern) {
      case "p":
        return formatLong2.time({ width: "short" });
      case "pp":
        return formatLong2.time({ width: "medium" });
      case "ppp":
        return formatLong2.time({ width: "long" });
      case "pppp":
      default:
        return formatLong2.time({ width: "full" });
    }
  };
  var dateTimeLongFormatter = (pattern, formatLong2) => {
    const matchResult = pattern.match(/(P+)(p+)?/) || [];
    const datePattern = matchResult[1];
    const timePattern = matchResult[2];
    if (!timePattern) {
      return dateLongFormatter(pattern, formatLong2);
    }
    let dateTimeFormat;
    switch (datePattern) {
      case "P":
        dateTimeFormat = formatLong2.dateTime({ width: "short" });
        break;
      case "PP":
        dateTimeFormat = formatLong2.dateTime({ width: "medium" });
        break;
      case "PPP":
        dateTimeFormat = formatLong2.dateTime({ width: "long" });
        break;
      case "PPPP":
      default:
        dateTimeFormat = formatLong2.dateTime({ width: "full" });
        break;
    }
    return dateTimeFormat.replace("{{date}}", dateLongFormatter(datePattern, formatLong2)).replace("{{time}}", timeLongFormatter(timePattern, formatLong2));
  };
  var longFormatters = {
    p: timeLongFormatter,
    P: dateTimeLongFormatter
  };

  // node_modules/date-fns/_lib/protectedTokens.js
  var dayOfYearTokenRE = /^D+$/;
  var weekYearTokenRE = /^Y+$/;
  var throwTokens = ["D", "DD", "YY", "YYYY"];
  function isProtectedDayOfYearToken(token2) {
    return dayOfYearTokenRE.test(token2);
  }
  function isProtectedWeekYearToken(token2) {
    return weekYearTokenRE.test(token2);
  }
  function warnOrThrowProtectedError(token2, format2, input) {
    const _message = message(token2, format2, input);
    console.warn(_message);
    if (throwTokens.includes(token2)) throw new RangeError(_message);
  }
  function message(token2, format2, input) {
    const subject = token2[0] === "Y" ? "years" : "days of the month";
    return `Use \`${token2.toLowerCase()}\` instead of \`${token2}\` (in \`${format2}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
  }

  // node_modules/date-fns/format.js
  var formattingTokensRegExp = /[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
  var longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
  var escapedStringRegExp = /^'([^]*?)'?$/;
  var doubleQuoteRegExp = /''/g;
  var unescapedLatinCharacterRegExp = /[a-zA-Z]/;
  function format(date, formatStr, options2) {
    const defaultOptions3 = getDefaultOptions();
    const locale = options2?.locale ?? defaultOptions3.locale ?? enUS;
    const firstWeekContainsDate = options2?.firstWeekContainsDate ?? options2?.locale?.options?.firstWeekContainsDate ?? defaultOptions3.firstWeekContainsDate ?? defaultOptions3.locale?.options?.firstWeekContainsDate ?? 1;
    const weekStartsOn = options2?.weekStartsOn ?? options2?.locale?.options?.weekStartsOn ?? defaultOptions3.weekStartsOn ?? defaultOptions3.locale?.options?.weekStartsOn ?? 0;
    const originalDate = toDate(date, options2?.in);
    if (!isValid(originalDate)) {
      throw new RangeError("Invalid time value");
    }
    let parts = formatStr.match(longFormattingTokensRegExp).map((substring) => {
      const firstCharacter = substring[0];
      if (firstCharacter === "p" || firstCharacter === "P") {
        const longFormatter = longFormatters[firstCharacter];
        return longFormatter(substring, locale.formatLong);
      }
      return substring;
    }).join("").match(formattingTokensRegExp).map((substring) => {
      if (substring === "''") {
        return { isToken: false, value: "'" };
      }
      const firstCharacter = substring[0];
      if (firstCharacter === "'") {
        return { isToken: false, value: cleanEscapedString(substring) };
      }
      if (formatters[firstCharacter]) {
        return { isToken: true, value: substring };
      }
      if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
        throw new RangeError(
          "Format string contains an unescaped latin alphabet character `" + firstCharacter + "`"
        );
      }
      return { isToken: false, value: substring };
    });
    if (locale.localize.preprocessor) {
      parts = locale.localize.preprocessor(originalDate, parts);
    }
    const formatterOptions = {
      firstWeekContainsDate,
      weekStartsOn,
      locale
    };
    return parts.map((part) => {
      if (!part.isToken) return part.value;
      const token2 = part.value;
      if (!options2?.useAdditionalWeekYearTokens && isProtectedWeekYearToken(token2) || !options2?.useAdditionalDayOfYearTokens && isProtectedDayOfYearToken(token2)) {
        warnOrThrowProtectedError(token2, formatStr, String(date));
      }
      const formatter = formatters[token2[0]];
      return formatter(originalDate, token2, locale.localize, formatterOptions);
    }).join("");
  }
  function cleanEscapedString(input) {
    const matched = input.match(escapedStringRegExp);
    if (!matched) {
      return input;
    }
    return matched[1].replace(doubleQuoteRegExp, "'");
  }

  // node_modules/date-fns/getDaysInMonth.js
  function getDaysInMonth(date, options2) {
    const _date = toDate(date, options2?.in);
    const year = _date.getFullYear();
    const monthIndex = _date.getMonth();
    const lastDayOfMonth = constructFrom(_date, 0);
    lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);
    lastDayOfMonth.setHours(0, 0, 0, 0);
    return lastDayOfMonth.getDate();
  }

  // node_modules/date-fns/getMonth.js
  function getMonth(date, options2) {
    return toDate(date, options2?.in).getMonth();
  }

  // node_modules/date-fns/getYear.js
  function getYear(date, options2) {
    return toDate(date, options2?.in).getFullYear();
  }

  // node_modules/date-fns/isAfter.js
  function isAfter(date, dateToCompare) {
    return +toDate(date) > +toDate(dateToCompare);
  }

  // node_modules/date-fns/isBefore.js
  function isBefore(date, dateToCompare) {
    return +toDate(date) < +toDate(dateToCompare);
  }

  // node_modules/date-fns/isEqual.js
  function isEqual(leftDate, rightDate) {
    return +toDate(leftDate) === +toDate(rightDate);
  }

  // node_modules/date-fns/startOfMinute.js
  function startOfMinute(date, options2) {
    const date_ = toDate(date, options2?.in);
    date_.setSeconds(0, 0);
    return date_;
  }

  // node_modules/date-fns/isSameMonth.js
  function isSameMonth(laterDate, earlierDate, options2) {
    const [laterDate_, earlierDate_] = normalizeDates(
      options2?.in,
      laterDate,
      earlierDate
    );
    return laterDate_.getFullYear() === earlierDate_.getFullYear() && laterDate_.getMonth() === earlierDate_.getMonth();
  }

  // node_modules/date-fns/isSameYear.js
  function isSameYear(laterDate, earlierDate, options2) {
    const [laterDate_, earlierDate_] = normalizeDates(
      options2?.in,
      laterDate,
      earlierDate
    );
    return laterDate_.getFullYear() === earlierDate_.getFullYear();
  }

  // node_modules/date-fns/subDays.js
  function subDays(date, amount, options2) {
    return addDays(date, -amount, options2);
  }

  // node_modules/date-fns/setMonth.js
  function setMonth(date, month, options2) {
    const _date = toDate(date, options2?.in);
    const year = _date.getFullYear();
    const day = _date.getDate();
    const midMonth = constructFrom(options2?.in || date, 0);
    midMonth.setFullYear(year, month, 15);
    midMonth.setHours(0, 0, 0, 0);
    const daysInMonth = getDaysInMonth(midMonth);
    _date.setMonth(month, Math.min(day, daysInMonth));
    return _date;
  }

  // node_modules/date-fns/set.js
  function set(date, values, options2) {
    let _date = toDate(date, options2?.in);
    if (isNaN(+_date)) return constructFrom(options2?.in || date, NaN);
    if (values.year != null) _date.setFullYear(values.year);
    if (values.month != null) _date = setMonth(_date, values.month);
    if (values.date != null) _date.setDate(values.date);
    if (values.hours != null) _date.setHours(values.hours);
    if (values.minutes != null) _date.setMinutes(values.minutes);
    if (values.seconds != null) _date.setSeconds(values.seconds);
    if (values.milliseconds != null) _date.setMilliseconds(values.milliseconds);
    return _date;
  }

  // node_modules/date-fns/setYear.js
  function setYear(date, year, options2) {
    const date_ = toDate(date, options2?.in);
    if (isNaN(+date_)) return constructFrom(options2?.in || date, NaN);
    date_.setFullYear(year);
    return date_;
  }

  // node_modules/date-fns/startOfToday.js
  function startOfToday(options2) {
    return startOfDay(Date.now(), options2);
  }

  // node_modules/date-fns/subMonths.js
  function subMonths(date, amount, options2) {
    return addMonths(date, -amount, options2);
  }

  // node_modules/date-fns/subWeeks.js
  function subWeeks(date, amount, options2) {
    return addWeeks(date, -amount, options2);
  }

  // node_modules/date-fns/subYears.js
  function subYears(date, amount, options2) {
    return addYears(date, -amount, options2);
  }

  // packages/components/build-module/date-time/date-picker/index.mjs
  var import_i18n42 = __toESM(require_i18n(), 1);
  var import_date3 = __toESM(require_date(), 1);
  var import_element126 = __toESM(require_element(), 1);

  // packages/components/build-module/date-time/date-picker/use-lilius/index.mjs
  var import_element125 = __toESM(require_element(), 1);
  var Day = /* @__PURE__ */ (function(Day22) {
    Day22[Day22["SUNDAY"] = 0] = "SUNDAY";
    Day22[Day22["MONDAY"] = 1] = "MONDAY";
    Day22[Day22["TUESDAY"] = 2] = "TUESDAY";
    Day22[Day22["WEDNESDAY"] = 3] = "WEDNESDAY";
    Day22[Day22["THURSDAY"] = 4] = "THURSDAY";
    Day22[Day22["FRIDAY"] = 5] = "FRIDAY";
    Day22[Day22["SATURDAY"] = 6] = "SATURDAY";
    return Day22;
  })({});
  var inRange = (date, min3, max3) => (isEqual(date, min3) || isAfter(date, min3)) && (isEqual(date, max3) || isBefore(date, max3));
  var clearTime2 = (date) => set(date, {
    hours: 0,
    minutes: 0,
    seconds: 0,
    milliseconds: 0
  });
  var useLilius = ({
    weekStartsOn = Day.SUNDAY,
    viewing: initialViewing = /* @__PURE__ */ new Date(),
    selected: initialSelected = [],
    numberOfMonths = 1
  } = {}) => {
    const [viewing, setViewing] = (0, import_element125.useState)(initialViewing);
    const viewToday = (0, import_element125.useCallback)(() => setViewing(startOfToday()), [setViewing]);
    const viewMonth = (0, import_element125.useCallback)((month) => setViewing((v3) => setMonth(v3, month)), []);
    const viewPreviousMonth = (0, import_element125.useCallback)(() => setViewing((v3) => subMonths(v3, 1)), []);
    const viewNextMonth = (0, import_element125.useCallback)(() => setViewing((v3) => addMonths(v3, 1)), []);
    const viewYear = (0, import_element125.useCallback)((year) => setViewing((v3) => setYear(v3, year)), []);
    const viewPreviousYear = (0, import_element125.useCallback)(() => setViewing((v3) => subYears(v3, 1)), []);
    const viewNextYear = (0, import_element125.useCallback)(() => setViewing((v3) => addYears(v3, 1)), []);
    const [selected, setSelected] = (0, import_element125.useState)(initialSelected.map(clearTime2));
    const clearSelected = () => setSelected([]);
    const isSelected2 = (0, import_element125.useCallback)((date) => selected.findIndex((s3) => isEqual(s3, date)) > -1, [selected]);
    const select = (0, import_element125.useCallback)((date, replaceExisting) => {
      if (replaceExisting) {
        setSelected(Array.isArray(date) ? date : [date]);
      } else {
        setSelected((selectedItems) => selectedItems.concat(Array.isArray(date) ? date : [date]));
      }
    }, []);
    const deselect = (0, import_element125.useCallback)((date) => setSelected((selectedItems) => Array.isArray(date) ? selectedItems.filter((s3) => !date.map((d3) => d3.getTime()).includes(s3.getTime())) : selectedItems.filter((s3) => !isEqual(s3, date))), []);
    const toggle = (0, import_element125.useCallback)((date, replaceExisting) => isSelected2(date) ? deselect(date) : select(date, replaceExisting), [deselect, isSelected2, select]);
    const selectRange = (0, import_element125.useCallback)((start, end, replaceExisting) => {
      if (replaceExisting) {
        setSelected(eachDayOfInterval({
          start,
          end
        }));
      } else {
        setSelected((selectedItems) => selectedItems.concat(eachDayOfInterval({
          start,
          end
        })));
      }
    }, []);
    const deselectRange = (0, import_element125.useCallback)((start, end) => {
      setSelected((selectedItems) => selectedItems.filter((s3) => !eachDayOfInterval({
        start,
        end
      }).map((d3) => d3.getTime()).includes(s3.getTime())));
    }, []);
    const calendar = (0, import_element125.useMemo)(() => eachMonthOfInterval({
      start: startOfMonth(viewing),
      end: endOfMonth(addMonths(viewing, numberOfMonths - 1))
    }).map((month) => eachWeekOfInterval({
      start: startOfMonth(month),
      end: endOfMonth(month)
    }, {
      weekStartsOn
    }).map((week) => eachDayOfInterval({
      start: startOfWeek(week, {
        weekStartsOn
      }),
      end: endOfWeek(week, {
        weekStartsOn
      })
    }))), [viewing, weekStartsOn, numberOfMonths]);
    return {
      clearTime: clearTime2,
      inRange,
      viewing,
      setViewing,
      viewToday,
      viewMonth,
      viewPreviousMonth,
      viewNextMonth,
      viewYear,
      viewPreviousYear,
      viewNextYear,
      selected,
      setSelected,
      clearSelected,
      isSelected: isSelected2,
      select,
      deselect,
      toggle,
      selectRange,
      deselectRange,
      calendar
    };
  };

  // packages/components/build-module/date-time/date-picker/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__25() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Wrapper3 = /* @__PURE__ */ createStyled("div", false ? {
    target: "e15s65uf7"
  } : {
    target: "e15s65uf7",
    label: "Wrapper"
  })(boxSizingReset, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var Navigator = /* @__PURE__ */ createStyled(component_default9, false ? {
    target: "e15s65uf6"
  } : {
    target: "e15s65uf6",
    label: "Navigator"
  })("column-gap:", space(2), ";display:grid;grid-template-columns:0.5fr repeat( 5, 1fr ) 0.5fr;justify-items:center;margin-bottom:", space(4), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ViewPreviousMonthButton = /* @__PURE__ */ createStyled(button_default, false ? {
    target: "e15s65uf5"
  } : {
    target: "e15s65uf5",
    label: "ViewPreviousMonthButton"
  })(false ? {
    name: "sarfoe",
    styles: "grid-column:1/2"
  } : {
    name: "sarfoe",
    styles: "grid-column:1/2/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__25
  });
  var ViewNextMonthButton = /* @__PURE__ */ createStyled(button_default, false ? {
    target: "e15s65uf4"
  } : {
    target: "e15s65uf4",
    label: "ViewNextMonthButton"
  })(false ? {
    name: "1v98r3z",
    styles: "grid-column:7/8"
  } : {
    name: "1v98r3z",
    styles: "grid-column:7/8/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__25
  });
  var NavigatorHeading = /* @__PURE__ */ createStyled(component_default19, false ? {
    target: "e15s65uf3"
  } : {
    target: "e15s65uf3",
    label: "NavigatorHeading"
  })("font-size:", config_values_default.fontSize, ";font-weight:", config_values_default.fontWeight, ";grid-column:2/7;strong{font-weight:", config_values_default.fontWeightEmphasis, ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var Calendar = /* @__PURE__ */ createStyled("div", false ? {
    target: "e15s65uf2"
  } : {
    target: "e15s65uf2",
    label: "Calendar"
  })("column-gap:", space(2), ";display:grid;grid-template-columns:0.5fr repeat( 5, 1fr ) 0.5fr;justify-items:center;row-gap:", space(2), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var DayOfWeek = /* @__PURE__ */ createStyled("div", false ? {
    target: "e15s65uf1"
  } : {
    target: "e15s65uf1",
    label: "DayOfWeek"
  })("color:", COLORS.theme.gray[700], ";font-size:", config_values_default.fontSize, ";line-height:", config_values_default.fontLineHeightBase, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var DayButton = /* @__PURE__ */ createStyled(button_default, false ? {
    shouldForwardProp: (prop) => !["column", "isSelected", "isToday", "hasEvents"].includes(prop),
    target: "e15s65uf0"
  } : {
    shouldForwardProp: (prop) => !["column", "isSelected", "isToday", "hasEvents"].includes(prop),
    target: "e15s65uf0",
    label: "DayButton"
  })("grid-column:", (props) => props.column, ";position:relative;justify-content:center;padding:0;", (props) => props.disabled && `
		pointer-events: none;
		`, " &&&{border-radius:", config_values_default.radiusRound, ";height:", space(7), ";width:", space(7), ";font-weight:400;", (props) => props.isSelected && `
				background: ${COLORS.theme.accent};

				&,
				&:hover:not(:disabled, [aria-disabled=true]) {
					color: ${COLORS.theme.accentInverted};
				}

				&:focus:not(:disabled),
				&:focus:not(:disabled) {
					border: ${config_values_default.borderWidthFocus} solid currentColor;
				}

				/* Highlight the selected day for high-contrast mode */
				&::after {
					content: '';
					position: absolute;
					pointer-events: none;
					inset: 0;
					border-radius: inherit;
					border: 1px solid transparent;
				}
			`, " ", (props) => !props.isSelected && props.isToday && `
			background: ${COLORS.theme.gray[200]};
			`, ";}", (props) => props.hasEvents && `
		::before {
			border: 2px solid ${props.isSelected ? COLORS.theme.accentInverted : COLORS.theme.accent};
			border-radius: ${config_values_default.radiusRound};
			content: " ";
			left: 50%;
			position: absolute;
			transform: translate(-50%, 9px);
		}
		`, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // node_modules/@date-fns/utc/date/mini.js
  var UTCDateMini = class extends Date {
    constructor() {
      super();
      this.setTime(arguments.length === 0 ? (
        // Enables Sinon's fake timers that override the constructor
        Date.now()
      ) : arguments.length === 1 ? typeof arguments[0] === "string" ? +new Date(arguments[0]) : arguments[0] : Date.UTC(...arguments));
    }
    getTimezoneOffset() {
      return 0;
    }
  };
  var re2 = /^(get|set)(?!UTC)/;
  Object.getOwnPropertyNames(Date.prototype).forEach((method) => {
    if (re2.test(method)) {
      const utcMethod = Date.prototype[method.replace(re2, "$1UTC")];
      if (utcMethod) UTCDateMini.prototype[method] = utcMethod;
    }
  });

  // node_modules/@date-fns/utc/date/index.js
  var weekdayFormat = new Intl.DateTimeFormat("en-US", {
    weekday: "short",
    timeZone: "UTC"
  });
  var dateFormat = new Intl.DateTimeFormat("en-US", {
    month: "short",
    day: "numeric",
    timeZone: "UTC"
  });
  var timeFormat = new Intl.DateTimeFormat("en-GB", {
    hour12: false,
    hour: "numeric",
    minute: "numeric",
    second: "numeric",
    timeZone: "UTC"
  });

  // packages/components/build-module/date-time/utils.mjs
  var import_date2 = __toESM(require_date(), 1);
  function inputToDate(input) {
    if (typeof input === "string") {
      const hasTimezone = /Z|[+-]\d{2}(:?\d{2})?$/.test(input);
      if (hasTimezone) {
        return new UTCDateMini(new Date(input));
      }
      return new UTCDateMini((0, import_date2.getDate)(input).getTime());
    }
    const time2 = input instanceof Date ? input.getTime() : input;
    return new UTCDateMini(time2);
  }
  function startOfDayInConfiguredTimezone(date) {
    const year = Number((0, import_date2.date)("Y", date));
    const month = Number((0, import_date2.date)("n", date)) - 1;
    const day = Number((0, import_date2.date)("j", date));
    return new Date(year, month, day, 0, 0, 0, 0);
  }
  function from12hTo24h(hours, isPm) {
    return isPm ? (hours % 12 + 12) % 24 : hours % 12;
  }
  function from24hTo12h(hours) {
    return hours % 12 || 12;
  }
  function buildPadInputStateReducer(pad) {
    return (state, action) => {
      const nextState = {
        ...state
      };
      if (action.type === COMMIT || action.type === PRESS_UP || action.type === PRESS_DOWN) {
        if (nextState.value !== void 0) {
          nextState.value = nextState.value.toString().padStart(pad, "0");
        }
      }
      return nextState;
    };
  }
  var getDaysInMonth2 = (year, month) => (
    // Take advantage of JavaScript's built-in date wrapping logic, where day 0
    // of the next month is interpreted as the last day of the preceding month.
    new Date(year, month + 1, 0).getDate()
  );
  function setInConfiguredTimezone(date, updates) {
    const values = {
      year: Number((0, import_date2.date)("Y", date)),
      month: Number((0, import_date2.date)("n", date)) - 1,
      date: Number((0, import_date2.date)("j", date)),
      hours: Number((0, import_date2.date)("H", date)),
      minutes: Number((0, import_date2.date)("i", date)),
      seconds: Number((0, import_date2.date)("s", date)),
      ...updates
    };
    const daysInMonth = getDaysInMonth2(values.year, values.month);
    values.date = Math.min(values.date, daysInMonth);
    const year = String(values.year).padStart(4, "0");
    const month = String(values.month + 1).padStart(2, "0");
    const day = String(values.date).padStart(2, "0");
    const hours = String(values.hours).padStart(2, "0");
    const minutes = String(values.minutes).padStart(2, "0");
    const seconds = String(values.seconds).padStart(2, "0");
    const timezoneless = `${year}-${month}-${day}T${hours}:${minutes}:${seconds}`;
    return new UTCDateMini((0, import_date2.getDate)(timezoneless).getTime());
  }
  function validateInputElementTarget(event) {
    const HTMLInputElementInstance = event.target?.ownerDocument.defaultView?.HTMLInputElement ?? HTMLInputElement;
    if (!(event.target instanceof HTMLInputElementInstance)) {
      return false;
    }
    return event.target.validity.valid;
  }

  // packages/components/build-module/date-time/constants.mjs
  var TIMEZONELESS_FORMAT = "Y-m-d\\TH:i:s";

  // packages/components/build-module/date-time/date-picker/index.mjs
  var import_jsx_runtime193 = __toESM(require_jsx_runtime(), 1);
  function DatePicker({
    currentDate,
    onChange,
    events = [],
    isInvalidDate,
    onMonthPreviewed,
    startOfWeek: weekStartsOn = 0
  }) {
    const date = inputToDate(currentDate ?? /* @__PURE__ */ new Date());
    const {
      calendar,
      viewing,
      setSelected,
      setViewing,
      isSelected: isSelected2,
      viewPreviousMonth,
      viewNextMonth
    } = useLilius({
      selected: [startOfDayInConfiguredTimezone(date)],
      viewing: startOfDayInConfiguredTimezone(date),
      weekStartsOn
    });
    const [focusable, setFocusable] = (0, import_element126.useState)(startOfDayInConfiguredTimezone(date));
    const [isFocusWithinCalendar, setIsFocusWithinCalendar] = (0, import_element126.useState)(false);
    const [prevCurrentDate, setPrevCurrentDate] = (0, import_element126.useState)(currentDate);
    if (currentDate !== prevCurrentDate) {
      setPrevCurrentDate(currentDate);
      setSelected([startOfDayInConfiguredTimezone(date)]);
      setViewing(startOfDayInConfiguredTimezone(date));
      setFocusable(startOfDayInConfiguredTimezone(date));
    }
    return /* @__PURE__ */ (0, import_jsx_runtime193.jsxs)(Wrapper3, {
      className: "components-datetime__date",
      role: "application",
      "aria-label": (0, import_i18n42.__)("Calendar"),
      children: [/* @__PURE__ */ (0, import_jsx_runtime193.jsxs)(Navigator, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime193.jsx)(ViewPreviousMonthButton, {
          icon: (0, import_i18n42.isRTL)() ? arrow_right_default : arrow_left_default,
          variant: "tertiary",
          "aria-label": (0, import_i18n42.__)("View previous month"),
          onClick: () => {
            viewPreviousMonth();
            setFocusable(subMonths(focusable, 1));
            const prevMonth = subMonths(viewing, 1);
            onMonthPreviewed?.((0, import_date3.dateI18n)(TIMEZONELESS_FORMAT, prevMonth, -prevMonth.getTimezoneOffset()));
          },
          size: "compact"
        }), /* @__PURE__ */ (0, import_jsx_runtime193.jsxs)(NavigatorHeading, {
          level: 3,
          children: [/* @__PURE__ */ (0, import_jsx_runtime193.jsx)("strong", {
            children: (0, import_date3.dateI18n)("F", viewing, -viewing.getTimezoneOffset())
          }), " ", (0, import_date3.dateI18n)("Y", viewing, -viewing.getTimezoneOffset())]
        }), /* @__PURE__ */ (0, import_jsx_runtime193.jsx)(ViewNextMonthButton, {
          icon: (0, import_i18n42.isRTL)() ? arrow_left_default : arrow_right_default,
          variant: "tertiary",
          "aria-label": (0, import_i18n42.__)("View next month"),
          onClick: () => {
            viewNextMonth();
            setFocusable(addMonths(focusable, 1));
            const nextMonth = addMonths(viewing, 1);
            onMonthPreviewed?.((0, import_date3.dateI18n)(TIMEZONELESS_FORMAT, nextMonth, -nextMonth.getTimezoneOffset()));
          },
          size: "compact"
        })]
      }), /* @__PURE__ */ (0, import_jsx_runtime193.jsxs)(Calendar, {
        onFocus: () => setIsFocusWithinCalendar(true),
        onBlur: () => setIsFocusWithinCalendar(false),
        children: [calendar[0][0].map((day) => /* @__PURE__ */ (0, import_jsx_runtime193.jsx)(DayOfWeek, {
          children: (0, import_date3.dateI18n)("D", day, -day.getTimezoneOffset())
        }, day.toString())), calendar[0].map((week) => week.map((day, index2) => {
          if (!isSameMonth(day, viewing)) {
            return null;
          }
          return /* @__PURE__ */ (0, import_jsx_runtime193.jsx)(Day2, {
            day,
            column: index2 + 1,
            isSelected: isSelected2(day),
            isFocusable: isEqual(day, focusable),
            isFocusAllowed: isFocusWithinCalendar,
            isToday: isSameDay(day, startOfDayInConfiguredTimezone(/* @__PURE__ */ new Date())),
            isInvalid: isInvalidDate ? isInvalidDate(day) : false,
            numEvents: events.filter((event) => isSameDay(event.date, day)).length,
            onClick: () => {
              setSelected([day]);
              setFocusable(day);
              const newDate = setInConfiguredTimezone(date, {
                year: day.getFullYear(),
                month: day.getMonth(),
                date: day.getDate()
              });
              onChange?.((0, import_date3.date)(TIMEZONELESS_FORMAT, newDate));
            },
            onKeyDown: (event) => {
              let nextFocusable;
              if (event.key === "ArrowLeft") {
                nextFocusable = addDays(day, (0, import_i18n42.isRTL)() ? 1 : -1);
              }
              if (event.key === "ArrowRight") {
                nextFocusable = addDays(day, (0, import_i18n42.isRTL)() ? -1 : 1);
              }
              if (event.key === "ArrowUp") {
                nextFocusable = subWeeks(day, 1);
              }
              if (event.key === "ArrowDown") {
                nextFocusable = addWeeks(day, 1);
              }
              if (event.key === "PageUp") {
                nextFocusable = subMonths(day, 1);
              }
              if (event.key === "PageDown") {
                nextFocusable = addMonths(day, 1);
              }
              if (event.key === "Home") {
                const dayOfWeek = day.getDay();
                const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
                nextFocusable = subDays(day, daysToSubtract);
              }
              if (event.key === "End") {
                const dayOfWeek = day.getDay();
                const daysToAdd = (weekStartsOn + 6 - dayOfWeek) % 7;
                nextFocusable = addDays(day, daysToAdd);
              }
              if (nextFocusable) {
                event.preventDefault();
                setFocusable(nextFocusable);
                if (!isSameMonth(nextFocusable, viewing)) {
                  setViewing(nextFocusable);
                  onMonthPreviewed?.((0, import_date3.dateI18n)(TIMEZONELESS_FORMAT, nextFocusable, -nextFocusable.getTimezoneOffset()));
                }
              }
            }
          }, day.toString());
        }))]
      })]
    });
  }
  function Day2({
    day,
    column: column2,
    isSelected: isSelected2,
    isFocusable: isFocusable2,
    isFocusAllowed,
    isToday,
    isInvalid,
    numEvents,
    onClick,
    onKeyDown
  }) {
    const ref = (0, import_element126.useRef)(null);
    (0, import_element126.useEffect)(() => {
      if (ref.current && isFocusable2 && isFocusAllowed) {
        ref.current.focus();
      }
    }, [isFocusable2]);
    return /* @__PURE__ */ (0, import_jsx_runtime193.jsx)(DayButton, {
      __next40pxDefaultSize: true,
      ref,
      className: "components-datetime__date__day",
      disabled: isInvalid,
      tabIndex: isFocusable2 ? 0 : -1,
      "aria-label": getDayLabel(day, isSelected2, isToday, numEvents),
      column: column2,
      isSelected: isSelected2,
      isToday,
      hasEvents: numEvents > 0,
      onClick,
      onKeyDown,
      children: (0, import_date3.dateI18n)("j", day, -day.getTimezoneOffset())
    });
  }
  function getDayLabel(date, isSelected2, isToday, numEvents) {
    const {
      formats
    } = (0, import_date3.getSettings)();
    const localizedDate = (0, import_date3.dateI18n)(formats.date, date, -date.getTimezoneOffset());
    const parts = [localizedDate];
    if (isSelected2) {
      parts.push((0, import_i18n42.__)("Selected"));
    }
    if (isToday) {
      parts.push((0, import_i18n42.__)("Today"));
    }
    if (numEvents > 0) {
      parts.push((0, import_i18n42.sprintf)(
        // translators: %d: Number of events on the calendar date.
        (0, import_i18n42._n)("There is %d event", "There are %d events", numEvents),
        numEvents
      ));
    }
    return parts.join(". ");
  }
  var date_picker_default = DatePicker;

  // packages/components/build-module/date-time/time-picker/index.mjs
  var import_element128 = __toESM(require_element(), 1);
  var import_i18n45 = __toESM(require_i18n(), 1);
  var import_date5 = __toESM(require_date(), 1);

  // packages/components/build-module/date-time/time-picker/timezone.mjs
  var import_i18n43 = __toESM(require_i18n(), 1);
  var import_date4 = __toESM(require_date(), 1);

  // packages/components/build-module/date-time/time-picker/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__26() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Wrapper4 = /* @__PURE__ */ createStyled("div", false ? {
    target: "exz187h9"
  } : {
    target: "exz187h9",
    label: "Wrapper"
  })("box-sizing:border-box;font-size:", config_values_default.fontSize, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var Fieldset = /* @__PURE__ */ createStyled("fieldset", false ? {
    target: "exz187h8"
  } : {
    target: "exz187h8",
    label: "Fieldset"
  })("border:0;margin:0 0 ", space(2 * 2), " 0;padding:0;&:last-child{margin-bottom:0;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var TimeWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "exz187h7"
  } : {
    target: "exz187h7",
    label: "TimeWrapper"
  })(false ? {
    name: "pd0mhc",
    styles: "direction:ltr;display:flex"
  } : {
    name: "pd0mhc",
    styles: "direction:ltr;display:flex/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__26
  });
  var baseInput = /* @__PURE__ */ css("&&& ", Input, "{padding-left:", space(2), ";padding-right:", space(2), ";text-align:center;}" + (false ? "" : ";label:baseInput;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var HoursInput = /* @__PURE__ */ createStyled(number_control_default, false ? {
    target: "exz187h6"
  } : {
    target: "exz187h6",
    label: "HoursInput"
  })(baseInput, " width:", space(9), ";&&& ", Input, "{padding-right:0;}&&& ", BackdropUI, "{border-right:0;border-top-right-radius:0;border-bottom-right-radius:0;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var TimeSeparator = /* @__PURE__ */ createStyled("span", false ? {
    target: "exz187h5"
  } : {
    target: "exz187h5",
    label: "TimeSeparator"
  })("border-top:", config_values_default.borderWidth, " solid ", COLORS.gray[700], ";border-bottom:", config_values_default.borderWidth, " solid ", COLORS.gray[700], ";font-size:", config_values_default.fontSize, ";line-height:calc(\n		", config_values_default.controlHeight, " - ", config_values_default.borderWidth, " * 2\n	);display:inline-block;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var MinutesInput = /* @__PURE__ */ createStyled(number_control_default, false ? {
    target: "exz187h4"
  } : {
    target: "exz187h4",
    label: "MinutesInput"
  })(baseInput, " width:", space(9), ";&&& ", Input, "{padding-left:0;}&&& ", BackdropUI, "{border-left:0;border-top-left-radius:0;border-bottom-left-radius:0;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var MonthSelectWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "exz187h3"
  } : {
    target: "exz187h3",
    label: "MonthSelectWrapper"
  })(false ? {
    name: "1ff36h2",
    styles: "flex-grow:1"
  } : {
    name: "1ff36h2",
    styles: "flex-grow:1/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__26
  });
  var DayInput = /* @__PURE__ */ createStyled(number_control_default, false ? {
    target: "exz187h2"
  } : {
    target: "exz187h2",
    label: "DayInput"
  })(baseInput, " width:", space(9), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var YearInput = /* @__PURE__ */ createStyled(number_control_default, false ? {
    target: "exz187h1"
  } : {
    target: "exz187h1",
    label: "YearInput"
  })(baseInput, " width:", space(14), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var TimeZone = /* @__PURE__ */ createStyled("div", false ? {
    target: "exz187h0"
  } : {
    target: "exz187h0",
    label: "TimeZone"
  })(false ? {
    name: "ebu3jh",
    styles: "text-decoration:underline dotted"
  } : {
    name: "ebu3jh",
    styles: "text-decoration:underline dotted/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__26
  });

  // packages/components/build-module/date-time/time-picker/timezone.mjs
  var import_jsx_runtime194 = __toESM(require_jsx_runtime(), 1);
  var TimeZone2 = () => {
    const {
      timezone
    } = (0, import_date4.getSettings)();
    const userTimezoneOffset = -1 * ((/* @__PURE__ */ new Date()).getTimezoneOffset() / 60);
    if (Number(timezone.offset) === userTimezoneOffset) {
      return null;
    }
    const offsetSymbol = Number(timezone.offset) >= 0 ? "+" : "";
    const zoneAbbr = "" !== timezone.abbr && isNaN(Number(timezone.abbr)) ? timezone.abbr : `UTC${offsetSymbol}${timezone.offsetFormatted}`;
    const prettyTimezoneString = timezone.string.replace("_", " ");
    const timezoneDetail = "UTC" === timezone.string ? (0, import_i18n43.__)("Coordinated Universal Time") : `(${zoneAbbr}) ${prettyTimezoneString}`;
    const hasNoAdditionalTimezoneDetail = prettyTimezoneString.trim().length === 0;
    return hasNoAdditionalTimezoneDetail ? /* @__PURE__ */ (0, import_jsx_runtime194.jsx)(TimeZone, {
      className: "components-datetime__timezone",
      children: zoneAbbr
    }) : /* @__PURE__ */ (0, import_jsx_runtime194.jsx)(tooltip_default, {
      placement: "top",
      text: timezoneDetail,
      children: /* @__PURE__ */ (0, import_jsx_runtime194.jsx)(TimeZone, {
        className: "components-datetime__timezone",
        children: zoneAbbr
      })
    });
  };
  var timezone_default = TimeZone2;

  // packages/components/build-module/date-time/time-picker/time-input/index.mjs
  var import_i18n44 = __toESM(require_i18n(), 1);
  var import_element127 = __toESM(require_element(), 1);
  var import_jsx_runtime195 = __toESM(require_jsx_runtime(), 1);
  function TimeInput({
    value: valueProp,
    defaultValue: defaultValue2,
    is12Hour,
    label,
    minutesProps,
    onChange
  }) {
    const [value = {
      hours: (/* @__PURE__ */ new Date()).getHours(),
      minutes: (/* @__PURE__ */ new Date()).getMinutes()
    }, setValue] = useControlledValue({
      value: valueProp,
      onChange,
      defaultValue: defaultValue2
    });
    const dayPeriod = parseDayPeriod(value.hours);
    const hours12Format = from24hTo12h(value.hours);
    const buildNumberControlChangeCallback = (method) => {
      return (_value, {
        event
      }) => {
        if (!validateInputElementTarget(event)) {
          return;
        }
        const numberValue = Number(_value);
        setValue({
          ...value,
          [method]: method === "hours" && is12Hour ? from12hTo24h(numberValue, dayPeriod === "PM") : numberValue
        });
      };
    };
    const buildAmPmChangeCallback = (_value) => {
      return () => {
        if (dayPeriod === _value) {
          return;
        }
        setValue({
          ...value,
          hours: from12hTo24h(hours12Format, _value === "PM")
        });
      };
    };
    function parseDayPeriod(_hours) {
      return _hours < 12 ? "AM" : "PM";
    }
    const Wrapper6 = label ? Fieldset : import_element127.Fragment;
    return /* @__PURE__ */ (0, import_jsx_runtime195.jsxs)(Wrapper6, {
      children: [label && /* @__PURE__ */ (0, import_jsx_runtime195.jsx)(base_control_default.VisualLabel, {
        as: "legend",
        children: label
      }), /* @__PURE__ */ (0, import_jsx_runtime195.jsxs)(component_default9, {
        alignment: "left",
        expanded: false,
        children: [/* @__PURE__ */ (0, import_jsx_runtime195.jsxs)(TimeWrapper, {
          className: "components-datetime__time-field components-datetime__time-field-time",
          children: [/* @__PURE__ */ (0, import_jsx_runtime195.jsx)(HoursInput, {
            className: "components-datetime__time-field-hours-input",
            label: (0, import_i18n44.__)("Hours"),
            hideLabelFromVision: true,
            value: String(is12Hour ? hours12Format : value.hours).padStart(2, "0"),
            step: 1,
            min: is12Hour ? 1 : 0,
            max: is12Hour ? 12 : 23,
            required: true,
            spinControls: "none",
            isPressEnterToChange: true,
            isDragEnabled: false,
            isShiftStepEnabled: false,
            onChange: buildNumberControlChangeCallback("hours"),
            __unstableStateReducer: buildPadInputStateReducer(2)
          }), /* @__PURE__ */ (0, import_jsx_runtime195.jsx)(TimeSeparator, {
            className: "components-datetime__time-separator",
            "aria-hidden": "true",
            children: ":"
          }), /* @__PURE__ */ (0, import_jsx_runtime195.jsx)(MinutesInput, {
            className: clsx_default(
              "components-datetime__time-field-minutes-input",
              // Unused, for backwards compatibility.
              minutesProps?.className
            ),
            label: (0, import_i18n44.__)("Minutes"),
            hideLabelFromVision: true,
            value: String(value.minutes).padStart(2, "0"),
            step: 1,
            min: 0,
            max: 59,
            required: true,
            spinControls: "none",
            isPressEnterToChange: true,
            isDragEnabled: false,
            isShiftStepEnabled: false,
            onChange: (...args) => {
              buildNumberControlChangeCallback("minutes")(...args);
              minutesProps?.onChange?.(...args);
            },
            __unstableStateReducer: buildPadInputStateReducer(2),
            ...minutesProps
          })]
        }), is12Hour && /* @__PURE__ */ (0, import_jsx_runtime195.jsxs)(component_default12, {
          isBlock: true,
          label: (0, import_i18n44.__)("Select AM or PM"),
          hideLabelFromVision: true,
          value: dayPeriod,
          onChange: (newValue) => {
            buildAmPmChangeCallback(newValue)();
          },
          children: [/* @__PURE__ */ (0, import_jsx_runtime195.jsx)(component_default14, {
            value: "AM",
            label: (0, import_i18n44.__)("AM")
          }), /* @__PURE__ */ (0, import_jsx_runtime195.jsx)(component_default14, {
            value: "PM",
            label: (0, import_i18n44.__)("PM")
          })]
        })]
      })]
    });
  }

  // packages/components/build-module/date-time/time-picker/index.mjs
  var import_jsx_runtime196 = __toESM(require_jsx_runtime(), 1);
  var VALID_DATE_ORDERS = ["dmy", "mdy", "ymd"];
  function TimePicker({
    is12Hour,
    currentTime,
    onChange,
    dateOrder: dateOrderProp,
    hideLabelFromVision = false
  }) {
    const [date, setDate] = (0, import_element128.useState)(() => (
      // Truncate the date at the minutes, see: #15495.
      startOfMinute(inputToDate(currentTime ?? /* @__PURE__ */ new Date()))
    ));
    (0, import_element128.useEffect)(() => {
      setDate(startOfMinute(inputToDate(currentTime ?? /* @__PURE__ */ new Date())));
    }, [currentTime]);
    const monthOptions = [{
      value: "01",
      label: (0, import_i18n45.__)("January")
    }, {
      value: "02",
      label: (0, import_i18n45.__)("February")
    }, {
      value: "03",
      label: (0, import_i18n45.__)("March")
    }, {
      value: "04",
      label: (0, import_i18n45.__)("April")
    }, {
      value: "05",
      label: (0, import_i18n45.__)("May")
    }, {
      value: "06",
      label: (0, import_i18n45.__)("June")
    }, {
      value: "07",
      label: (0, import_i18n45.__)("July")
    }, {
      value: "08",
      label: (0, import_i18n45.__)("August")
    }, {
      value: "09",
      label: (0, import_i18n45.__)("September")
    }, {
      value: "10",
      label: (0, import_i18n45.__)("October")
    }, {
      value: "11",
      label: (0, import_i18n45.__)("November")
    }, {
      value: "12",
      label: (0, import_i18n45.__)("December")
    }];
    const {
      day,
      month,
      year,
      minutes,
      hours
    } = (0, import_element128.useMemo)(() => ({
      day: (0, import_date5.date)("d", date),
      month: (0, import_date5.date)("m", date),
      year: (0, import_date5.date)("Y", date),
      minutes: (0, import_date5.date)("i", date),
      hours: (0, import_date5.date)("H", date)
    }), [date]);
    const buildNumberControlChangeCallback = (method) => {
      const callback = (value, {
        event
      }) => {
        if (!validateInputElementTarget(event)) {
          return;
        }
        const numberValue = Number(value);
        const newDate = setInConfiguredTimezone(date, {
          [method]: numberValue
        });
        setDate(newDate);
        onChange?.((0, import_date5.date)(TIMEZONELESS_FORMAT, newDate));
      };
      return callback;
    };
    const onTimeInputChangeCallback = ({
      hours: newHours,
      minutes: newMinutes
    }) => {
      const newDate = setInConfiguredTimezone(date, {
        hours: newHours,
        minutes: newMinutes
      });
      setDate(newDate);
      onChange?.((0, import_date5.date)(TIMEZONELESS_FORMAT, newDate));
    };
    const dayField = /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(DayInput, {
      className: "components-datetime__time-field components-datetime__time-field-day",
      label: (0, import_i18n45.__)("Day"),
      hideLabelFromVision: true,
      value: day,
      step: 1,
      min: 1,
      max: getDaysInMonth2(Number(year), Number(month) - 1),
      required: true,
      spinControls: "none",
      isPressEnterToChange: true,
      isDragEnabled: false,
      isShiftStepEnabled: false,
      onChange: buildNumberControlChangeCallback("date")
    }, "day");
    const monthField = /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(MonthSelectWrapper, {
      children: /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(select_control_default, {
        className: "components-datetime__time-field components-datetime__time-field-month",
        label: (0, import_i18n45.__)("Month"),
        hideLabelFromVision: true,
        value: month,
        options: monthOptions,
        onChange: (value) => {
          const newDate = setInConfiguredTimezone(date, {
            month: Number(value) - 1
          });
          setDate(newDate);
          onChange?.((0, import_date5.date)(TIMEZONELESS_FORMAT, newDate));
        }
      })
    }, "month");
    const yearField = /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(YearInput, {
      className: "components-datetime__time-field components-datetime__time-field-year",
      label: (0, import_i18n45.__)("Year"),
      hideLabelFromVision: true,
      value: year,
      step: 1,
      min: 1,
      max: 9999,
      required: true,
      spinControls: "none",
      isPressEnterToChange: true,
      isDragEnabled: false,
      isShiftStepEnabled: false,
      onChange: buildNumberControlChangeCallback("year"),
      __unstableStateReducer: buildPadInputStateReducer(4)
    }, "year");
    const defaultDateOrder = is12Hour ? "mdy" : "dmy";
    const dateOrder = dateOrderProp && VALID_DATE_ORDERS.includes(dateOrderProp) ? dateOrderProp : defaultDateOrder;
    const fields = dateOrder.split("").map((field) => {
      switch (field) {
        case "d":
          return dayField;
        case "m":
          return monthField;
        case "y":
          return yearField;
        default:
          return null;
      }
    });
    return /* @__PURE__ */ (0, import_jsx_runtime196.jsxs)(Wrapper4, {
      className: "components-datetime__time",
      children: [/* @__PURE__ */ (0, import_jsx_runtime196.jsxs)(Fieldset, {
        children: [hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(component_default2, {
          as: "legend",
          children: (0, import_i18n45.__)("Time")
        }) : /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(base_control_default.VisualLabel, {
          as: "legend",
          className: "components-datetime__time-legend",
          children: (0, import_i18n45.__)("Time")
        }), /* @__PURE__ */ (0, import_jsx_runtime196.jsxs)(component_default9, {
          className: "components-datetime__time-wrapper",
          children: [/* @__PURE__ */ (0, import_jsx_runtime196.jsx)(TimeInput, {
            value: {
              hours: Number(hours),
              minutes: Number(minutes)
            },
            is12Hour,
            onChange: onTimeInputChangeCallback
          }), /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(component_default6, {}), /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(timezone_default, {})]
        })]
      }), /* @__PURE__ */ (0, import_jsx_runtime196.jsxs)(Fieldset, {
        children: [hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(component_default2, {
          as: "legend",
          children: (0, import_i18n45.__)("Date")
        }) : /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(base_control_default.VisualLabel, {
          as: "legend",
          className: "components-datetime__time-legend",
          children: (0, import_i18n45.__)("Date")
        }), /* @__PURE__ */ (0, import_jsx_runtime196.jsx)(component_default9, {
          className: "components-datetime__time-wrapper",
          children: fields
        })]
      })]
    });
  }
  TimePicker.TimeInput = TimeInput;
  Object.assign(TimePicker.TimeInput, {
    displayName: "TimePicker.TimeInput"
  });
  var time_picker_default = TimePicker;

  // packages/components/build-module/date-time/date-time/index.mjs
  var import_element129 = __toESM(require_element(), 1);

  // packages/components/build-module/date-time/date-time/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__27() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Wrapper5 = /* @__PURE__ */ createStyled(component_default18, false ? {
    target: "e1p5onf00"
  } : {
    target: "e1p5onf00",
    label: "Wrapper"
  })(false ? {
    name: "1khn195",
    styles: "box-sizing:border-box"
  } : {
    name: "1khn195",
    styles: "box-sizing:border-box/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFVdUMiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBWU3RhY2sgfSBmcm9tICcuLi8uLi92LXN0YWNrJztcblxuZXhwb3J0IGNvbnN0IFdyYXBwZXIgPSBzdHlsZWQoIFZTdGFjayApYFxuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuYDtcbiJdfQ== */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__27
  });

  // packages/components/build-module/date-time/date-time/index.mjs
  var import_jsx_runtime197 = __toESM(require_jsx_runtime(), 1);
  var noop14 = () => {
  };
  function UnforwardedDateTimePicker({
    currentDate,
    is12Hour,
    dateOrder,
    isInvalidDate,
    onMonthPreviewed = noop14,
    onChange,
    events,
    startOfWeek: startOfWeek2
  }, ref) {
    return /* @__PURE__ */ (0, import_jsx_runtime197.jsx)(Wrapper5, {
      ref,
      className: "components-datetime",
      spacing: 4,
      children: /* @__PURE__ */ (0, import_jsx_runtime197.jsxs)(import_jsx_runtime197.Fragment, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime197.jsx)(time_picker_default, {
          currentTime: currentDate,
          onChange,
          is12Hour,
          dateOrder
        }), /* @__PURE__ */ (0, import_jsx_runtime197.jsx)(date_picker_default, {
          currentDate,
          onChange,
          isInvalidDate,
          events,
          onMonthPreviewed,
          startOfWeek: startOfWeek2
        })]
      })
    });
  }
  var DateTimePicker = (0, import_element129.forwardRef)(UnforwardedDateTimePicker);
  DateTimePicker.displayName = "DateTimePicker";
  var date_time_default = DateTimePicker;

  // packages/components/build-module/date-time/index.mjs
  var date_time_default2 = date_time_default;

  // packages/components/build-module/disabled/styles/disabled-styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__28() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var disabledStyles3 = false ? {
    name: "u2jump",
    styles: "position:relative;pointer-events:none;&::after{content:'';position:absolute;top:0;right:0;bottom:0;left:0;}*{pointer-events:none;}"
  } : {
    name: "iqemdn-disabledStyles",
    styles: "position:relative;pointer-events:none;&::after{content:'';position:absolute;top:0;right:0;bottom:0;left:0;}*{pointer-events:none;};label:disabledStyles;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImRpc2FibGVkLXN0eWxlcy50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS2lDIiwiZmlsZSI6ImRpc2FibGVkLXN0eWxlcy50c3giLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5cbmV4cG9ydCBjb25zdCBkaXNhYmxlZFN0eWxlcyA9IGNzc2Bcblx0cG9zaXRpb246IHJlbGF0aXZlO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblxuXHQmOjphZnRlciB7XG5cdFx0Y29udGVudDogJyc7XG5cdFx0cG9zaXRpb246IGFic29sdXRlO1xuXHRcdHRvcDogMDtcblx0XHRyaWdodDogMDtcblx0XHRib3R0b206IDA7XG5cdFx0bGVmdDogMDtcblx0fVxuXG5cdC8vIEFsc28gbWFrZSBuZXN0ZWQgYmxvY2tzIHVuc2VsZWN0YWJsZS5cblx0KiB7XG5cdFx0cG9pbnRlci1ldmVudHM6IG5vbmU7XG5cdH1cbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__28
  };

  // packages/components/build-module/disabled/context.mjs
  var import_element130 = __toESM(require_element(), 1);
  var Context = (0, import_element130.createContext)(false);
  Context.displayName = "DisabledContext";
  var context_default3 = Context;

  // packages/components/build-module/disabled/index.mjs
  var import_jsx_runtime198 = __toESM(require_jsx_runtime(), 1);
  var {
    Consumer,
    Provider: Provider2
  } = context_default3;
  function Disabled({
    className: className2,
    children,
    isDisabled = true,
    ...props
  }) {
    const cx2 = useCx();
    return /* @__PURE__ */ (0, import_jsx_runtime198.jsx)(Provider2, {
      value: isDisabled,
      children: /* @__PURE__ */ (0, import_jsx_runtime198.jsx)("div", {
        // @ts-ignore Reason: inert is a recent HTML attribute
        inert: isDisabled ? "true" : void 0,
        className: isDisabled ? cx2(disabledStyles3, className2, "components-disabled") : void 0,
        ...props,
        children
      })
    });
  }
  Disabled.Context = context_default3;
  Disabled.Consumer = Consumer;
  var disabled_default = Disabled;

  // packages/components/build-module/disclosure/index.mjs
  var import_element131 = __toESM(require_element(), 1);
  var import_jsx_runtime199 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedDisclosureContent = ({
    visible,
    children,
    ...props
  }, ref) => {
    const disclosure = useDisclosureStore({
      open: visible
    });
    return /* @__PURE__ */ (0, import_jsx_runtime199.jsx)(DisclosureContent, {
      store: disclosure,
      ref,
      ...props,
      children
    });
  };
  var DisclosureContent22 = (0, import_element131.forwardRef)(UnforwardedDisclosureContent);
  DisclosureContent22.displayName = "DisclosureContent";

  // packages/components/build-module/draggable/index.mjs
  var import_compose52 = __toESM(require_compose(), 1);
  var import_element132 = __toESM(require_element(), 1);

  // packages/ui/build-module/utils/wp-compat-overlay-slot.mjs
  var STYLE_HASH_ATTRIBUTE11 = "data-wp-hash";
  function getRuntime11() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument11(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash11(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(
      `style[${STYLE_HASH_ATTRIBUTE11}]`
    )) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE11) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle11(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime11();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash11(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE11, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument11(targetDocument) {
    const runtime = getRuntime11();
    runtime.documents.set(
      targetDocument,
      (runtime.documents.get(targetDocument) ?? 0) + 1
    );
    for (const [hash2, css3] of runtime.styles) {
      injectStyle11(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle10(hash2, css3) {
    const runtime = getRuntime11();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle11(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle10("be37f31c1e", "._11fc52b637ff8a7e__slot{inset:0;isolation:isolate;pointer-events:none;position:fixed;z-index:1000000003}@layer wp-ui{@layer utilities, components, compositions, overrides;@layer utilities{._11fc52b637ff8a7e__slot>*{pointer-events:auto}}}");
  }
  var wp_compat_overlay_slot_default = { "slot": "_11fc52b637ff8a7e__slot" };
  var WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE = "data-wp-compat-overlay-slot";
  function resolveOwnerDocument() {
    return typeof document === "undefined" ? null : document;
  }
  function isInWordPressEnvironment() {
    let topWp;
    try {
      topWp = window.top?.wp;
    } catch {
    }
    const wp = topWp ?? window.wp;
    return typeof wp?.components === "object" && wp.components !== null;
  }
  var cachedSlot = null;
  function ensureSlotIsAccessible(element) {
    element.setAttribute("aria-hidden", "false");
    return element;
  }
  function createSlot(ownerDocument) {
    const element = ownerDocument.createElement("div");
    element.setAttribute(WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE, "");
    if (wp_compat_overlay_slot_default.slot) {
      element.classList.add(wp_compat_overlay_slot_default.slot);
    }
    ownerDocument.body.appendChild(element);
    return element;
  }
  function getWpCompatOverlaySlot() {
    if (typeof window === "undefined") {
      return void 0;
    }
    if (!isInWordPressEnvironment() && window.__wpUiCompatOverlaySlotEnabled !== true) {
      return void 0;
    }
    const ownerDocument = resolveOwnerDocument();
    if (!ownerDocument || !ownerDocument.body) {
      return void 0;
    }
    if (cachedSlot && cachedSlot.ownerDocument === ownerDocument && cachedSlot.isConnected) {
      return ensureSlotIsAccessible(cachedSlot);
    }
    const existing = ownerDocument.querySelector(
      `[${WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE}]`
    );
    if (existing instanceof HTMLDivElement) {
      cachedSlot = ensureSlotIsAccessible(existing);
      return cachedSlot;
    }
    if (cachedSlot?.isConnected) {
      cachedSlot.remove();
    }
    cachedSlot = ensureSlotIsAccessible(createSlot(ownerDocument));
    return cachedSlot;
  }

  // packages/components/build-module/draggable/index.mjs
  var import_jsx_runtime200 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE12 = "data-wp-hash";
  function getRuntime12() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument12(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash12(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE12}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE12) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle12(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime12();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash12(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE12, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument12(targetDocument) {
    const runtime = getRuntime12();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle12(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle11(hash2, css3) {
    const runtime = getRuntime12();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle12(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle11("e7e88c1781", "._3476c2e530687f96__invisible-drag-image{height:50px;left:-1000px;position:fixed;width:50px}._6f00e51ab7574306__clone{background:transparent;padding:0;pointer-events:none;position:fixed}._6f00e51ab7574306__clone:not(._664ecd37377558df__is-in-compat-slot){z-index:1000000000}body.is-dragging-components-draggable{cursor:move;cursor:grabbing!important}");
  }
  var style_module_default10 = { "invisible-drag-image": "_3476c2e530687f96__invisible-drag-image", "clone": "_6f00e51ab7574306__clone", "is-in-compat-slot": "_664ecd37377558df__is-in-compat-slot" };
  var dragImageClasses = [style_module_default10["invisible-drag-image"], "components-draggable__invisible-drag-image"].filter(Boolean);
  var cloneWrapperClasses = [style_module_default10.clone, "components-draggable__clone"].filter(Boolean);
  var bodyClass = "is-dragging-components-draggable";
  var clonePadding = 0;
  function Draggable({
    children,
    onDragStart,
    onDragOver,
    onDragEnd,
    appendToOwnerDocument = false,
    cloneClassname,
    elementId,
    transferData,
    __experimentalTransferDataType: transferDataType = "text",
    __experimentalDragComponent: dragComponent
  }) {
    const dragComponentRef = (0, import_element132.useRef)(null);
    const cleanupRef = (0, import_element132.useRef)(() => {
    });
    function end(event) {
      event.preventDefault();
      cleanupRef.current();
      if (onDragEnd) {
        onDragEnd(event);
      }
    }
    function start(event) {
      const {
        ownerDocument
      } = event.target;
      const slot = getWpCompatOverlaySlot();
      const compatSlot = slot?.ownerDocument === ownerDocument ? slot : null;
      event.dataTransfer.setData(transferDataType, JSON.stringify(transferData));
      const cloneWrapper = ownerDocument.createElement("div");
      cloneWrapper.style.top = "0";
      cloneWrapper.style.left = "0";
      const dragImage = ownerDocument.createElement("div");
      if ("function" === typeof event.dataTransfer.setDragImage) {
        dragImage.classList.add(...dragImageClasses);
        ownerDocument.body.appendChild(dragImage);
        event.dataTransfer.setDragImage(dragImage, 0, 0);
      }
      cloneWrapper.classList.add(...cloneWrapperClasses);
      const inSlotClass = style_module_default10["is-in-compat-slot"];
      if (compatSlot && inSlotClass) {
        cloneWrapper.classList.add(inSlotClass);
      }
      if (cloneClassname) {
        cloneWrapper.classList.add(cloneClassname);
      }
      let x2 = 0;
      let y3 = 0;
      if (dragComponentRef.current) {
        x2 = event.clientX;
        y3 = event.clientY;
        cloneWrapper.style.transform = `translate( ${x2}px, ${y3}px )`;
        const clonedDragComponent = ownerDocument.createElement("div");
        clonedDragComponent.innerHTML = dragComponentRef.current.innerHTML;
        cloneWrapper.appendChild(clonedDragComponent);
        (compatSlot ?? ownerDocument.body).appendChild(cloneWrapper);
      } else {
        const element = ownerDocument.getElementById(elementId);
        const elementRect = element.getBoundingClientRect();
        const elementWrapper = element.parentNode;
        const elementTopOffset = elementRect.top;
        const elementLeftOffset = elementRect.left;
        cloneWrapper.style.width = `${elementRect.width + clonePadding * 2}px`;
        const clone = element.cloneNode(true);
        clone.id = `clone-${elementId}`;
        x2 = elementLeftOffset - clonePadding;
        y3 = elementTopOffset - clonePadding;
        cloneWrapper.style.transform = `translate( ${x2}px, ${y3}px )`;
        Array.from(clone.querySelectorAll("iframe")).forEach((child) => child.parentNode?.removeChild(child));
        cloneWrapper.appendChild(clone);
        if (compatSlot) {
          compatSlot.appendChild(cloneWrapper);
        } else if (appendToOwnerDocument) {
          ownerDocument.body.appendChild(cloneWrapper);
        } else {
          elementWrapper?.appendChild(cloneWrapper);
        }
      }
      let cursorLeft = event.clientX;
      let cursorTop = event.clientY;
      function over(e3) {
        if (cursorLeft === e3.clientX && cursorTop === e3.clientY) {
          return;
        }
        const nextX = x2 + e3.clientX - cursorLeft;
        const nextY = y3 + e3.clientY - cursorTop;
        cloneWrapper.style.transform = `translate( ${nextX}px, ${nextY}px )`;
        cursorLeft = e3.clientX;
        cursorTop = e3.clientY;
        x2 = nextX;
        y3 = nextY;
        if (onDragOver) {
          onDragOver(e3);
        }
      }
      const throttledDragOver = (0, import_compose52.throttle)(over, 16);
      ownerDocument.addEventListener("dragover", throttledDragOver);
      ownerDocument.body.classList.add(bodyClass);
      if (onDragStart) {
        onDragStart(event);
      }
      cleanupRef.current = () => {
        if (cloneWrapper && cloneWrapper.parentNode) {
          cloneWrapper.parentNode.removeChild(cloneWrapper);
        }
        if (dragImage && dragImage.parentNode) {
          dragImage.parentNode.removeChild(dragImage);
        }
        ownerDocument.body.classList.remove(bodyClass);
        ownerDocument.removeEventListener("dragover", throttledDragOver);
      };
    }
    (0, import_element132.useEffect)(() => () => {
      cleanupRef.current();
    }, []);
    return /* @__PURE__ */ (0, import_jsx_runtime200.jsxs)(import_jsx_runtime200.Fragment, {
      children: [children({
        onDraggableStart: start,
        onDraggableEnd: end
      }), dragComponent && /* @__PURE__ */ (0, import_jsx_runtime200.jsx)("div", {
        className: "components-draggable-drag-component-root",
        style: {
          display: "none"
        },
        ref: dragComponentRef,
        children: dragComponent
      })]
    });
  }
  var draggable_default = Draggable;

  // packages/components/build-module/drop-zone/index.mjs
  var import_i18n46 = __toESM(require_i18n(), 1);
  var import_element133 = __toESM(require_element(), 1);
  var import_dom7 = __toESM(require_dom(), 1);
  var import_compose53 = __toESM(require_compose(), 1);
  var import_jsx_runtime201 = __toESM(require_jsx_runtime(), 1);
  function DropZoneComponent({
    className: className2,
    icon = upload_default,
    label,
    onFilesDrop,
    onHTMLDrop,
    onDrop,
    isEligible = () => true,
    ...restProps
  }) {
    const [isDraggingOverDocument, setIsDraggingOverDocument] = (0, import_element133.useState)();
    const [isDraggingOverElement, setIsDraggingOverElement] = (0, import_element133.useState)();
    const [isActive, setIsActive] = (0, import_element133.useState)();
    const ref = (0, import_compose53.__experimentalUseDropZone)({
      onDrop(event) {
        if (!event.dataTransfer) {
          return;
        }
        const files = (0, import_dom7.getFilesFromDataTransfer)(event.dataTransfer);
        const html = event.dataTransfer.getData("text/html");
        if (html && onHTMLDrop) {
          onHTMLDrop(html);
        } else if (files.length && onFilesDrop) {
          onFilesDrop(files);
        } else if (onDrop) {
          onDrop(event);
        }
      },
      onDragStart(event) {
        setIsDraggingOverDocument(true);
        if (!event.dataTransfer) {
          return;
        }
        if (event.dataTransfer.types.includes("text/html")) {
          setIsActive(!!onHTMLDrop);
        } else if (
          // Check for the types because sometimes the files themselves
          // are only available on drop.
          event.dataTransfer.types.includes("Files") || (0, import_dom7.getFilesFromDataTransfer)(event.dataTransfer).length > 0
        ) {
          setIsActive(!!onFilesDrop);
        } else {
          setIsActive(!!onDrop && isEligible(event.dataTransfer));
        }
      },
      onDragEnd() {
        setIsDraggingOverElement(false);
        setIsDraggingOverDocument(false);
        setIsActive(void 0);
      },
      onDragEnter() {
        setIsDraggingOverElement(true);
      },
      onDragLeave() {
        setIsDraggingOverElement(false);
      }
    });
    const classes = clsx_default("components-drop-zone", className2, {
      "is-active": isActive,
      "is-dragging-over-document": isDraggingOverDocument,
      "is-dragging-over-element": isDraggingOverElement
    });
    return /* @__PURE__ */ (0, import_jsx_runtime201.jsx)("div", {
      ...restProps,
      ref,
      className: classes,
      children: /* @__PURE__ */ (0, import_jsx_runtime201.jsx)("div", {
        className: "components-drop-zone__content",
        children: /* @__PURE__ */ (0, import_jsx_runtime201.jsxs)("div", {
          className: "components-drop-zone__content-inner",
          children: [/* @__PURE__ */ (0, import_jsx_runtime201.jsx)(icon_default2, {
            icon,
            className: "components-drop-zone__content-icon"
          }), /* @__PURE__ */ (0, import_jsx_runtime201.jsx)("span", {
            className: "components-drop-zone__content-text",
            children: label ? label : (0, import_i18n46.__)("Drop files to upload")
          })]
        })
      })
    });
  }
  var drop_zone_default = DropZoneComponent;

  // packages/components/build-module/drop-zone/provider.mjs
  var import_deprecated13 = __toESM(require_deprecated(), 1);
  function DropZoneProvider({
    children
  }) {
    (0, import_deprecated13.default)("wp.components.DropZoneProvider", {
      since: "5.8",
      hint: "wp.component.DropZone no longer needs a provider. wp.components.DropZoneProvider is safe to remove from your code."
    });
    return children;
  }

  // packages/components/build-module/duotone-picker/duotone-picker.mjs
  var import_es62 = __toESM(require_es6(), 1);
  var import_element135 = __toESM(require_element(), 1);
  var import_i18n48 = __toESM(require_i18n(), 1);

  // packages/components/build-module/duotone-picker/color-list-picker/index.mjs
  var import_element134 = __toESM(require_element(), 1);
  var import_i18n47 = __toESM(require_i18n(), 1);
  var import_compose54 = __toESM(require_compose(), 1);
  var import_jsx_runtime202 = __toESM(require_jsx_runtime(), 1);
  function ColorOption({
    label,
    value,
    colors,
    disableCustomColors,
    enableAlpha,
    onChange
  }) {
    const [isOpen, setIsOpen] = (0, import_element134.useState)(false);
    const idRoot = (0, import_compose54.useInstanceId)(ColorOption, "color-list-picker-option");
    const labelId = `${idRoot}__label`;
    const contentId = `${idRoot}__content`;
    return /* @__PURE__ */ (0, import_jsx_runtime202.jsxs)(import_jsx_runtime202.Fragment, {
      children: [/* @__PURE__ */ (0, import_jsx_runtime202.jsx)(button_default, {
        __next40pxDefaultSize: true,
        className: "components-color-list-picker__swatch-button",
        id: labelId,
        onClick: () => setIsOpen((prev2) => !prev2),
        "aria-expanded": isOpen,
        "aria-controls": contentId,
        icon: value ? /* @__PURE__ */ (0, import_jsx_runtime202.jsx)(color_indicator_default, {
          colorValue: value,
          className: "components-color-list-picker__swatch-color"
        }) : /* @__PURE__ */ (0, import_jsx_runtime202.jsx)(icon_default3, {
          icon: swatch_default
        }),
        text: label
      }), /* @__PURE__ */ (0, import_jsx_runtime202.jsx)("div", {
        role: "group",
        id: contentId,
        "aria-labelledby": labelId,
        "aria-hidden": !isOpen,
        children: isOpen && /* @__PURE__ */ (0, import_jsx_runtime202.jsx)(color_palette_default, {
          "aria-label": (0, import_i18n47.__)("Color options"),
          className: "components-color-list-picker__color-picker",
          colors,
          value,
          clearable: false,
          onChange,
          disableCustomColors,
          enableAlpha
        })
      })]
    });
  }
  function ColorListPicker({
    colors,
    labels,
    value = [],
    disableCustomColors,
    enableAlpha,
    onChange
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime202.jsx)("div", {
      className: "components-color-list-picker",
      children: labels.map((label, index2) => /* @__PURE__ */ (0, import_jsx_runtime202.jsx)(ColorOption, {
        label,
        value: value[index2],
        colors,
        disableCustomColors,
        enableAlpha,
        onChange: (newColor) => {
          const newColors = value.slice();
          newColors[index2] = newColor;
          onChange(newColors);
        }
      }, index2))
    });
  }
  var color_list_picker_default = ColorListPicker;

  // packages/components/build-module/duotone-picker/utils.mjs
  k([names_default]);
  function getDefaultColors(palette) {
    if (!palette || palette.length < 2) {
      return ["#000", "#fff"];
    }
    return palette.map(({
      color: color2
    }) => ({
      color: color2,
      brightness: w(color2).brightness()
    })).reduce(([min3, max3], current) => {
      return [current.brightness <= min3.brightness ? current : min3, current.brightness >= max3.brightness ? current : max3];
    }, [{
      brightness: 1,
      color: ""
    }, {
      brightness: 0,
      color: ""
    }]).map(({
      color: color2
    }) => color2);
  }
  function getGradientFromCSSColors(colors = [], angle = "90deg") {
    const l3 = 100 / colors.length;
    const stops = colors.map((c3, i3) => `${c3} ${i3 * l3}%, ${c3} ${(i3 + 1) * l3}%`).join(", ");
    return `linear-gradient( ${angle}, ${stops} )`;
  }
  function getColorStopsFromColors(colors) {
    return colors.map((color2, i3) => ({
      position: i3 * 100 / (colors.length - 1),
      color: color2
    }));
  }
  function getColorsFromColorStops(colorStops = []) {
    return colorStops.map(({
      color: color2
    }) => color2);
  }

  // packages/components/build-module/duotone-picker/custom-duotone-bar.mjs
  var import_jsx_runtime203 = __toESM(require_jsx_runtime(), 1);
  var PLACEHOLDER_VALUES = ["#333", "#CCC"];
  function CustomDuotoneBar({
    value,
    onChange
  }) {
    const hasGradient = !!value;
    const values = hasGradient ? value : PLACEHOLDER_VALUES;
    const background = getGradientFromCSSColors(values);
    const controlPoints = getColorStopsFromColors(values);
    return /* @__PURE__ */ (0, import_jsx_runtime203.jsx)(CustomGradientBar, {
      disableInserter: true,
      background,
      hasGradient,
      value: controlPoints,
      onChange: (newColorStops) => {
        const newValue = getColorsFromColorStops(newColorStops);
        onChange(newValue);
      }
    });
  }

  // packages/components/build-module/duotone-picker/duotone-picker.mjs
  var import_jsx_runtime204 = __toESM(require_jsx_runtime(), 1);
  function DuotonePicker({
    asButtons,
    loop,
    clearable = true,
    unsetable = true,
    colorPalette,
    duotonePalette,
    disableCustomColors,
    disableCustomDuotone,
    value,
    onChange,
    "aria-label": ariaLabel,
    "aria-labelledby": ariaLabelledby,
    ...otherProps
  }) {
    const [defaultDark, defaultLight] = (0, import_element135.useMemo)(() => getDefaultColors(colorPalette), [colorPalette]);
    const isUnset = value === "unset";
    const unsetOptionLabel = (0, import_i18n48.__)("Unset");
    const unsetOption = /* @__PURE__ */ (0, import_jsx_runtime204.jsx)(circular_option_picker_default2.Option, {
      value: "unset",
      isSelected: isUnset,
      tooltipText: unsetOptionLabel,
      "aria-label": unsetOptionLabel,
      className: "components-duotone-picker__color-indicator",
      onClick: () => {
        onChange(isUnset ? void 0 : "unset");
      }
    }, "unset");
    const duotoneOptions = duotonePalette.map(({
      colors,
      slug,
      name
    }) => {
      const style2 = {
        background: getGradientFromCSSColors(colors, "135deg"),
        color: "transparent"
      };
      const tooltipText = name ?? (0, import_i18n48.sprintf)(
        // translators: %s: duotone code e.g: "dark-grayscale" or "7f7f7f-ffffff".
        (0, import_i18n48.__)("Duotone code: %s"),
        slug
      );
      const label = name ? (0, import_i18n48.sprintf)(
        // translators: %s: The name of the option e.g: "Dark grayscale".
        (0, import_i18n48.__)("Duotone: %s"),
        name
      ) : tooltipText;
      const isSelected2 = (0, import_es62.default)(colors, value);
      return /* @__PURE__ */ (0, import_jsx_runtime204.jsx)(circular_option_picker_default2.Option, {
        value: colors,
        isSelected: isSelected2,
        "aria-label": label,
        tooltipText,
        style: style2,
        onClick: () => {
          onChange(isSelected2 ? void 0 : colors);
        }
      }, slug);
    });
    const {
      metaProps,
      labelProps
    } = getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby);
    const options2 = unsetable ? [unsetOption, ...duotoneOptions] : duotoneOptions;
    return /* @__PURE__ */ (0, import_jsx_runtime204.jsx)(circular_option_picker_default2, {
      ...otherProps,
      ...metaProps,
      ...labelProps,
      options: options2,
      actions: !!clearable && /* @__PURE__ */ (0, import_jsx_runtime204.jsx)(circular_option_picker_default2.ButtonAction, {
        onClick: () => onChange(void 0),
        accessibleWhenDisabled: true,
        disabled: !value,
        children: (0, import_i18n48.__)("Clear")
      }),
      children: /* @__PURE__ */ (0, import_jsx_runtime204.jsx)(component_default6, {
        paddingTop: options2.length === 0 ? 0 : 4,
        children: /* @__PURE__ */ (0, import_jsx_runtime204.jsxs)(component_default18, {
          spacing: 3,
          children: [!disableCustomColors && !disableCustomDuotone && /* @__PURE__ */ (0, import_jsx_runtime204.jsx)(CustomDuotoneBar, {
            value: isUnset ? void 0 : value,
            onChange
          }), !disableCustomDuotone && /* @__PURE__ */ (0, import_jsx_runtime204.jsx)(color_list_picker_default, {
            labels: [(0, import_i18n48.__)("Shadows"), (0, import_i18n48.__)("Highlights")],
            colors: colorPalette,
            value: isUnset ? void 0 : value,
            disableCustomColors,
            enableAlpha: true,
            onChange: (newColors) => {
              if (!newColors[0]) {
                newColors[0] = defaultDark;
              }
              if (!newColors[1]) {
                newColors[1] = defaultLight;
              }
              const newValue = newColors.length >= 2 ? newColors : void 0;
              onChange(newValue);
            }
          })]
        })
      })
    });
  }
  var duotone_picker_default = DuotonePicker;

  // packages/components/build-module/duotone-picker/duotone-swatch.mjs
  var import_jsx_runtime205 = __toESM(require_jsx_runtime(), 1);
  function DuotoneSwatch({
    values
  }) {
    return values ? /* @__PURE__ */ (0, import_jsx_runtime205.jsx)(color_indicator_default, {
      colorValue: getGradientFromCSSColors(values, "135deg")
    }) : /* @__PURE__ */ (0, import_jsx_runtime205.jsx)(icon_default3, {
      icon: swatch_default
    });
  }
  var duotone_swatch_default = DuotoneSwatch;

  // packages/components/build-module/external-link/index.mjs
  var import_i18n49 = __toESM(require_i18n(), 1);
  var import_element136 = __toESM(require_element(), 1);
  var import_jsx_runtime206 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedExternalLink(props, ref) {
    const {
      href,
      children,
      className: className2,
      ...additionalProps
    } = props;
    const classes = clsx_default("components-external-link", className2);
    const isInternalAnchor = !!href?.startsWith("#");
    const onClickHandler = (event) => {
      if (isInternalAnchor) {
        event.preventDefault();
      }
      if (props.onClick) {
        props.onClick(event);
      }
    };
    return (
      /* eslint-disable react/jsx-no-target-blank */
      /* @__PURE__ */ (0, import_jsx_runtime206.jsxs)("a", {
        ...additionalProps,
        className: classes,
        href,
        onClick: onClickHandler,
        target: "_blank",
        ref,
        children: [/* @__PURE__ */ (0, import_jsx_runtime206.jsx)("span", {
          className: "components-external-link__contents",
          children
        }), /* @__PURE__ */ (0, import_jsx_runtime206.jsx)("span", {
          className: clsx_default(
            "components-external-link__icon",
            // This class prevents the arrow from being replaced by a Twemoji image.
            "wp-exclude-emoji"
          ),
          "aria-label": (
            /* translators: accessibility text */
            (0, import_i18n49.__)("(opens in a new tab)")
          ),
          children: (0, import_i18n49.isRTL)() ? "\u2196" : "\u2197"
        })]
      })
    );
  }
  var ExternalLink = (0, import_element136.forwardRef)(UnforwardedExternalLink);
  ExternalLink.displayName = "ExternalLink";
  var external_link_default = ExternalLink;

  // packages/components/build-module/focal-point-picker/index.mjs
  var import_i18n51 = __toESM(require_i18n(), 1);
  var import_element137 = __toESM(require_element(), 1);
  var import_compose55 = __toESM(require_compose(), 1);

  // packages/components/build-module/focal-point-picker/controls.mjs
  var import_i18n50 = __toESM(require_i18n(), 1);

  // packages/components/build-module/focal-point-picker/utils.mjs
  var INITIAL_BOUNDS = {
    width: 200,
    height: 170
  };
  var VIDEO_EXTENSIONS = ["avi", "mpg", "mpeg", "mov", "mp4", "m4v", "ogg", "ogv", "webm", "wmv"];
  function getExtension(filename = "") {
    const parts = filename.split(".");
    return parts[parts.length - 1];
  }
  function isVideoType(filename = "") {
    if (!filename) {
      return false;
    }
    return filename.startsWith("data:video/") || VIDEO_EXTENSIONS.includes(getExtension(filename));
  }
  function fractionToPercentage(fraction) {
    return Math.round(fraction * 100);
  }

  // packages/components/build-module/focal-point-picker/styles/focal-point-picker-style.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__29() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Container2 = /* @__PURE__ */ createStyled(component_default, false ? {
    target: "eeew7dm9"
  } : {
    target: "eeew7dm9",
    label: "Container"
  })("border:0;padding:0;margin:0;font-family:", font("default.fontFamily"), ";font-size:", font("default.fontSize"), ";", boxSizingReset, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var MediaWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "eeew7dm8"
  } : {
    target: "eeew7dm8",
    label: "MediaWrapper"
  })(false ? {
    name: "jqnsxy",
    styles: "background-color:transparent;display:flex;text-align:center;width:100%"
  } : {
    name: "jqnsxy",
    styles: "background-color:transparent;display:flex;text-align:center;width:100%/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__29
  });
  var MediaContainer = /* @__PURE__ */ createStyled("div", false ? {
    target: "eeew7dm7"
  } : {
    target: "eeew7dm7",
    label: "MediaContainer"
  })("align-items:center;border-radius:", config_values_default.radiusSmall, ";cursor:pointer;display:inline-flex;justify-content:center;margin:auto;position:relative;height:100%;&:after{border-radius:inherit;bottom:0;box-shadow:inset 0 0 0 1px rgba( 0, 0, 0, 0.1 );content:'';left:0;pointer-events:none;position:absolute;right:0;top:0;}img,video{border-radius:inherit;box-sizing:border-box;display:block;height:auto;margin:0;max-height:100%;max-width:100%;pointer-events:none;user-select:none;width:100%;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var MediaPlaceholder = /* @__PURE__ */ createStyled("div", false ? {
    target: "eeew7dm6"
  } : {
    target: "eeew7dm6",
    label: "MediaPlaceholder"
  })("background:", COLORS.gray[100], ";border-radius:inherit;box-sizing:border-box;height:", INITIAL_BOUNDS.height, "px;max-width:280px;min-width:", INITIAL_BOUNDS.width, "px;width:100%;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var StyledUnitControl2 = /* @__PURE__ */ createStyled(unit_control_default, false ? {
    target: "eeew7dm5"
  } : {
    target: "eeew7dm5",
    label: "StyledUnitControl"
  })(false ? {
    name: "1d3w5wq",
    styles: "width:100%"
  } : {
    name: "1d3w5wq",
    styles: "width:100%/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__29
  });
  var _ref6 = false ? {
    name: "1mn7kwb",
    styles: "padding-bottom:1em"
  } : {
    name: "ho4pgl-extraHelpTextMargin",
    styles: "padding-bottom:1em;label:extraHelpTextMargin;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__29
  };
  var extraHelpTextMargin = ({
    hasHelpText = false
  }) => {
    return hasHelpText ? _ref6 : void 0;
  };
  var ControlWrapper = /* @__PURE__ */ createStyled(component_default3, false ? {
    target: "eeew7dm4"
  } : {
    target: "eeew7dm4",
    label: "ControlWrapper"
  })("max-width:320px;padding-top:1em;", extraHelpTextMargin, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var GridView = /* @__PURE__ */ createStyled("div", false ? {
    target: "eeew7dm3"
  } : {
    target: "eeew7dm3",
    label: "GridView"
  })("left:50%;overflow:hidden;pointer-events:none;position:absolute;top:50%;transform:translate3d( -50%, -50%, 0 );z-index:1;@media not ( prefers-reduced-motion ){transition:opacity 100ms linear;}opacity:", ({
    showOverlay
  }) => showOverlay ? 1 : 0, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var GridLine = /* @__PURE__ */ createStyled("div", false ? {
    target: "eeew7dm2"
  } : {
    target: "eeew7dm2",
    label: "GridLine"
  })(false ? {
    name: "1yzbo24",
    styles: "background:rgba( 255, 255, 255, 0.4 );backdrop-filter:blur( 16px ) saturate( 180% );position:absolute;transform:translateZ( 0 )"
  } : {
    name: "1yzbo24",
    styles: "background:rgba( 255, 255, 255, 0.4 );backdrop-filter:blur( 16px ) saturate( 180% );position:absolute;transform:translateZ( 0 )/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__29
  });
  var GridLineX = /* @__PURE__ */ createStyled(GridLine, false ? {
    target: "eeew7dm1"
  } : {
    target: "eeew7dm1",
    label: "GridLineX"
  })(false ? {
    name: "1sw8ur",
    styles: "height:1px;left:1px;right:1px"
  } : {
    name: "1sw8ur",
    styles: "height:1px;left:1px;right:1px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__29
  });
  var GridLineY = /* @__PURE__ */ createStyled(GridLine, false ? {
    target: "eeew7dm0"
  } : {
    target: "eeew7dm0",
    label: "GridLineY"
  })(false ? {
    name: "188vg4t",
    styles: "width:1px;top:1px;bottom:1px"
  } : {
    name: "188vg4t",
    styles: "width:1px;top:1px;bottom:1px/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__29
  });

  // packages/components/build-module/focal-point-picker/controls.mjs
  var import_jsx_runtime207 = __toESM(require_jsx_runtime(), 1);
  var TEXTCONTROL_MIN = 0;
  var TEXTCONTROL_MAX = 100;
  var noop15 = () => {
  };
  function FocalPointPickerControls({
    hasHelpText,
    onChange = noop15,
    point = {
      x: 0.5,
      y: 0.5
    }
  }) {
    const valueX = fractionToPercentage(point.x);
    const valueY = fractionToPercentage(point.y);
    const handleChange = (value, axis) => {
      if (value === void 0) {
        return;
      }
      const num = parseInt(value, 10);
      if (!isNaN(num)) {
        onChange({
          ...point,
          [axis]: num / 100
        });
      }
    };
    return /* @__PURE__ */ (0, import_jsx_runtime207.jsxs)(ControlWrapper, {
      className: "focal-point-picker__controls",
      hasHelpText,
      gap: 4,
      children: [/* @__PURE__ */ (0, import_jsx_runtime207.jsx)(FocalPointUnitControl, {
        label: (0, import_i18n50.__)("Left"),
        "aria-label": (0, import_i18n50.__)("Focal point left position"),
        value: [valueX, "%"].join(""),
        onChange: (next2) => handleChange(next2, "x"),
        dragDirection: "e"
      }), /* @__PURE__ */ (0, import_jsx_runtime207.jsx)(FocalPointUnitControl, {
        label: (0, import_i18n50.__)("Top"),
        "aria-label": (0, import_i18n50.__)("Focal point top position"),
        value: [valueY, "%"].join(""),
        onChange: (next2) => handleChange(next2, "y"),
        dragDirection: "s"
      })]
    });
  }
  function FocalPointUnitControl(props) {
    return /* @__PURE__ */ (0, import_jsx_runtime207.jsx)(StyledUnitControl2, {
      className: "focal-point-picker__controls-position-unit-control",
      labelPosition: "top",
      max: TEXTCONTROL_MAX,
      min: TEXTCONTROL_MIN,
      units: [{
        value: "%",
        label: "%"
      }],
      ...props
    });
  }

  // packages/components/build-module/focal-point-picker/styles/focal-point-style.mjs
  var PointerCircle = /* @__PURE__ */ createStyled("div", false ? {
    target: "e19snlhg0"
  } : {
    target: "e19snlhg0",
    label: "PointerCircle"
  })("background-color:transparent;cursor:grab;height:40px;margin:-20px 0 0 -20px;position:absolute;user-select:none;width:40px;will-change:transform;z-index:10000;background:rgba( 255, 255, 255, 0.4 );border:1px solid rgba( 255, 255, 255, 0.4 );border-radius:", config_values_default.radiusRound, ";backdrop-filter:blur( 16px ) saturate( 180% );box-shadow:rgb( 0 0 0 / 10% ) 0px 0px 8px;@media not ( prefers-reduced-motion ){transition:transform 100ms linear;}", ({
    isDragging: isDragging2
  }) => isDragging2 && `
			box-shadow: rgb( 0 0 0 / 12% ) 0px 0px 10px;
			transform: scale( 1.1 );
			cursor: grabbing;
			`, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZvY2FsLXBvaW50LXN0eWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVV1QyIsImZpbGUiOiJmb2NhbC1wb2ludC1zdHlsZS50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgQ09ORklHIH0gZnJvbSAnLi4vLi4vdXRpbHMnO1xuXG5leHBvcnQgY29uc3QgUG9pbnRlckNpcmNsZSA9IHN0eWxlZC5kaXZgXG5cdGJhY2tncm91bmQtY29sb3I6IHRyYW5zcGFyZW50O1xuXHRjdXJzb3I6IGdyYWI7XG5cdGhlaWdodDogNDBweDtcblx0bWFyZ2luOiAtMjBweCAwIDAgLTIwcHg7XG5cdHBvc2l0aW9uOiBhYnNvbHV0ZTtcblx0dXNlci1zZWxlY3Q6IG5vbmU7XG5cdHdpZHRoOiA0MHB4O1xuXHR3aWxsLWNoYW5nZTogdHJhbnNmb3JtO1xuXHR6LWluZGV4OiAxMDAwMDtcblx0YmFja2dyb3VuZDogcmdiYSggMjU1LCAyNTUsIDI1NSwgMC40ICk7XG5cdGJvcmRlcjogMXB4IHNvbGlkIHJnYmEoIDI1NSwgMjU1LCAyNTUsIDAuNCApO1xuXHRib3JkZXItcmFkaXVzOiAkeyBDT05GSUcucmFkaXVzUm91bmQgfTtcblx0YmFja2Ryb3AtZmlsdGVyOiBibHVyKCAxNnB4ICkgc2F0dXJhdGUoIDE4MCUgKTtcblx0Ym94LXNoYWRvdzogcmdiKCAwIDAgMCAvIDEwJSApIDBweCAwcHggOHB4O1xuXG5cdEBtZWRpYSBub3QgKCBwcmVmZXJzLXJlZHVjZWQtbW90aW9uICkge1xuXHRcdHRyYW5zaXRpb246IHRyYW5zZm9ybSAxMDBtcyBsaW5lYXI7XG5cdH1cblxuXHQkeyAoIHsgaXNEcmFnZ2luZyB9OiB7IGlzRHJhZ2dpbmc6IGJvb2xlYW4gfSApID0+XG5cdFx0aXNEcmFnZ2luZyAmJlxuXHRcdGBcblx0XHRcdGJveC1zaGFkb3c6IHJnYiggMCAwIDAgLyAxMiUgKSAwcHggMHB4IDEwcHg7XG5cdFx0XHR0cmFuc2Zvcm06IHNjYWxlKCAxLjEgKTtcblx0XHRcdGN1cnNvcjogZ3JhYmJpbmc7XG5cdFx0XHRgIH1cbmA7XG4iXX0= */"));

  // packages/components/build-module/focal-point-picker/focal-point.mjs
  var import_jsx_runtime208 = __toESM(require_jsx_runtime(), 1);
  function FocalPoint({
    left = "50%",
    top = "50%",
    ...props
  }) {
    const style2 = {
      left,
      top
    };
    return /* @__PURE__ */ (0, import_jsx_runtime208.jsx)(PointerCircle, {
      ...props,
      className: "components-focal-point-picker__icon_container",
      style: style2
    });
  }

  // packages/components/build-module/focal-point-picker/grid.mjs
  var import_jsx_runtime209 = __toESM(require_jsx_runtime(), 1);
  function FocalPointPickerGrid({
    bounds,
    ...props
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime209.jsxs)(GridView, {
      ...props,
      className: "components-focal-point-picker__grid",
      style: {
        width: bounds.width,
        height: bounds.height
      },
      children: [/* @__PURE__ */ (0, import_jsx_runtime209.jsx)(GridLineX, {
        style: {
          top: "33%"
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime209.jsx)(GridLineX, {
        style: {
          top: "66%"
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime209.jsx)(GridLineY, {
        style: {
          left: "33%"
        }
      }), /* @__PURE__ */ (0, import_jsx_runtime209.jsx)(GridLineY, {
        style: {
          left: "66%"
        }
      })]
    });
  }

  // packages/components/build-module/focal-point-picker/media.mjs
  var import_jsx_runtime210 = __toESM(require_jsx_runtime(), 1);
  function Media2({
    alt,
    autoPlay,
    src,
    onLoad,
    mediaRef,
    // Exposing muted prop for test rendering purposes
    // https://github.com/testing-library/react-testing-library/issues/470
    muted: muted2 = true,
    ...props
  }) {
    if (!src) {
      return /* @__PURE__ */ (0, import_jsx_runtime210.jsx)(MediaPlaceholder, {
        className: "components-focal-point-picker__media components-focal-point-picker__media--placeholder",
        ref: mediaRef,
        ...props
      });
    }
    const isVideo = isVideoType(src);
    return isVideo ? /* @__PURE__ */ (0, import_jsx_runtime210.jsx)("video", {
      ...props,
      autoPlay,
      className: "components-focal-point-picker__media components-focal-point-picker__media--video",
      loop: true,
      muted: muted2,
      onLoadedData: onLoad,
      ref: mediaRef,
      src
    }) : /* @__PURE__ */ (0, import_jsx_runtime210.jsx)("img", {
      ...props,
      alt,
      className: "components-focal-point-picker__media components-focal-point-picker__media--image",
      onLoad,
      ref: mediaRef,
      src
    });
  }

  // packages/components/build-module/focal-point-picker/index.mjs
  var import_jsx_runtime211 = __toESM(require_jsx_runtime(), 1);
  var GRID_OVERLAY_TIMEOUT = 600;
  function FocalPointPicker({
    // Prevent passing to internal component.
    __nextHasNoMarginBottom: _2,
    __next40pxDefaultSize: _next40pxDefaultSize,
    autoPlay = true,
    className: className2,
    help,
    hideLabelFromVision,
    label,
    onChange,
    onDrag,
    onDragEnd,
    onDragStart,
    resolvePoint,
    url,
    value: valueProp = {
      x: 0.5,
      y: 0.5
    },
    ...restProps
  }) {
    const [point, setPoint] = (0, import_element137.useState)(valueProp);
    const [showGridOverlay, setShowGridOverlay] = (0, import_element137.useState)(false);
    const {
      startDrag,
      endDrag,
      isDragging: isDragging2
    } = (0, import_compose55.__experimentalUseDragging)({
      onDragStart: (event) => {
        dragAreaRef.current?.focus();
        const value = getValueWithinDragArea(event);
        if (!value) {
          return;
        }
        onDragStart?.(value, event);
        setPoint(value);
      },
      onDragMove: (event) => {
        event.preventDefault();
        const value = getValueWithinDragArea(event);
        if (!value) {
          return;
        }
        onDrag?.(value, event);
        setPoint(value);
      },
      onDragEnd: () => {
        onDragEnd?.();
        onChange?.(point);
      }
    });
    const {
      x: x2,
      y: y3
    } = isDragging2 ? point : valueProp;
    const dragAreaRef = (0, import_element137.useRef)(null);
    const [bounds, setBounds] = (0, import_element137.useState)(INITIAL_BOUNDS);
    const refUpdateBounds = (0, import_element137.useRef)(() => {
      if (!dragAreaRef.current) {
        return;
      }
      const {
        clientWidth: width,
        clientHeight: height
      } = dragAreaRef.current;
      setBounds(width > 0 && height > 0 ? {
        width,
        height
      } : {
        ...INITIAL_BOUNDS
      });
    });
    (0, import_element137.useEffect)(() => {
      const updateBounds = refUpdateBounds.current;
      if (!dragAreaRef.current) {
        return;
      }
      const {
        defaultView
      } = dragAreaRef.current.ownerDocument;
      defaultView?.addEventListener("resize", updateBounds);
      return () => defaultView?.removeEventListener("resize", updateBounds);
    }, []);
    (0, import_compose55.useIsomorphicLayoutEffect)(() => void refUpdateBounds.current(), []);
    const getValueWithinDragArea = ({
      clientX,
      clientY,
      shiftKey
    }) => {
      if (!dragAreaRef.current) {
        return;
      }
      const {
        top,
        left
      } = dragAreaRef.current.getBoundingClientRect();
      let nextX = (clientX - left) / bounds.width;
      let nextY = (clientY - top) / bounds.height;
      if (shiftKey) {
        nextX = Math.round(nextX / 0.1) * 0.1;
        nextY = Math.round(nextY / 0.1) * 0.1;
      }
      return getFinalValue({
        x: nextX,
        y: nextY
      });
    };
    const getFinalValue = (value) => {
      const resolvedValue = resolvePoint?.(value) ?? value;
      resolvedValue.x = Math.max(0, Math.min(resolvedValue.x, 1));
      resolvedValue.y = Math.max(0, Math.min(resolvedValue.y, 1));
      const roundToTwoDecimalPlaces = (n3) => Math.round(n3 * 100) / 100;
      return {
        x: roundToTwoDecimalPlaces(resolvedValue.x),
        y: roundToTwoDecimalPlaces(resolvedValue.y)
      };
    };
    const arrowKeyStep = (event) => {
      const {
        code,
        shiftKey
      } = event;
      if (!["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(code)) {
        return;
      }
      event.preventDefault();
      const value = {
        x: x2,
        y: y3
      };
      const step = shiftKey ? 0.1 : 0.01;
      const delta = code === "ArrowUp" || code === "ArrowLeft" ? -1 * step : step;
      const axis = code === "ArrowUp" || code === "ArrowDown" ? "y" : "x";
      value[axis] = value[axis] + delta;
      onChange?.(getFinalValue(value));
    };
    const focalPointPosition = {
      left: x2 !== void 0 ? x2 * bounds.width : 0.5 * bounds.width,
      top: y3 !== void 0 ? y3 * bounds.height : 0.5 * bounds.height
    };
    const classes = clsx_default("components-focal-point-picker-control", className2);
    const Label4 = hideLabelFromVision ? component_default2 : StyledLabel;
    use_update_effect_default(() => {
      setShowGridOverlay(true);
      const timeout = window.setTimeout(() => {
        setShowGridOverlay(false);
      }, GRID_OVERLAY_TIMEOUT);
      return () => window.clearTimeout(timeout);
    }, [x2, y3]);
    return /* @__PURE__ */ (0, import_jsx_runtime211.jsxs)(Container2, {
      ...restProps,
      as: "fieldset",
      className: classes,
      children: [!!label && /* @__PURE__ */ (0, import_jsx_runtime211.jsx)(Label4, {
        as: "legend",
        children: label
      }), /* @__PURE__ */ (0, import_jsx_runtime211.jsx)(MediaWrapper, {
        className: "components-focal-point-picker-wrapper",
        children: /* @__PURE__ */ (0, import_jsx_runtime211.jsxs)(MediaContainer, {
          className: "components-focal-point-picker",
          onKeyDown: arrowKeyStep,
          onMouseDown: startDrag,
          onBlur: () => {
            if (isDragging2) {
              endDrag();
            }
          },
          ref: dragAreaRef,
          role: "button",
          tabIndex: -1,
          children: [/* @__PURE__ */ (0, import_jsx_runtime211.jsx)(FocalPointPickerGrid, {
            bounds,
            showOverlay: showGridOverlay
          }), /* @__PURE__ */ (0, import_jsx_runtime211.jsx)(Media2, {
            alt: (0, import_i18n51.__)("Media preview"),
            autoPlay,
            onLoad: refUpdateBounds.current,
            src: url
          }), /* @__PURE__ */ (0, import_jsx_runtime211.jsx)(FocalPoint, {
            ...focalPointPosition,
            isDragging: isDragging2
          })]
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime211.jsx)(FocalPointPickerControls, {
        hasHelpText: !!help,
        point: {
          x: x2,
          y: y3
        },
        onChange: (value) => {
          onChange?.(getFinalValue(value));
        }
      }), !!help && /* @__PURE__ */ (0, import_jsx_runtime211.jsx)(StyledHelp, {
        children: help
      })]
    });
  }
  var focal_point_picker_default = FocalPointPicker;

  // packages/components/build-module/focusable-iframe/index.mjs
  var import_compose56 = __toESM(require_compose(), 1);
  var import_deprecated14 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime212 = __toESM(require_jsx_runtime(), 1);
  function FocusableIframe({
    iframeRef,
    ...props
  }) {
    const ref = (0, import_compose56.useMergeRefs)([iframeRef, (0, import_compose56.useFocusableIframe)()]);
    (0, import_deprecated14.default)("wp.components.FocusableIframe", {
      since: "5.9",
      alternative: "wp.compose.useFocusableIframe"
    });
    return /* @__PURE__ */ (0, import_jsx_runtime212.jsx)("iframe", {
      ref,
      ...props
    });
  }

  // packages/components/build-module/font-size-picker/index.mjs
  var import_i18n55 = __toESM(require_i18n(), 1);
  var import_element139 = __toESM(require_element(), 1);
  var import_compose57 = __toESM(require_compose(), 1);

  // packages/components/build-module/font-size-picker/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__30() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Container3 = /* @__PURE__ */ createStyled("fieldset", false ? {
    target: "e8tqeku4"
  } : {
    target: "e8tqeku4",
    label: "Container"
  })(false ? {
    name: "k2q51s",
    styles: "border:0;margin:0;padding:0;display:contents"
  } : {
    name: "k2q51s",
    styles: "border:0;margin:0;padding:0;display:contents/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFjd0MiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgQmFzZUNvbnRyb2wgZnJvbSAnLi4vYmFzZS1jb250cm9sJztcbmltcG9ydCBCdXR0b24gZnJvbSAnLi4vYnV0dG9uJztcbmltcG9ydCBDdXN0b21TZWxlY3RDb250cm9sIGZyb20gJy4uL2N1c3RvbS1zZWxlY3QtY29udHJvbCc7XG5pbXBvcnQgeyBIU3RhY2sgfSBmcm9tICcuLi9oLXN0YWNrJztcbmltcG9ydCB7IHNwYWNlIH0gZnJvbSAnLi4vdXRpbHMvc3BhY2UnO1xuXG5leHBvcnQgY29uc3QgQ29udGFpbmVyID0gc3R5bGVkLmZpZWxkc2V0YFxuXHRib3JkZXI6IDA7XG5cdG1hcmdpbjogMDtcblx0cGFkZGluZzogMDtcblx0ZGlzcGxheTogY29udGVudHM7XG5gO1xuXG5leHBvcnQgY29uc3QgSGVhZGVyID0gc3R5bGVkKCBIU3RhY2sgKWBcblx0aGVpZ2h0OiAkeyBzcGFjZSggNCApIH07XG5gO1xuXG5leHBvcnQgY29uc3QgSGVhZGVyVG9nZ2xlID0gc3R5bGVkKCBCdXR0b24gKWBcblx0bWFyZ2luLXRvcDogJHsgc3BhY2UoIC0xICkgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBIZWFkZXJMYWJlbCA9IHN0eWxlZCggQmFzZUNvbnRyb2wuVmlzdWFsTGFiZWwgKWBcblx0ZGlzcGxheTogZmxleDtcblx0Z2FwOiAkeyBzcGFjZSggMSApIH07XG5cdGp1c3RpZnktY29udGVudDogZmxleC1zdGFydDtcblx0bWFyZ2luLWJvdHRvbTogMDtcbmA7XG5cbi8vIEN1c3RvbSBzdHlsZWQgY29tcG9uZW50IHRvIGZvcmNlIGxpbmUgYnJlYWsgYmV0d2VlbiBuYW1lIGFuZCBoaW50IHdoaWxlIGtlZXBpbmcgY2hlY2ttYXJrIG9uIHRoZSByaWdodFxuZXhwb3J0IGNvbnN0IFN0eWxlZEN1c3RvbVNlbGVjdENvbnRyb2wgPSBzdHlsZWQoIEN1c3RvbVNlbGVjdENvbnRyb2wgKWBcblx0LmNvbXBvbmVudHMtY3VzdG9tLXNlbGVjdC1jb250cm9sX19pdGVtXG5cdFx0LmNvbXBvbmVudHMtY3VzdG9tLXNlbGVjdC1jb250cm9sX19pdGVtLWhpbnQge1xuXHRcdHdpZHRoOiAxMDAlO1xuXHR9XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__30
  });
  var Header2 = /* @__PURE__ */ createStyled(component_default9, false ? {
    target: "e8tqeku3"
  } : {
    target: "e8tqeku3",
    label: "Header"
  })("height:", space(4), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFxQnNDIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IEJhc2VDb250cm9sIGZyb20gJy4uL2Jhc2UtY29udHJvbCc7XG5pbXBvcnQgQnV0dG9uIGZyb20gJy4uL2J1dHRvbic7XG5pbXBvcnQgQ3VzdG9tU2VsZWN0Q29udHJvbCBmcm9tICcuLi9jdXN0b20tc2VsZWN0LWNvbnRyb2wnO1xuaW1wb3J0IHsgSFN0YWNrIH0gZnJvbSAnLi4vaC1zdGFjayc7XG5pbXBvcnQgeyBzcGFjZSB9IGZyb20gJy4uL3V0aWxzL3NwYWNlJztcblxuZXhwb3J0IGNvbnN0IENvbnRhaW5lciA9IHN0eWxlZC5maWVsZHNldGBcblx0Ym9yZGVyOiAwO1xuXHRtYXJnaW46IDA7XG5cdHBhZGRpbmc6IDA7XG5cdGRpc3BsYXk6IGNvbnRlbnRzO1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGhlaWdodDogJHsgc3BhY2UoIDQgKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlclRvZ2dsZSA9IHN0eWxlZCggQnV0dG9uIClgXG5cdG1hcmdpbi10b3A6ICR7IHNwYWNlKCAtMSApIH07XG5gO1xuXG5leHBvcnQgY29uc3QgSGVhZGVyTGFiZWwgPSBzdHlsZWQoIEJhc2VDb250cm9sLlZpc3VhbExhYmVsIClgXG5cdGRpc3BsYXk6IGZsZXg7XG5cdGdhcDogJHsgc3BhY2UoIDEgKSB9O1xuXHRqdXN0aWZ5LWNvbnRlbnQ6IGZsZXgtc3RhcnQ7XG5cdG1hcmdpbi1ib3R0b206IDA7XG5gO1xuXG4vLyBDdXN0b20gc3R5bGVkIGNvbXBvbmVudCB0byBmb3JjZSBsaW5lIGJyZWFrIGJldHdlZW4gbmFtZSBhbmQgaGludCB3aGlsZSBrZWVwaW5nIGNoZWNrbWFyayBvbiB0aGUgcmlnaHRcbmV4cG9ydCBjb25zdCBTdHlsZWRDdXN0b21TZWxlY3RDb250cm9sID0gc3R5bGVkKCBDdXN0b21TZWxlY3RDb250cm9sIClgXG5cdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbVxuXHRcdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbS1oaW50IHtcblx0XHR3aWR0aDogMTAwJTtcblx0fVxuYDtcbiJdfQ== */"));
  var HeaderToggle = /* @__PURE__ */ createStyled(button_default, false ? {
    target: "e8tqeku2"
  } : {
    target: "e8tqeku2",
    label: "HeaderToggle"
  })("margin-top:", space(-1), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUF5QjRDIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IEJhc2VDb250cm9sIGZyb20gJy4uL2Jhc2UtY29udHJvbCc7XG5pbXBvcnQgQnV0dG9uIGZyb20gJy4uL2J1dHRvbic7XG5pbXBvcnQgQ3VzdG9tU2VsZWN0Q29udHJvbCBmcm9tICcuLi9jdXN0b20tc2VsZWN0LWNvbnRyb2wnO1xuaW1wb3J0IHsgSFN0YWNrIH0gZnJvbSAnLi4vaC1zdGFjayc7XG5pbXBvcnQgeyBzcGFjZSB9IGZyb20gJy4uL3V0aWxzL3NwYWNlJztcblxuZXhwb3J0IGNvbnN0IENvbnRhaW5lciA9IHN0eWxlZC5maWVsZHNldGBcblx0Ym9yZGVyOiAwO1xuXHRtYXJnaW46IDA7XG5cdHBhZGRpbmc6IDA7XG5cdGRpc3BsYXk6IGNvbnRlbnRzO1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGhlaWdodDogJHsgc3BhY2UoIDQgKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlclRvZ2dsZSA9IHN0eWxlZCggQnV0dG9uIClgXG5cdG1hcmdpbi10b3A6ICR7IHNwYWNlKCAtMSApIH07XG5gO1xuXG5leHBvcnQgY29uc3QgSGVhZGVyTGFiZWwgPSBzdHlsZWQoIEJhc2VDb250cm9sLlZpc3VhbExhYmVsIClgXG5cdGRpc3BsYXk6IGZsZXg7XG5cdGdhcDogJHsgc3BhY2UoIDEgKSB9O1xuXHRqdXN0aWZ5LWNvbnRlbnQ6IGZsZXgtc3RhcnQ7XG5cdG1hcmdpbi1ib3R0b206IDA7XG5gO1xuXG4vLyBDdXN0b20gc3R5bGVkIGNvbXBvbmVudCB0byBmb3JjZSBsaW5lIGJyZWFrIGJldHdlZW4gbmFtZSBhbmQgaGludCB3aGlsZSBrZWVwaW5nIGNoZWNrbWFyayBvbiB0aGUgcmlnaHRcbmV4cG9ydCBjb25zdCBTdHlsZWRDdXN0b21TZWxlY3RDb250cm9sID0gc3R5bGVkKCBDdXN0b21TZWxlY3RDb250cm9sIClgXG5cdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbVxuXHRcdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbS1oaW50IHtcblx0XHR3aWR0aDogMTAwJTtcblx0fVxuYDtcbiJdfQ== */"));
  var HeaderLabel = /* @__PURE__ */ createStyled(base_control_default.VisualLabel, false ? {
    target: "e8tqeku1"
  } : {
    target: "e8tqeku1",
    label: "HeaderLabel"
  })("display:flex;gap:", space(1), ";justify-content:flex-start;margin-bottom:0;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE2QjREIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IEJhc2VDb250cm9sIGZyb20gJy4uL2Jhc2UtY29udHJvbCc7XG5pbXBvcnQgQnV0dG9uIGZyb20gJy4uL2J1dHRvbic7XG5pbXBvcnQgQ3VzdG9tU2VsZWN0Q29udHJvbCBmcm9tICcuLi9jdXN0b20tc2VsZWN0LWNvbnRyb2wnO1xuaW1wb3J0IHsgSFN0YWNrIH0gZnJvbSAnLi4vaC1zdGFjayc7XG5pbXBvcnQgeyBzcGFjZSB9IGZyb20gJy4uL3V0aWxzL3NwYWNlJztcblxuZXhwb3J0IGNvbnN0IENvbnRhaW5lciA9IHN0eWxlZC5maWVsZHNldGBcblx0Ym9yZGVyOiAwO1xuXHRtYXJnaW46IDA7XG5cdHBhZGRpbmc6IDA7XG5cdGRpc3BsYXk6IGNvbnRlbnRzO1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGhlaWdodDogJHsgc3BhY2UoIDQgKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlclRvZ2dsZSA9IHN0eWxlZCggQnV0dG9uIClgXG5cdG1hcmdpbi10b3A6ICR7IHNwYWNlKCAtMSApIH07XG5gO1xuXG5leHBvcnQgY29uc3QgSGVhZGVyTGFiZWwgPSBzdHlsZWQoIEJhc2VDb250cm9sLlZpc3VhbExhYmVsIClgXG5cdGRpc3BsYXk6IGZsZXg7XG5cdGdhcDogJHsgc3BhY2UoIDEgKSB9O1xuXHRqdXN0aWZ5LWNvbnRlbnQ6IGZsZXgtc3RhcnQ7XG5cdG1hcmdpbi1ib3R0b206IDA7XG5gO1xuXG4vLyBDdXN0b20gc3R5bGVkIGNvbXBvbmVudCB0byBmb3JjZSBsaW5lIGJyZWFrIGJldHdlZW4gbmFtZSBhbmQgaGludCB3aGlsZSBrZWVwaW5nIGNoZWNrbWFyayBvbiB0aGUgcmlnaHRcbmV4cG9ydCBjb25zdCBTdHlsZWRDdXN0b21TZWxlY3RDb250cm9sID0gc3R5bGVkKCBDdXN0b21TZWxlY3RDb250cm9sIClgXG5cdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbVxuXHRcdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbS1oaW50IHtcblx0XHR3aWR0aDogMTAwJTtcblx0fVxuYDtcbiJdfQ== */"));
  var StyledCustomSelectControl = /* @__PURE__ */ createStyled(custom_select_control_default, false ? {
    target: "e8tqeku0"
  } : {
    target: "e8tqeku0",
    label: "StyledCustomSelectControl"
  })(false ? {
    name: "anvx77",
    styles: ".components-custom-select-control__item .components-custom-select-control__item-hint{width:100%;}"
  } : {
    name: "anvx77",
    styles: ".components-custom-select-control__item .components-custom-select-control__item-hint{width:100%;}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFxQ3NFIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IEJhc2VDb250cm9sIGZyb20gJy4uL2Jhc2UtY29udHJvbCc7XG5pbXBvcnQgQnV0dG9uIGZyb20gJy4uL2J1dHRvbic7XG5pbXBvcnQgQ3VzdG9tU2VsZWN0Q29udHJvbCBmcm9tICcuLi9jdXN0b20tc2VsZWN0LWNvbnRyb2wnO1xuaW1wb3J0IHsgSFN0YWNrIH0gZnJvbSAnLi4vaC1zdGFjayc7XG5pbXBvcnQgeyBzcGFjZSB9IGZyb20gJy4uL3V0aWxzL3NwYWNlJztcblxuZXhwb3J0IGNvbnN0IENvbnRhaW5lciA9IHN0eWxlZC5maWVsZHNldGBcblx0Ym9yZGVyOiAwO1xuXHRtYXJnaW46IDA7XG5cdHBhZGRpbmc6IDA7XG5cdGRpc3BsYXk6IGNvbnRlbnRzO1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlciA9IHN0eWxlZCggSFN0YWNrIClgXG5cdGhlaWdodDogJHsgc3BhY2UoIDQgKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IEhlYWRlclRvZ2dsZSA9IHN0eWxlZCggQnV0dG9uIClgXG5cdG1hcmdpbi10b3A6ICR7IHNwYWNlKCAtMSApIH07XG5gO1xuXG5leHBvcnQgY29uc3QgSGVhZGVyTGFiZWwgPSBzdHlsZWQoIEJhc2VDb250cm9sLlZpc3VhbExhYmVsIClgXG5cdGRpc3BsYXk6IGZsZXg7XG5cdGdhcDogJHsgc3BhY2UoIDEgKSB9O1xuXHRqdXN0aWZ5LWNvbnRlbnQ6IGZsZXgtc3RhcnQ7XG5cdG1hcmdpbi1ib3R0b206IDA7XG5gO1xuXG4vLyBDdXN0b20gc3R5bGVkIGNvbXBvbmVudCB0byBmb3JjZSBsaW5lIGJyZWFrIGJldHdlZW4gbmFtZSBhbmQgaGludCB3aGlsZSBrZWVwaW5nIGNoZWNrbWFyayBvbiB0aGUgcmlnaHRcbmV4cG9ydCBjb25zdCBTdHlsZWRDdXN0b21TZWxlY3RDb250cm9sID0gc3R5bGVkKCBDdXN0b21TZWxlY3RDb250cm9sIClgXG5cdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbVxuXHRcdC5jb21wb25lbnRzLWN1c3RvbS1zZWxlY3QtY29udHJvbF9faXRlbS1oaW50IHtcblx0XHR3aWR0aDogMTAwJTtcblx0fVxuYDtcbiJdfQ== */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__30
  });

  // packages/components/build-module/font-size-picker/font-size-picker-select.mjs
  var import_i18n52 = __toESM(require_i18n(), 1);
  var import_element138 = __toESM(require_element(), 1);

  // packages/components/build-module/font-size-picker/utils.mjs
  function isSimpleCssValue(value) {
    const sizeRegex = /^[\d\.]+(px|em|rem|vw|vh|%|svw|lvw|dvw|svh|lvh|dvh|vi|svi|lvi|dvi|vb|svb|lvb|dvb|vmin|svmin|lvmin|dvmin|vmax|svmax|lvmax|dvmax)?$/i;
    return sizeRegex.test(String(value));
  }
  function generateFontSizeHint(fontSize) {
    if (fontSize.hint) {
      return fontSize.hint;
    }
    if (isSimpleCssValue(fontSize.size)) {
      return String(fontSize.size);
    }
    return void 0;
  }

  // packages/components/build-module/font-size-picker/font-size-picker-select.mjs
  var import_jsx_runtime213 = __toESM(require_jsx_runtime(), 1);
  var DEFAULT_OPTION = {
    key: "default",
    name: (0, import_i18n52.__)("Default"),
    value: void 0
  };
  var FontSizePickerSelect = (props) => {
    const {
      fontSizes,
      value,
      valueMode = "literal",
      onChange
    } = props;
    const options2 = [DEFAULT_OPTION, ...fontSizes.map((fontSize) => {
      const hint = generateFontSizeHint(fontSize);
      return {
        key: fontSize.slug,
        name: fontSize.name || fontSize.slug,
        value: fontSize.size,
        hint
      };
    })];
    const selectedOption = (0, import_element138.useMemo)(() => {
      if (value === void 0) {
        return DEFAULT_OPTION;
      }
      if (valueMode === "slug") {
        const optionBySlug = options2.find((option) => option.key === value);
        if (optionBySlug) {
          return optionBySlug;
        }
      }
      return options2.find((option) => option.value === value) ?? DEFAULT_OPTION;
    }, [value, valueMode, options2]);
    return /* @__PURE__ */ (0, import_jsx_runtime213.jsx)(StyledCustomSelectControl, {
      className: "components-font-size-picker__select",
      label: (0, import_i18n52.__)("Font size"),
      hideLabelFromVision: true,
      describedBy: (0, import_i18n52.sprintf)(
        // translators: %s: Currently selected font size.
        (0, import_i18n52.__)("Currently selected font size: %s"),
        selectedOption.name
      ),
      options: options2,
      value: selectedOption,
      showSelectedHint: true,
      onChange: ({
        selectedItem
      }) => {
        const matchingFontSize = selectedItem.key === "default" ? void 0 : fontSizes.find((fontSize) => fontSize.slug === selectedItem.key);
        onChange(selectedItem.value, matchingFontSize);
      }
    });
  };
  var font_size_picker_select_default = FontSizePickerSelect;

  // packages/components/build-module/font-size-picker/font-size-picker-toggle-group.mjs
  var import_i18n54 = __toESM(require_i18n(), 1);

  // packages/components/build-module/font-size-picker/constants.mjs
  var import_i18n53 = __toESM(require_i18n(), 1);
  var T_SHIRT_ABBREVIATIONS = [
    /* translators: S stands for 'small' and is a size label. */
    (0, import_i18n53.__)("S"),
    /* translators: M stands for 'medium' and is a size label. */
    (0, import_i18n53.__)("M"),
    /* translators: L stands for 'large' and is a size label. */
    (0, import_i18n53.__)("L"),
    /* translators: XL stands for 'extra large' and is a size label. */
    (0, import_i18n53.__)("XL"),
    /* translators: XXL stands for 'extra extra large' and is a size label. */
    (0, import_i18n53.__)("XXL")
  ];
  var T_SHIRT_NAMES = [(0, import_i18n53.__)("Small"), (0, import_i18n53.__)("Medium"), (0, import_i18n53.__)("Large"), (0, import_i18n53.__)("Extra Large"), (0, import_i18n53.__)("Extra Extra Large")];

  // packages/components/build-module/font-size-picker/font-size-picker-toggle-group.mjs
  var import_jsx_runtime214 = __toESM(require_jsx_runtime(), 1);
  var FontSizePickerToggleGroup = (props) => {
    const {
      fontSizes,
      value,
      valueMode = "literal",
      onChange
    } = props;
    const currentValue = (() => {
      if (!value) {
        return void 0;
      }
      if (valueMode === "slug") {
        return String(value);
      }
      const matchingFontSizes = fontSizes.filter((fontSize) => fontSize.size === value);
      if (matchingFontSizes.length > 1) {
        return void 0;
      }
      const fontSizeBySize = fontSizes.find((fontSize) => fontSize.size === value);
      return fontSizeBySize?.slug;
    })();
    return /* @__PURE__ */ (0, import_jsx_runtime214.jsx)(component_default12, {
      label: (0, import_i18n54.__)("Font size"),
      hideLabelFromVision: true,
      value: currentValue,
      onChange: (newSlug) => {
        if (newSlug === void 0) {
          onChange(void 0);
        } else {
          const selectedFontSize = fontSizes.find((fontSize) => fontSize.slug === String(newSlug));
          if (selectedFontSize) {
            onChange(selectedFontSize.size, selectedFontSize);
          }
        }
      },
      isBlock: true,
      children: fontSizes.map((fontSize, index2) => /* @__PURE__ */ (0, import_jsx_runtime214.jsx)(component_default14, {
        value: fontSize.slug,
        label: T_SHIRT_ABBREVIATIONS[index2],
        "aria-label": fontSize.name || T_SHIRT_NAMES[index2],
        showTooltip: true
      }, fontSize.slug))
    });
  };
  var font_size_picker_toggle_group_default = FontSizePickerToggleGroup;

  // packages/components/build-module/font-size-picker/index.mjs
  var import_jsx_runtime215 = __toESM(require_jsx_runtime(), 1);
  var DEFAULT_UNITS = ["px", "em", "rem", "vw", "vh"];
  var MAX_TOGGLE_GROUP_SIZES = 5;
  var UnforwardedFontSizePicker = (props, ref) => {
    const {
      fallbackFontSize,
      fontSizes = [],
      disableCustomFontSizes = false,
      onChange,
      units: unitsProp = DEFAULT_UNITS,
      value,
      valueMode = "literal",
      withSlider = false,
      withReset = true
    } = props;
    const labelId = (0, import_compose57.useInstanceId)(UnforwardedFontSizePicker, "font-size-picker-label");
    const units = useCustomUnits({
      availableUnits: unitsProp
    });
    const selectedFontSize = (() => {
      if (!value) {
        return void 0;
      }
      if (valueMode === "slug") {
        return fontSizes.find((fontSize) => fontSize.slug === value);
      }
      return fontSizes.find((fontSize) => fontSize.size === value);
    })();
    const isCustomValue2 = !!value && !selectedFontSize;
    const [userRequestedCustom, setUserRequestedCustom] = (0, import_element139.useState)(isCustomValue2);
    const resolvedValueForControls = valueMode === "slug" ? selectedFontSize?.size : value;
    let currentPickerType;
    if (!disableCustomFontSizes && userRequestedCustom) {
      currentPickerType = "custom";
    } else {
      currentPickerType = fontSizes.length > MAX_TOGGLE_GROUP_SIZES ? "select" : "togglegroup";
    }
    if (fontSizes.length === 0 && disableCustomFontSizes) {
      return null;
    }
    const hasUnits2 = typeof resolvedValueForControls === "string" || typeof fontSizes[0]?.size === "string";
    const [valueQuantity, valueUnit] = parseQuantityAndUnitFromRawValue(resolvedValueForControls, units);
    const isValueUnitRelative = !!valueUnit && ["em", "rem", "vw", "vh"].includes(valueUnit);
    const isDisabled = value === void 0;
    return /* @__PURE__ */ (0, import_jsx_runtime215.jsxs)(Container3, {
      ref,
      className: "components-font-size-picker",
      "aria-labelledby": labelId,
      children: [/* @__PURE__ */ (0, import_jsx_runtime215.jsx)(component_default6, {
        children: /* @__PURE__ */ (0, import_jsx_runtime215.jsxs)(Header2, {
          className: "components-font-size-picker__header",
          children: [/* @__PURE__ */ (0, import_jsx_runtime215.jsx)(HeaderLabel, {
            id: labelId,
            children: (0, import_i18n55.__)("Font size")
          }), !disableCustomFontSizes && /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(HeaderToggle, {
            label: currentPickerType === "custom" ? (0, import_i18n55.__)("Use size preset") : (0, import_i18n55.__)("Set custom size"),
            icon: settings_default,
            onClick: () => setUserRequestedCustom(!userRequestedCustom),
            isPressed: currentPickerType === "custom",
            size: "small"
          })]
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime215.jsxs)("div", {
        children: [currentPickerType === "select" && /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(font_size_picker_select_default, {
          fontSizes,
          value,
          valueMode,
          disableCustomFontSizes,
          onChange: (newValue, selectedItem) => {
            if (newValue === void 0) {
              onChange?.(void 0, selectedItem);
            } else {
              onChange?.(hasUnits2 ? newValue : Number(newValue), selectedItem);
            }
          },
          onSelectCustom: () => setUserRequestedCustom(true)
        }), currentPickerType === "togglegroup" && /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(font_size_picker_toggle_group_default, {
          fontSizes,
          value,
          valueMode,
          onChange: (newValue, selectedItem) => {
            if (newValue === void 0) {
              onChange?.(void 0, selectedItem);
            } else {
              onChange?.(hasUnits2 ? newValue : Number(newValue), selectedItem);
            }
          }
        }), currentPickerType === "custom" && /* @__PURE__ */ (0, import_jsx_runtime215.jsxs)(component_default3, {
          className: "components-font-size-picker__custom-size-control",
          children: [/* @__PURE__ */ (0, import_jsx_runtime215.jsx)(component_default4, {
            isBlock: true,
            children: /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(unit_control_default, {
              label: (0, import_i18n55.__)("Font size"),
              labelPosition: "top",
              hideLabelFromVision: true,
              value: hasUnits2 ? `${valueQuantity ?? ""}${valueUnit ?? ""}` : resolvedValueForControls,
              onChange: (newValue) => {
                setUserRequestedCustom(true);
                if (newValue === void 0 || newValue === "") {
                  onChange?.(void 0);
                } else {
                  onChange?.(hasUnits2 ? newValue : parseInt(newValue, 10));
                }
              },
              units: hasUnits2 ? units : [],
              min: 0
            })
          }), withSlider && /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(component_default4, {
            isBlock: true,
            children: /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(component_default6, {
              marginX: 2,
              marginBottom: 0,
              children: /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(range_control_default, {
                className: "components-font-size-picker__custom-input",
                label: (0, import_i18n55.__)("Font size"),
                hideLabelFromVision: true,
                value: valueQuantity,
                initialPosition: fallbackFontSize,
                withInputField: false,
                onChange: (newValue) => {
                  setUserRequestedCustom(true);
                  if (newValue === void 0) {
                    onChange?.(void 0);
                  } else if (hasUnits2) {
                    onChange?.(newValue + (valueUnit ?? "px"));
                  } else {
                    onChange?.(newValue);
                  }
                },
                min: 0,
                max: isValueUnitRelative ? 10 : 100,
                step: isValueUnitRelative ? 0.1 : 1
              })
            })
          }), withReset && /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(component_default4, {
            children: /* @__PURE__ */ (0, import_jsx_runtime215.jsx)(Button3, {
              disabled: isDisabled,
              accessibleWhenDisabled: true,
              onClick: () => {
                onChange?.(void 0);
              },
              variant: "secondary",
              __next40pxDefaultSize: true,
              size: "default",
              children: (0, import_i18n55.__)("Reset")
            })
          })]
        })]
      })]
    });
  };
  var FontSizePicker = (0, import_element139.forwardRef)(UnforwardedFontSizePicker);
  FontSizePicker.displayName = "FontSizePicker";
  var font_size_picker_default = FontSizePicker;

  // packages/components/build-module/form-file-upload/index.mjs
  var import_element140 = __toESM(require_element(), 1);
  var import_jsx_runtime216 = __toESM(require_jsx_runtime(), 1);
  function FormFileUpload({
    accept,
    children,
    multiple = false,
    onChange,
    onClick,
    render,
    __next40pxDefaultSize: _next40pxDefaultSize,
    ...props
  }) {
    const ref = (0, import_element140.useRef)(null);
    const openFileDialog = () => {
      ref.current?.click();
    };
    const ui = render ? render({
      openFileDialog
    }) : /* @__PURE__ */ (0, import_jsx_runtime216.jsx)(button_default, {
      onClick: openFileDialog,
      __next40pxDefaultSize: true,
      ...props,
      children
    });
    const compatAccept = accept?.includes("audio/*") ? `${accept}, audio/mp3, audio/x-m4a, audio/x-m4b, audio/x-m4p, audio/x-wav, audio/webm` : accept;
    return /* @__PURE__ */ (0, import_jsx_runtime216.jsxs)("div", {
      className: "components-form-file-upload",
      children: [ui, /* @__PURE__ */ (0, import_jsx_runtime216.jsx)("input", {
        type: "file",
        ref,
        multiple,
        style: {
          display: "none"
        },
        accept: compatAccept,
        onChange,
        onClick,
        "data-testid": "form-file-upload-input"
      })]
    });
  }
  var form_file_upload_default = FormFileUpload;

  // packages/components/build-module/form-toggle/index.mjs
  var import_element141 = __toESM(require_element(), 1);
  var import_jsx_runtime217 = __toESM(require_jsx_runtime(), 1);
  var noop16 = () => {
  };
  function UnforwardedFormToggle(props, ref) {
    const {
      className: className2,
      checked,
      id: id3,
      disabled,
      onChange = noop16,
      onClick,
      ...additionalProps
    } = props;
    const wrapperClasses = clsx_default("components-form-toggle", className2, {
      "is-checked": checked,
      "is-disabled": disabled
    });
    return /* @__PURE__ */ (0, import_jsx_runtime217.jsxs)("span", {
      className: wrapperClasses,
      children: [/* @__PURE__ */ (0, import_jsx_runtime217.jsx)("input", {
        className: "components-form-toggle__input",
        id: id3,
        type: "checkbox",
        checked,
        onChange,
        disabled,
        onClick: (event) => {
          event.currentTarget.focus();
          onClick?.(event);
        },
        ...additionalProps,
        ref
      }), /* @__PURE__ */ (0, import_jsx_runtime217.jsx)("span", {
        className: "components-form-toggle__track"
      }), /* @__PURE__ */ (0, import_jsx_runtime217.jsx)("span", {
        className: "components-form-toggle__thumb"
      })]
    });
  }
  var FormToggle = (0, import_element141.forwardRef)(UnforwardedFormToggle);
  FormToggle.displayName = "FormToggle";
  var form_toggle_default = FormToggle;

  // packages/components/build-module/form-token-field/index.mjs
  var import_element142 = __toESM(require_element(), 1);
  var import_i18n57 = __toESM(require_i18n(), 1);
  var import_compose59 = __toESM(require_compose(), 1);
  var import_a11y6 = __toESM(require_a11y(), 1);
  var import_is_shallow_equal2 = __toESM(require_is_shallow_equal(), 1);
  var import_deprecated15 = __toESM(require_deprecated(), 1);

  // packages/components/build-module/form-token-field/token.mjs
  var import_compose58 = __toESM(require_compose(), 1);
  var import_i18n56 = __toESM(require_i18n(), 1);
  var import_jsx_runtime218 = __toESM(require_jsx_runtime(), 1);
  var noop17 = () => {
  };
  function Token({
    value,
    status,
    title,
    displayTransform,
    isBorderless = false,
    disabled = false,
    onClickRemove = noop17,
    onMouseEnter,
    onMouseLeave,
    messages,
    termPosition,
    termsCount
  }) {
    const instanceId = (0, import_compose58.useInstanceId)(Token);
    const tokenClasses = clsx_default("components-form-token-field__token", {
      "is-error": "error" === status,
      "is-success": "success" === status,
      "is-validating": "validating" === status,
      "is-borderless": isBorderless,
      "is-disabled": disabled
    });
    const onClick = () => onClickRemove({
      value
    });
    const transformedValue = displayTransform(value);
    const termPositionAndCount = (0, import_i18n56.sprintf)(
      /* translators: 1: term name, 2: term position in a set of terms, 3: total term set count. */
      (0, import_i18n56.__)("%1$s (%2$d of %3$d)"),
      transformedValue,
      termPosition,
      termsCount
    );
    return /* @__PURE__ */ (0, import_jsx_runtime218.jsxs)("span", {
      className: tokenClasses,
      onMouseEnter,
      onMouseLeave,
      title,
      children: [/* @__PURE__ */ (0, import_jsx_runtime218.jsxs)("span", {
        className: "components-form-token-field__token-text",
        id: `components-form-token-field__token-text-${instanceId}`,
        children: [/* @__PURE__ */ (0, import_jsx_runtime218.jsx)(component_default2, {
          as: "span",
          children: termPositionAndCount
        }), /* @__PURE__ */ (0, import_jsx_runtime218.jsx)("span", {
          "aria-hidden": "true",
          children: transformedValue
        })]
      }), /* @__PURE__ */ (0, import_jsx_runtime218.jsx)(button_default, {
        className: "components-form-token-field__remove-token",
        size: "small",
        icon: close_small_default,
        onClick: !disabled ? onClick : void 0,
        disabled,
        label: messages.remove,
        "aria-describedby": `components-form-token-field__token-text-${instanceId}`
      })]
    });
  }

  // packages/components/build-module/form-token-field/styles.mjs
  var TokensAndInputWrapperFlex = /* @__PURE__ */ createStyled(component_default3, false ? {
    target: "ehq8nmi0"
  } : {
    target: "ehq8nmi0",
    label: "TokensAndInputWrapperFlex"
  })("padding:7px;", boxSizingReset, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXdUQiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBGbGV4IH0gZnJvbSAnLi4vZmxleCc7XG5pbXBvcnQgeyBib3hTaXppbmdSZXNldCB9IGZyb20gJy4uL3V0aWxzJztcblxuZXhwb3J0IGNvbnN0IFRva2Vuc0FuZElucHV0V3JhcHBlckZsZXggPSBzdHlsZWQoIEZsZXggKWBcblx0cGFkZGluZzogN3B4O1xuXHQkeyBib3hTaXppbmdSZXNldCB9XG5gO1xuIl19 */"));

  // packages/components/build-module/form-token-field/index.mjs
  var import_jsx_runtime219 = __toESM(require_jsx_runtime(), 1);
  var identity3 = (value) => value;
  function FormTokenField(props) {
    const {
      autoCapitalize,
      autoComplete,
      maxLength,
      placeholder,
      label = (0, import_i18n57.__)("Add item"),
      className: className2,
      suggestions = [],
      maxSuggestions = 100,
      value = [],
      displayTransform = identity3,
      saveTransform = (token2) => token2.trim(),
      onChange = () => {
      },
      onInputChange = () => {
      },
      onFocus = void 0,
      isBorderless = false,
      disabled = false,
      tokenizeOnSpace = false,
      messages = {
        added: (0, import_i18n57.__)("Item added."),
        removed: (0, import_i18n57.__)("Item removed."),
        remove: (0, import_i18n57.__)("Remove item"),
        __experimentalInvalid: (0, import_i18n57.__)("Invalid item")
      },
      __experimentalRenderItem,
      __experimentalExpandOnFocus = false,
      __experimentalValidateInput = () => true,
      __experimentalShowHowTo,
      __experimentalAutoSelectFirstMatch = false,
      tokenizeOnBlur = false,
      help
    } = props;
    const defaultHelp = tokenizeOnSpace ? (0, import_i18n57.__)("Separate with commas, spaces, or the Enter key.") : (0, import_i18n57.__)("Separate with commas or the Enter key.");
    let computedHelp = help !== void 0 ? help : defaultHelp;
    if (typeof __experimentalShowHowTo === "boolean") {
      (0, import_deprecated15.default)("`__experimentalShowHowTo` prop in wp.components.FormTokenField", {
        since: "7.1",
        alternative: "`help` prop",
        hint: "The `help` prop now defaults to the previous how-to text. Pass an empty string to hide it."
      });
      if (__experimentalShowHowTo === false && help === void 0) {
        computedHelp = "";
      }
    }
    const instanceId = (0, import_compose59.useInstanceId)(FormTokenField);
    const [incompleteTokenValue, setIncompleteTokenValue] = (0, import_element142.useState)("");
    const [inputOffsetFromEnd, setInputOffsetFromEnd] = (0, import_element142.useState)(0);
    const [isActive, setIsActive] = (0, import_element142.useState)(false);
    const [isExpanded, setIsExpanded] = (0, import_element142.useState)(false);
    const [selectedSuggestionIndex, setSelectedSuggestionIndex] = (0, import_element142.useState)(-1);
    const [selectedSuggestionScroll, setSelectedSuggestionScroll] = (0, import_element142.useState)(false);
    const prevSuggestions = (0, import_compose59.usePrevious)(suggestions);
    const prevValue = (0, import_compose59.usePrevious)(value);
    const input = (0, import_element142.useRef)(null);
    const tokensAndInput = (0, import_element142.useRef)(null);
    const debouncedSpeak = (0, import_compose59.useDebounce)(import_a11y6.speak, 500);
    (0, import_element142.useEffect)(() => {
      if (isActive && !hasFocus2()) {
        focus4();
      }
    }, [isActive]);
    (0, import_element142.useEffect)(() => {
      const suggestionsDidUpdate = !(0, import_is_shallow_equal2.isShallowEqual)(suggestions, prevSuggestions || []);
      if (suggestionsDidUpdate || value !== prevValue) {
        updateSuggestions(suggestionsDidUpdate);
      }
    }, [suggestions, prevSuggestions, value, prevValue]);
    (0, import_element142.useEffect)(() => {
      updateSuggestions();
    }, [incompleteTokenValue]);
    (0, import_element142.useEffect)(() => {
      updateSuggestions();
    }, [__experimentalAutoSelectFirstMatch]);
    if (disabled && isActive) {
      setIsActive(false);
      setIncompleteTokenValue("");
    }
    function focus4() {
      input.current?.focus();
    }
    function hasFocus2() {
      return input.current === input.current?.ownerDocument.activeElement;
    }
    function onFocusHandler(event) {
      if (hasFocus2() || event.target === tokensAndInput.current) {
        setIsActive(true);
        setIsExpanded(__experimentalExpandOnFocus || isExpanded);
      } else {
        setIsActive(false);
      }
      if ("function" === typeof onFocus) {
        onFocus(event);
      }
    }
    function onBlur(event) {
      if (inputHasValidValue() && __experimentalValidateInput(incompleteTokenValue)) {
        setIsActive(false);
        if (tokenizeOnBlur && inputHasValidValue()) {
          addNewToken(incompleteTokenValue);
        }
      } else {
        setIncompleteTokenValue("");
        setInputOffsetFromEnd(0);
        setIsActive(false);
        if (__experimentalExpandOnFocus) {
          const hasFocusWithin2 = event.relatedTarget === tokensAndInput.current;
          setIsExpanded(hasFocusWithin2);
        } else {
          setIsExpanded(false);
        }
        setSelectedSuggestionIndex(-1);
        setSelectedSuggestionScroll(false);
      }
    }
    function onKeyDown(event) {
      let preventDefault = false;
      if (event.defaultPrevented) {
        return;
      }
      switch (event.key) {
        case "Backspace":
          preventDefault = handleDeleteKey(deleteTokenBeforeInput);
          break;
        case "Enter":
          preventDefault = addCurrentToken();
          break;
        case "ArrowLeft":
          preventDefault = handleLeftArrowKey();
          break;
        case "ArrowUp":
          preventDefault = handleUpArrowKey();
          break;
        case "ArrowRight":
          preventDefault = handleRightArrowKey();
          break;
        case "ArrowDown":
          preventDefault = handleDownArrowKey();
          break;
        case "Delete":
          preventDefault = handleDeleteKey(deleteTokenAfterInput);
          break;
        case "Space":
          if (tokenizeOnSpace) {
            preventDefault = addCurrentToken({
              preventDefaultOnFailedValidation: false
            });
          }
          break;
        case "Escape":
          preventDefault = handleEscapeKey(event);
          break;
        case "Tab":
          preventDefault = handleTabKey(event);
          break;
        default:
          break;
      }
      if (preventDefault) {
        event.preventDefault();
      }
    }
    function onKeyPress(event) {
      let preventDefault = false;
      switch (event.key) {
        case ",":
          preventDefault = handleCommaKey();
          break;
        default:
          break;
      }
      if (preventDefault) {
        event.preventDefault();
      }
    }
    function onContainerTouched(event) {
      if (event.target === tokensAndInput.current && isActive) {
        event.preventDefault();
      }
    }
    function onTokenClickRemove(event) {
      deleteToken(event.value);
      focus4();
    }
    function onSuggestionHovered(suggestion) {
      const index2 = getMatchingSuggestions().indexOf(suggestion);
      if (index2 >= 0) {
        setSelectedSuggestionIndex(index2);
        setSelectedSuggestionScroll(false);
      }
    }
    function onSuggestionSelected(suggestion) {
      addNewToken(suggestion);
    }
    function onInputChangeHandler(event) {
      const text = event.value;
      const separator = tokenizeOnSpace ? /[ ,\t]+/ : /[,\t]+/;
      const items = text.split(separator);
      const tokenValue = items[items.length - 1] || "";
      if (items.length > 1) {
        const tokensToProcess = items.slice(0, -1);
        const willFailValidation = (segment) => {
          const transformed = saveTransform(segment);
          return !!transformed && !valueContainsToken(transformed) && !__experimentalValidateInput(transformed);
        };
        const hasFailures = tokensToProcess.some(willFailValidation);
        const addedTokens = addNewTokens(hasFailures ? items : tokensToProcess);
        if (hasFailures) {
          const rejected = items.filter((token2) => {
            const transformed = saveTransform(token2);
            if (!transformed) {
              return false;
            }
            if (addedTokens.has(transformed)) {
              return false;
            }
            if (valueContainsToken(transformed)) {
              return false;
            }
            return !__experimentalValidateInput(transformed);
          });
          const usedSeparators = text.match(/[ ,\t]/g);
          const separatorChar = usedSeparators?.[usedSeparators.length - 1] ?? (tokenizeOnSpace ? " " : ",");
          const trailing = tokenValue === "" ? separatorChar : "";
          const remaining = rejected.join(separatorChar) + trailing;
          setIncompleteTokenValue(remaining);
          onInputChange(remaining);
          return;
        }
      }
      setIncompleteTokenValue(tokenValue);
      onInputChange(tokenValue);
    }
    function handleDeleteKey(_deleteToken) {
      let preventDefault = false;
      if (hasFocus2() && isInputEmpty()) {
        _deleteToken();
        preventDefault = true;
      }
      return preventDefault;
    }
    function handleLeftArrowKey() {
      let preventDefault = false;
      if (isInputEmpty()) {
        moveInputBeforePreviousToken();
        preventDefault = true;
      }
      return preventDefault;
    }
    function handleRightArrowKey() {
      let preventDefault = false;
      if (isInputEmpty()) {
        moveInputAfterNextToken();
        preventDefault = true;
      }
      return preventDefault;
    }
    function handleUpArrowKey() {
      setSelectedSuggestionIndex((index2) => {
        return (index2 === 0 ? getMatchingSuggestions(incompleteTokenValue, suggestions, value, maxSuggestions, saveTransform).length : index2) - 1;
      });
      setSelectedSuggestionScroll(true);
      return true;
    }
    function handleDownArrowKey() {
      setSelectedSuggestionIndex((index2) => {
        return (index2 + 1) % getMatchingSuggestions(incompleteTokenValue, suggestions, value, maxSuggestions, saveTransform).length;
      });
      setSelectedSuggestionScroll(true);
      return true;
    }
    function collapseSuggestionsList(event) {
      if (event.target instanceof HTMLInputElement) {
        setIncompleteTokenValue(event.target.value);
        setIsExpanded(false);
        setSelectedSuggestionIndex(-1);
        setSelectedSuggestionScroll(false);
      }
    }
    function handleEscapeKey(event) {
      collapseSuggestionsList(event);
      return true;
    }
    function handleTabKey(event) {
      collapseSuggestionsList(event);
      return false;
    }
    function handleCommaKey() {
      if (inputHasValidValue()) {
        addNewToken(incompleteTokenValue);
      }
      return true;
    }
    function moveInputToIndex(index2) {
      setInputOffsetFromEnd(value.length - Math.max(index2, -1) - 1);
    }
    function moveInputBeforePreviousToken() {
      setInputOffsetFromEnd((prevInputOffsetFromEnd) => {
        return Math.min(prevInputOffsetFromEnd + 1, value.length);
      });
    }
    function moveInputAfterNextToken() {
      setInputOffsetFromEnd((prevInputOffsetFromEnd) => {
        return Math.max(prevInputOffsetFromEnd - 1, 0);
      });
    }
    function deleteTokenBeforeInput() {
      const index2 = getIndexOfInput() - 1;
      if (index2 > -1) {
        deleteToken(value[index2]);
      }
    }
    function deleteTokenAfterInput() {
      const index2 = getIndexOfInput();
      if (index2 < value.length) {
        deleteToken(value[index2]);
        moveInputToIndex(index2);
      }
    }
    function addCurrentToken({
      preventDefaultOnFailedValidation = true
    } = {}) {
      let preventDefault = false;
      const selectedSuggestion = getSelectedSuggestion();
      if (selectedSuggestion) {
        addNewToken(selectedSuggestion);
        preventDefault = true;
      } else if (inputHasValidValue()) {
        const passedValidation = addNewToken(incompleteTokenValue);
        preventDefault = passedValidation || preventDefaultOnFailedValidation;
      }
      return preventDefault;
    }
    function addNewTokens(tokens) {
      const tokensToAdd = [...new Set(tokens.map(saveTransform).filter(Boolean).filter((token2) => !valueContainsToken(token2)).filter((token2) => __experimentalValidateInput(token2)))];
      if (tokensToAdd.length > 0) {
        const newValue = [...value];
        newValue.splice(getIndexOfInput(), 0, ...tokensToAdd);
        onChange(newValue);
      }
      return new Set(tokensToAdd);
    }
    function addNewToken(token2) {
      if (!__experimentalValidateInput(token2)) {
        (0, import_a11y6.speak)(messages.__experimentalInvalid, "assertive");
        return false;
      }
      addNewTokens([token2]);
      (0, import_a11y6.speak)(messages.added, "assertive");
      setIncompleteTokenValue("");
      setSelectedSuggestionIndex(-1);
      setSelectedSuggestionScroll(false);
      setIsExpanded(!__experimentalExpandOnFocus);
      if (isActive && !tokenizeOnBlur) {
        focus4();
      }
      return true;
    }
    function deleteToken(token2) {
      const newTokens = value.filter((item2) => {
        return getTokenValue(item2) !== getTokenValue(token2);
      });
      onChange(newTokens);
      (0, import_a11y6.speak)(messages.removed, "assertive");
    }
    function getTokenValue(token2) {
      if ("object" === typeof token2) {
        return token2.value;
      }
      return token2;
    }
    function getMatchingSuggestions(searchValue = incompleteTokenValue, _suggestions = suggestions, _value = value, _maxSuggestions = maxSuggestions, _saveTransform = saveTransform) {
      let match4 = _saveTransform(searchValue);
      const startsWithMatch = [];
      const containsMatch = [];
      const normalizedValue = _value.map((item2) => {
        if (typeof item2 === "string") {
          return item2;
        }
        return item2.value;
      });
      if (match4.length === 0) {
        _suggestions = _suggestions.filter((suggestion) => !normalizedValue.includes(suggestion));
      } else {
        match4 = match4.normalize("NFKC").toLocaleLowerCase();
        _suggestions.forEach((suggestion) => {
          const index2 = suggestion.normalize("NFKC").toLocaleLowerCase().indexOf(match4);
          if (normalizedValue.indexOf(suggestion) === -1) {
            if (index2 === 0) {
              startsWithMatch.push(suggestion);
            } else if (index2 > 0) {
              containsMatch.push(suggestion);
            }
          }
        });
        _suggestions = startsWithMatch.concat(containsMatch);
      }
      return _suggestions.slice(0, _maxSuggestions);
    }
    function getSelectedSuggestion() {
      if (selectedSuggestionIndex !== -1) {
        return getMatchingSuggestions()[selectedSuggestionIndex];
      }
      return void 0;
    }
    function valueContainsToken(token2) {
      return value.some((item2) => {
        return getTokenValue(token2) === getTokenValue(item2);
      });
    }
    function getIndexOfInput() {
      return value.length - inputOffsetFromEnd;
    }
    function isInputEmpty() {
      return incompleteTokenValue.length === 0;
    }
    function inputHasValidValue() {
      return saveTransform(incompleteTokenValue).length > 0;
    }
    function updateSuggestions(resetSelectedSuggestion = true) {
      const inputHasMinimumChars = incompleteTokenValue.trim().length > 1;
      const matchingSuggestions2 = getMatchingSuggestions(incompleteTokenValue);
      const hasMatchingSuggestions = matchingSuggestions2.length > 0;
      const shouldExpandIfFocuses = hasFocus2() && __experimentalExpandOnFocus;
      setIsExpanded(shouldExpandIfFocuses || inputHasMinimumChars && hasMatchingSuggestions);
      if (resetSelectedSuggestion) {
        if (__experimentalAutoSelectFirstMatch && inputHasMinimumChars && hasMatchingSuggestions) {
          setSelectedSuggestionIndex(0);
          setSelectedSuggestionScroll(true);
        } else {
          setSelectedSuggestionIndex(-1);
          setSelectedSuggestionScroll(false);
        }
      }
      if (inputHasMinimumChars) {
        const message2 = hasMatchingSuggestions ? (0, import_i18n57.sprintf)(
          /* translators: %d: number of results. */
          (0, import_i18n57._n)("%d result found, use up and down arrow keys to navigate.", "%d results found, use up and down arrow keys to navigate.", matchingSuggestions2.length),
          matchingSuggestions2.length
        ) : (0, import_i18n57.__)("No results.");
        debouncedSpeak(message2, "assertive");
      }
    }
    function renderTokensAndInput() {
      const components = value.map(renderToken);
      components.splice(getIndexOfInput(), 0, renderInput());
      return components;
    }
    function renderToken(token2, index2, tokens) {
      const _value = getTokenValue(token2);
      const status = typeof token2 !== "string" ? token2.status : void 0;
      const termPosition = index2 + 1;
      const termsCount = tokens.length;
      return /* @__PURE__ */ (0, import_jsx_runtime219.jsx)(component_default4, {
        children: /* @__PURE__ */ (0, import_jsx_runtime219.jsx)(Token, {
          value: _value,
          status,
          title: typeof token2 !== "string" ? token2.title : void 0,
          displayTransform,
          onClickRemove: onTokenClickRemove,
          isBorderless: typeof token2 !== "string" && token2.isBorderless || isBorderless,
          onMouseEnter: typeof token2 !== "string" ? token2.onMouseEnter : void 0,
          onMouseLeave: typeof token2 !== "string" ? token2.onMouseLeave : void 0,
          disabled: "error" !== status && disabled,
          messages,
          termsCount,
          termPosition
        })
      }, "token-" + _value);
    }
    function renderInput() {
      const describedById = computedHelp ? `components-form-token-input-${instanceId}__help` : void 0;
      const inputProps = {
        instanceId,
        autoCapitalize,
        autoComplete,
        placeholder: value.length === 0 ? placeholder : "",
        disabled,
        value: incompleteTokenValue,
        onBlur,
        isExpanded,
        selectedSuggestionIndex,
        "aria-describedby": describedById
      };
      return /* @__PURE__ */ (0, import_jsx_runtime219.jsx)(token_input_default, {
        ...inputProps,
        onChange: !(maxLength && value.length >= maxLength) ? onInputChangeHandler : void 0,
        ref: input
      }, "input");
    }
    const classes = clsx_default(className2, "components-form-token-field__input-container", {
      "is-active": isActive,
      "is-disabled": disabled
    });
    let tokenFieldProps = {
      className: "components-form-token-field",
      tabIndex: -1
    };
    const matchingSuggestions = getMatchingSuggestions();
    if (!disabled) {
      tokenFieldProps = Object.assign({}, tokenFieldProps, {
        onKeyDown: withIgnoreIMEEvents(onKeyDown),
        onKeyPress,
        onFocus: onFocusHandler
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime219.jsxs)("div", {
      ...tokenFieldProps,
      children: [label && /* @__PURE__ */ (0, import_jsx_runtime219.jsx)(StyledLabel, {
        htmlFor: `components-form-token-input-${instanceId}`,
        className: "components-form-token-field__label",
        children: label
      }), /* @__PURE__ */ (0, import_jsx_runtime219.jsxs)("div", {
        ref: tokensAndInput,
        className: classes,
        tabIndex: -1,
        onMouseDown: onContainerTouched,
        onTouchStart: onContainerTouched,
        children: [/* @__PURE__ */ (0, import_jsx_runtime219.jsx)(TokensAndInputWrapperFlex, {
          justify: "flex-start",
          align: "center",
          gap: 1,
          wrap: true,
          children: renderTokensAndInput()
        }), isExpanded && /* @__PURE__ */ (0, import_jsx_runtime219.jsx)(suggestions_list_default, {
          instanceId,
          match: saveTransform(incompleteTokenValue),
          displayTransform,
          suggestions: matchingSuggestions,
          selectedIndex: selectedSuggestionIndex,
          scrollIntoView: selectedSuggestionScroll,
          onHover: onSuggestionHovered,
          onSelect: onSuggestionSelected,
          __experimentalRenderItem
        })]
      }), computedHelp && /* @__PURE__ */ (0, import_jsx_runtime219.jsx)(StyledHelp, {
        id: `components-form-token-input-${instanceId}__help`,
        className: "components-form-token-field__help",
        children: computedHelp
      })]
    });
  }
  var form_token_field_default = FormTokenField;

  // packages/components/build-module/guide/index.mjs
  var import_element143 = __toESM(require_element(), 1);
  var import_deprecated16 = __toESM(require_deprecated(), 1);
  var import_i18n59 = __toESM(require_i18n(), 1);

  // packages/components/build-module/guide/page-control.mjs
  var import_i18n58 = __toESM(require_i18n(), 1);

  // packages/components/build-module/guide/icons.mjs
  var import_primitives32 = __toESM(require_primitives(), 1);
  var import_jsx_runtime220 = __toESM(require_jsx_runtime(), 1);
  var PageControlIcon = () => /* @__PURE__ */ (0, import_jsx_runtime220.jsx)(import_primitives32.SVG, {
    width: "8",
    height: "8",
    fill: "none",
    xmlns: "http://www.w3.org/2000/svg",
    children: /* @__PURE__ */ (0, import_jsx_runtime220.jsx)(import_primitives32.Circle, {
      cx: "4",
      cy: "4",
      r: "4"
    })
  });

  // packages/components/build-module/guide/page-control.mjs
  var import_jsx_runtime221 = __toESM(require_jsx_runtime(), 1);
  function PageControl({
    currentPage,
    numberOfPages,
    setCurrentPage
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime221.jsx)("ul", {
      className: "components-guide__page-control",
      "aria-label": (0, import_i18n58.__)("Guide controls"),
      children: Array.from({
        length: numberOfPages
      }).map((_2, page) => /* @__PURE__ */ (0, import_jsx_runtime221.jsx)("li", {
        // Set aria-current="step" on the active page, see https://www.w3.org/TR/wai-aria-1.1/#aria-current
        "aria-current": page === currentPage ? "step" : void 0,
        children: /* @__PURE__ */ (0, import_jsx_runtime221.jsx)(button_default, {
          size: "small",
          icon: /* @__PURE__ */ (0, import_jsx_runtime221.jsx)(PageControlIcon, {}),
          "aria-label": (0, import_i18n58.sprintf)(
            /* translators: 1: current page number 2: total number of pages */
            (0, import_i18n58.__)("Page %1$d of %2$d"),
            page + 1,
            numberOfPages
          ),
          onClick: () => setCurrentPage(page)
        }, page)
      }, page))
    });
  }

  // packages/components/build-module/guide/index.mjs
  var import_jsx_runtime222 = __toESM(require_jsx_runtime(), 1);
  function Guide({
    children,
    className: className2,
    contentLabel,
    finishButtonText = (0, import_i18n59.__)("Finish"),
    nextButtonText = (0, import_i18n59.__)("Next"),
    previousButtonText = (0, import_i18n59.__)("Previous"),
    onFinish,
    pages = []
  }) {
    const ref = (0, import_element143.useRef)(null);
    const [currentPage, setCurrentPage] = (0, import_element143.useState)(0);
    (0, import_element143.useEffect)(() => {
      const frame2 = ref.current?.querySelector(".components-guide");
      if (frame2 instanceof HTMLElement) {
        frame2.focus();
      }
    }, [currentPage]);
    (0, import_element143.useEffect)(() => {
      if (import_element143.Children.count(children)) {
        (0, import_deprecated16.default)("Passing children to <Guide>", {
          since: "5.5",
          alternative: "the `pages` prop"
        });
      }
    }, [children]);
    if (import_element143.Children.count(children)) {
      pages = import_element143.Children.map(children, (child) => ({
        content: child
      })) ?? [];
    }
    const canGoBack = currentPage > 0;
    const canGoForward = currentPage < pages.length - 1;
    const goBack = () => {
      if (canGoBack) {
        setCurrentPage(currentPage - 1);
      }
    };
    const goForward = () => {
      if (canGoForward) {
        setCurrentPage(currentPage + 1);
      }
    };
    if (pages.length === 0) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime222.jsx)(modal_default, {
      className: clsx_default("components-guide", className2),
      contentLabel,
      isDismissible: pages.length > 1,
      onRequestClose: onFinish,
      onKeyDown: (event) => {
        if (event.code === "ArrowLeft") {
          goBack();
          event.preventDefault();
        } else if (event.code === "ArrowRight") {
          goForward();
          event.preventDefault();
        }
      },
      ref,
      children: /* @__PURE__ */ (0, import_jsx_runtime222.jsxs)("div", {
        className: "components-guide__container",
        children: [/* @__PURE__ */ (0, import_jsx_runtime222.jsxs)("div", {
          className: "components-guide__page",
          children: [pages[currentPage].image, pages.length > 1 && /* @__PURE__ */ (0, import_jsx_runtime222.jsx)(PageControl, {
            currentPage,
            numberOfPages: pages.length,
            setCurrentPage
          }), pages[currentPage].content]
        }), /* @__PURE__ */ (0, import_jsx_runtime222.jsxs)("div", {
          className: "components-guide__footer",
          children: [canGoBack && /* @__PURE__ */ (0, import_jsx_runtime222.jsx)(button_default, {
            className: "components-guide__back-button",
            variant: "tertiary",
            onClick: goBack,
            __next40pxDefaultSize: true,
            children: previousButtonText
          }), canGoForward && /* @__PURE__ */ (0, import_jsx_runtime222.jsx)(button_default, {
            className: "components-guide__forward-button",
            variant: "primary",
            onClick: goForward,
            __next40pxDefaultSize: true,
            children: nextButtonText
          }), !canGoForward && /* @__PURE__ */ (0, import_jsx_runtime222.jsx)(button_default, {
            className: "components-guide__finish-button",
            variant: "primary",
            onClick: onFinish,
            __next40pxDefaultSize: true,
            children: finishButtonText
          })]
        })]
      })
    });
  }
  var guide_default = Guide;

  // packages/components/build-module/guide/page.mjs
  var import_element144 = __toESM(require_element(), 1);
  var import_deprecated17 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime223 = __toESM(require_jsx_runtime(), 1);
  function GuidePage(props) {
    (0, import_element144.useEffect)(() => {
      (0, import_deprecated17.default)("<GuidePage>", {
        since: "5.5",
        alternative: "the `pages` prop in <Guide>"
      });
    }, []);
    return /* @__PURE__ */ (0, import_jsx_runtime223.jsx)("div", {
      ...props
    });
  }

  // packages/components/build-module/button/deprecated.mjs
  var import_deprecated18 = __toESM(require_deprecated(), 1);
  var import_element145 = __toESM(require_element(), 1);
  var import_jsx_runtime224 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedIconButton({
    label,
    labelPosition,
    size: size4,
    tooltip,
    ...props
  }, ref) {
    (0, import_deprecated18.default)("wp.components.IconButton", {
      since: "5.4",
      alternative: "wp.components.Button",
      version: "6.2"
    });
    return (
      // Disable reason: the parent component is taking care of the __next40pxDefaultSize prop.
      // eslint-disable-next-line @wordpress/components-no-missing-40px-size-prop
      /* @__PURE__ */ (0, import_jsx_runtime224.jsx)(button_default, {
        ...props,
        ref,
        tooltipPosition: labelPosition,
        iconSize: size4,
        showTooltip: tooltip !== void 0 ? !!tooltip : void 0,
        label: tooltip || label
      })
    );
  }
  var deprecated_default = (0, import_element145.forwardRef)(UnforwardedIconButton);

  // packages/components/build-module/keyboard-shortcuts/index.mjs
  var import_element146 = __toESM(require_element(), 1);
  var import_compose60 = __toESM(require_compose(), 1);
  var import_jsx_runtime225 = __toESM(require_jsx_runtime(), 1);
  function KeyboardShortcut({
    target,
    callback,
    shortcut,
    bindGlobal,
    eventName
  }) {
    (0, import_compose60.useKeyboardShortcut)(shortcut, callback, {
      bindGlobal,
      target,
      eventName
    });
    return null;
  }
  function KeyboardShortcuts({
    children,
    shortcuts,
    bindGlobal,
    eventName
  }) {
    const target = (0, import_element146.useRef)(null);
    const element = Object.entries(shortcuts ?? {}).map(([shortcut, callback]) => /* @__PURE__ */ (0, import_jsx_runtime225.jsx)(KeyboardShortcut, {
      shortcut,
      callback,
      bindGlobal,
      eventName,
      target
    }, shortcut));
    if (!import_element146.Children.count(children)) {
      return /* @__PURE__ */ (0, import_jsx_runtime225.jsx)(import_jsx_runtime225.Fragment, {
        children: element
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime225.jsxs)("div", {
      ref: target,
      children: [element, children]
    });
  }
  var keyboard_shortcuts_default = KeyboardShortcuts;

  // packages/components/build-module/menu-group/index.mjs
  var import_element147 = __toESM(require_element(), 1);
  var import_compose61 = __toESM(require_compose(), 1);
  var import_jsx_runtime226 = __toESM(require_jsx_runtime(), 1);
  function MenuGroup3(props) {
    const {
      children,
      className: className2 = "",
      label,
      hideSeparator
    } = props;
    const instanceId = (0, import_compose61.useInstanceId)(MenuGroup3);
    if (!import_element147.Children.count(children)) {
      return null;
    }
    const labelId = `components-menu-group-label-${instanceId}`;
    const classNames = clsx_default(className2, "components-menu-group", {
      "has-hidden-separator": hideSeparator
    });
    return /* @__PURE__ */ (0, import_jsx_runtime226.jsxs)("div", {
      className: classNames,
      children: [label && /* @__PURE__ */ (0, import_jsx_runtime226.jsx)("div", {
        className: "components-menu-group__label",
        id: labelId,
        "aria-hidden": "true",
        children: label
      }), /* @__PURE__ */ (0, import_jsx_runtime226.jsx)("div", {
        role: "group",
        "aria-labelledby": label ? labelId : void 0,
        children
      })]
    });
  }
  var menu_group_default = MenuGroup3;

  // packages/components/build-module/menu-item/index.mjs
  var import_element148 = __toESM(require_element(), 1);
  var import_jsx_runtime227 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedMenuItem(props, ref) {
    let {
      children,
      info,
      className: className2,
      icon,
      iconPosition = "right",
      shortcut,
      isSelected: isSelected2,
      role = "menuitem",
      suffix,
      ...buttonProps
    } = props;
    className2 = clsx_default("components-menu-item__button", className2);
    if (info) {
      children = /* @__PURE__ */ (0, import_jsx_runtime227.jsxs)("span", {
        className: "components-menu-item__info-wrapper",
        children: [/* @__PURE__ */ (0, import_jsx_runtime227.jsx)("span", {
          className: "components-menu-item__item",
          children
        }), /* @__PURE__ */ (0, import_jsx_runtime227.jsx)("span", {
          className: "components-menu-item__info",
          children: info
        })]
      });
    }
    if (icon && typeof icon !== "string") {
      icon = (0, import_element148.cloneElement)(icon, {
        className: clsx_default("components-menu-items__item-icon", {
          "has-icon-right": iconPosition === "right"
        })
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime227.jsxs)(button_default, {
      size: "compact",
      ref,
      "aria-checked": role === "menuitemcheckbox" || role === "menuitemradio" ? isSelected2 : void 0,
      role,
      icon: iconPosition === "left" ? icon : void 0,
      className: className2,
      accessibleWhenDisabled: true,
      ...buttonProps,
      children: [/* @__PURE__ */ (0, import_jsx_runtime227.jsx)("span", {
        className: "components-menu-item__item",
        children
      }), !suffix && /* @__PURE__ */ (0, import_jsx_runtime227.jsx)(shortcut_default, {
        className: "components-menu-item__shortcut",
        shortcut
      }), !suffix && icon && iconPosition === "right" && /* @__PURE__ */ (0, import_jsx_runtime227.jsx)(icon_default3, {
        icon
      }), suffix]
    });
  }
  var MenuItem3 = (0, import_element148.forwardRef)(UnforwardedMenuItem);
  MenuItem3.displayName = "MenuItem";
  var menu_item_default = MenuItem3;

  // packages/components/build-module/menu-items-choice/index.mjs
  var import_jsx_runtime228 = __toESM(require_jsx_runtime(), 1);
  var noop18 = () => {
  };
  function MenuItemsChoice({
    choices = [],
    onHover = noop18,
    onSelect,
    value
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime228.jsx)(import_jsx_runtime228.Fragment, {
      children: choices.map((item2) => {
        const isSelected2 = value === item2.value;
        return /* @__PURE__ */ (0, import_jsx_runtime228.jsx)(menu_item_default, {
          role: "menuitemradio",
          disabled: item2.disabled,
          icon: isSelected2 ? check_default : null,
          info: item2.info,
          isSelected: isSelected2,
          shortcut: item2.shortcut,
          className: "components-menu-items-choice",
          onClick: () => {
            if (!isSelected2) {
              onSelect(item2.value);
            }
          },
          onMouseEnter: () => onHover(item2.value),
          onMouseLeave: () => onHover(null),
          "aria-label": item2["aria-label"],
          children: item2.label
        }, item2.value);
      })
    });
  }
  var menu_items_choice_default = MenuItemsChoice;

  // packages/components/build-module/navigator/navigator/component.mjs
  var import_deprecated19 = __toESM(require_deprecated(), 1);
  var import_element150 = __toESM(require_element(), 1);
  var import_is_shallow_equal3 = __toESM(require_is_shallow_equal(), 1);
  var import_warning7 = __toESM(require_warning(), 1);

  // packages/components/node_modules/path-to-regexp/dist.es2015/index.js
  function lexer(str) {
    var tokens = [];
    var i3 = 0;
    while (i3 < str.length) {
      var char2 = str[i3];
      if (char2 === "*" || char2 === "+" || char2 === "?") {
        tokens.push({ type: "MODIFIER", index: i3, value: str[i3++] });
        continue;
      }
      if (char2 === "\\") {
        tokens.push({ type: "ESCAPED_CHAR", index: i3++, value: str[i3++] });
        continue;
      }
      if (char2 === "{") {
        tokens.push({ type: "OPEN", index: i3, value: str[i3++] });
        continue;
      }
      if (char2 === "}") {
        tokens.push({ type: "CLOSE", index: i3, value: str[i3++] });
        continue;
      }
      if (char2 === ":") {
        var name = "";
        var j2 = i3 + 1;
        while (j2 < str.length) {
          var code = str.charCodeAt(j2);
          if (
            // `0-9`
            code >= 48 && code <= 57 || // `A-Z`
            code >= 65 && code <= 90 || // `a-z`
            code >= 97 && code <= 122 || // `_`
            code === 95
          ) {
            name += str[j2++];
            continue;
          }
          break;
        }
        if (!name)
          throw new TypeError("Missing parameter name at ".concat(i3));
        tokens.push({ type: "NAME", index: i3, value: name });
        i3 = j2;
        continue;
      }
      if (char2 === "(") {
        var count = 1;
        var pattern = "";
        var j2 = i3 + 1;
        if (str[j2] === "?") {
          throw new TypeError('Pattern cannot start with "?" at '.concat(j2));
        }
        while (j2 < str.length) {
          if (str[j2] === "\\") {
            pattern += str[j2++] + str[j2++];
            continue;
          }
          if (str[j2] === ")") {
            count--;
            if (count === 0) {
              j2++;
              break;
            }
          } else if (str[j2] === "(") {
            count++;
            if (str[j2 + 1] !== "?") {
              throw new TypeError("Capturing groups are not allowed at ".concat(j2));
            }
          }
          pattern += str[j2++];
        }
        if (count)
          throw new TypeError("Unbalanced pattern at ".concat(i3));
        if (!pattern)
          throw new TypeError("Missing pattern at ".concat(i3));
        tokens.push({ type: "PATTERN", index: i3, value: pattern });
        i3 = j2;
        continue;
      }
      tokens.push({ type: "CHAR", index: i3, value: str[i3++] });
    }
    tokens.push({ type: "END", index: i3, value: "" });
    return tokens;
  }
  function parse3(str, options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    var tokens = lexer(str);
    var _a = options2.prefixes, prefixes = _a === void 0 ? "./" : _a, _b = options2.delimiter, delimiter2 = _b === void 0 ? "/#?" : _b;
    var result = [];
    var key = 0;
    var i3 = 0;
    var path = "";
    var tryConsume = function(type) {
      if (i3 < tokens.length && tokens[i3].type === type)
        return tokens[i3++].value;
    };
    var mustConsume = function(type) {
      var value2 = tryConsume(type);
      if (value2 !== void 0)
        return value2;
      var _a2 = tokens[i3], nextType = _a2.type, index2 = _a2.index;
      throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index2, ", expected ").concat(type));
    };
    var consumeText = function() {
      var result2 = "";
      var value2;
      while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
        result2 += value2;
      }
      return result2;
    };
    var isSafe = function(value2) {
      for (var _i = 0, delimiter_1 = delimiter2; _i < delimiter_1.length; _i++) {
        var char3 = delimiter_1[_i];
        if (value2.indexOf(char3) > -1)
          return true;
      }
      return false;
    };
    var safePattern = function(prefix3) {
      var prev2 = result[result.length - 1];
      var prevText = prefix3 || (prev2 && typeof prev2 === "string" ? prev2 : "");
      if (prev2 && !prevText) {
        throw new TypeError('Must have text between two parameters, missing text after "'.concat(prev2.name, '"'));
      }
      if (!prevText || isSafe(prevText))
        return "[^".concat(escapeString(delimiter2), "]+?");
      return "(?:(?!".concat(escapeString(prevText), ")[^").concat(escapeString(delimiter2), "])+?");
    };
    while (i3 < tokens.length) {
      var char2 = tryConsume("CHAR");
      var name = tryConsume("NAME");
      var pattern = tryConsume("PATTERN");
      if (name || pattern) {
        var prefix2 = char2 || "";
        if (prefixes.indexOf(prefix2) === -1) {
          path += prefix2;
          prefix2 = "";
        }
        if (path) {
          result.push(path);
          path = "";
        }
        result.push({
          name: name || key++,
          prefix: prefix2,
          suffix: "",
          pattern: pattern || safePattern(prefix2),
          modifier: tryConsume("MODIFIER") || ""
        });
        continue;
      }
      var value = char2 || tryConsume("ESCAPED_CHAR");
      if (value) {
        path += value;
        continue;
      }
      if (path) {
        result.push(path);
        path = "";
      }
      var open = tryConsume("OPEN");
      if (open) {
        var prefix2 = consumeText();
        var name_1 = tryConsume("NAME") || "";
        var pattern_1 = tryConsume("PATTERN") || "";
        var suffix = consumeText();
        mustConsume("CLOSE");
        result.push({
          name: name_1 || (pattern_1 ? key++ : ""),
          pattern: name_1 && !pattern_1 ? safePattern(prefix2) : pattern_1,
          prefix: prefix2,
          suffix,
          modifier: tryConsume("MODIFIER") || ""
        });
        continue;
      }
      mustConsume("END");
    }
    return result;
  }
  function match3(str, options2) {
    var keys = [];
    var re4 = pathToRegexp(str, keys, options2);
    return regexpToFunction(re4, keys, options2);
  }
  function regexpToFunction(re4, keys, options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    var _a = options2.decode, decode = _a === void 0 ? function(x2) {
      return x2;
    } : _a;
    return function(pathname) {
      var m3 = re4.exec(pathname);
      if (!m3)
        return false;
      var path = m3[0], index2 = m3.index;
      var params = /* @__PURE__ */ Object.create(null);
      var _loop_1 = function(i4) {
        if (m3[i4] === void 0)
          return "continue";
        var key = keys[i4 - 1];
        if (key.modifier === "*" || key.modifier === "+") {
          params[key.name] = m3[i4].split(key.prefix + key.suffix).map(function(value) {
            return decode(value, key);
          });
        } else {
          params[key.name] = decode(m3[i4], key);
        }
      };
      for (var i3 = 1; i3 < m3.length; i3++) {
        _loop_1(i3);
      }
      return { path, index: index2, params };
    };
  }
  function escapeString(str) {
    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
  }
  function flags(options2) {
    return options2 && options2.sensitive ? "" : "i";
  }
  function regexpToRegexp(path, keys) {
    if (!keys)
      return path;
    var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
    var index2 = 0;
    var execResult = groupsRegex.exec(path.source);
    while (execResult) {
      keys.push({
        // Use parenthesized substring match if available, index otherwise
        name: execResult[1] || index2++,
        prefix: "",
        suffix: "",
        modifier: "",
        pattern: ""
      });
      execResult = groupsRegex.exec(path.source);
    }
    return path;
  }
  function arrayToRegexp(paths, keys, options2) {
    var parts = paths.map(function(path) {
      return pathToRegexp(path, keys, options2).source;
    });
    return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options2));
  }
  function stringToRegexp(path, keys, options2) {
    return tokensToRegexp(parse3(path, options2), keys, options2);
  }
  function tokensToRegexp(tokens, keys, options2) {
    if (options2 === void 0) {
      options2 = {};
    }
    var _a = options2.strict, strict = _a === void 0 ? false : _a, _b = options2.start, start = _b === void 0 ? true : _b, _c = options2.end, end = _c === void 0 ? true : _c, _d = options2.encode, encode = _d === void 0 ? function(x2) {
      return x2;
    } : _d, _e = options2.delimiter, delimiter2 = _e === void 0 ? "/#?" : _e, _f = options2.endsWith, endsWith2 = _f === void 0 ? "" : _f;
    var endsWithRe = "[".concat(escapeString(endsWith2), "]|$");
    var delimiterRe = "[".concat(escapeString(delimiter2), "]");
    var route = start ? "^" : "";
    for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
      var token2 = tokens_1[_i];
      if (typeof token2 === "string") {
        route += escapeString(encode(token2));
      } else {
        var prefix2 = escapeString(encode(token2.prefix));
        var suffix = escapeString(encode(token2.suffix));
        if (token2.pattern) {
          if (keys)
            keys.push(token2);
          if (prefix2 || suffix) {
            if (token2.modifier === "+" || token2.modifier === "*") {
              var mod = token2.modifier === "*" ? "?" : "";
              route += "(?:".concat(prefix2, "((?:").concat(token2.pattern, ")(?:").concat(suffix).concat(prefix2, "(?:").concat(token2.pattern, "))*)").concat(suffix, ")").concat(mod);
            } else {
              route += "(?:".concat(prefix2, "(").concat(token2.pattern, ")").concat(suffix, ")").concat(token2.modifier);
            }
          } else {
            if (token2.modifier === "+" || token2.modifier === "*") {
              throw new TypeError('Can not repeat "'.concat(token2.name, '" without a prefix and suffix'));
            }
            route += "(".concat(token2.pattern, ")").concat(token2.modifier);
          }
        } else {
          route += "(?:".concat(prefix2).concat(suffix, ")").concat(token2.modifier);
        }
      }
    }
    if (end) {
      if (!strict)
        route += "".concat(delimiterRe, "?");
      route += !options2.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
    } else {
      var endToken = tokens[tokens.length - 1];
      var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
      if (!strict) {
        route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
      }
      if (!isEndDelimited) {
        route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
      }
    }
    return new RegExp(route, flags(options2));
  }
  function pathToRegexp(path, keys, options2) {
    if (path instanceof RegExp)
      return regexpToRegexp(path, keys);
    if (Array.isArray(path))
      return arrayToRegexp(path, keys, options2);
    return stringToRegexp(path, keys, options2);
  }

  // packages/components/build-module/navigator/utils/router.mjs
  function matchPath(path, pattern) {
    const matchingFunction = match3(pattern, {
      decode: decodeURIComponent
    });
    return matchingFunction(path);
  }
  function patternMatch(path, screens) {
    for (const screen of screens) {
      const matched = matchPath(path, screen.path);
      if (matched) {
        return {
          params: matched.params,
          id: screen.id
        };
      }
    }
    return void 0;
  }
  function findParent(path, screens) {
    if (!path.startsWith("/")) {
      return void 0;
    }
    const pathParts = path.split("/");
    let parentPath;
    while (pathParts.length > 1 && parentPath === void 0) {
      pathParts.pop();
      const potentialParentPath = pathParts.join("/") === "" ? "/" : pathParts.join("/");
      if (screens.find((screen) => {
        return matchPath(potentialParentPath, screen.path) !== false;
      })) {
        parentPath = potentialParentPath;
      }
    }
    return parentPath;
  }

  // packages/components/build-module/navigator/context.mjs
  var import_element149 = __toESM(require_element(), 1);
  var initialContextValue = {
    location: {},
    goTo: () => {
    },
    goBack: () => {
    },
    goToParent: () => {
    },
    addScreen: () => {
    },
    removeScreen: () => {
    },
    params: {}
  };
  var NavigatorContext = (0, import_element149.createContext)(initialContextValue);
  NavigatorContext.displayName = "NavigatorContext";

  // packages/components/build-module/navigator/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__31() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var navigatorWrapper = false ? {
    name: "1br0vvk",
    styles: "position:relative;overflow-x:clip;contain:layout;display:grid;grid-template-columns:1fr;grid-template-rows:1fr;align-items:start"
  } : {
    name: "il0xvu-navigatorWrapper",
    styles: "position:relative;overflow-x:clip;contain:layout;display:grid;grid-template-columns:1fr;grid-template-rows:1fr;align-items:start;label:navigatorWrapper;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__31
  };
  var fadeIn2 = keyframes2({
    from: {
      opacity: 0
    }
  });
  var fadeOut = keyframes2({
    to: {
      opacity: 0
    }
  });
  var slideFromRight = keyframes2({
    from: {
      transform: "translateX(100px)"
    }
  });
  var slideToLeft = keyframes2({
    to: {
      transform: "translateX(-80px)"
    }
  });
  var slideFromLeft = keyframes2({
    from: {
      transform: "translateX(-100px)"
    }
  });
  var slideToRight = keyframes2({
    to: {
      transform: "translateX(80px)"
    }
  });
  var FADE = {
    DURATION: 70,
    EASING: "linear",
    DELAY: {
      IN: 70,
      OUT: 40
    }
  };
  var SLIDE = {
    DURATION: 300,
    EASING: "cubic-bezier(0.33, 0, 0, 1)"
  };
  var TOTAL_ANIMATION_DURATION = {
    IN: Math.max(FADE.DURATION + FADE.DELAY.IN, SLIDE.DURATION),
    OUT: Math.max(FADE.DURATION + FADE.DELAY.OUT, SLIDE.DURATION)
  };
  var ANIMATION_END_NAMES = {
    end: {
      in: slideFromRight.name,
      out: slideToLeft.name
    },
    start: {
      in: slideFromLeft.name,
      out: slideToRight.name
    }
  };
  var ANIMATION = {
    end: {
      in: /* @__PURE__ */ css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.IN, "ms both ", fadeIn2, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideFromRight, ";" + (false ? "" : ";label:in;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"),
      out: /* @__PURE__ */ css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.OUT, "ms both ", fadeOut, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideToLeft, ";" + (false ? "" : ";label:out;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */")
    },
    start: {
      in: /* @__PURE__ */ css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.IN, "ms both ", fadeIn2, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideFromLeft, ";" + (false ? "" : ";label:in;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"),
      out: /* @__PURE__ */ css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.OUT, "ms both ", fadeOut, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideToRight, ";" + (false ? "" : ";label:out;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */")
    }
  };
  var navigatorScreenAnimation = /* @__PURE__ */ css("z-index:1;&[data-animation-type='out']{z-index:0;}@media not ( prefers-reduced-motion ){&:not( [data-skip-animation] ){", ["start", "end"].map((direction) => ["in", "out"].map((type) => /* @__PURE__ */ css("&[data-animation-direction='", direction, "'][data-animation-type='", type, "']{animation:", ANIMATION[direction][type], ";}" + (false ? "" : ";label:navigatorScreenAnimation;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"))), ";}}" + (false ? "" : ";label:navigatorScreenAnimation;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var navigatorScreen = false ? {
    name: "14di7zd",
    styles: "overflow-x:auto;max-height:100%;box-sizing:border-box;position:relative;grid-column:1/-1;grid-row:1/-1"
  } : {
    name: "x0o5tf-navigatorScreen",
    styles: "overflow-x:auto;max-height:100%;box-sizing:border-box;position:relative;grid-column:1/-1;grid-row:1/-1;label:navigatorScreen;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__31
  };

  // packages/components/build-module/navigator/navigator/component.mjs
  var import_jsx_runtime229 = __toESM(require_jsx_runtime(), 1);
  function addScreen({
    screens
  }, screen) {
    if (screens.some((s3) => s3.path === screen.path)) {
      true ? (0, import_warning7.default)(`Navigator: a screen with path ${screen.path} already exists.
The screen with id ${screen.id} will not be added.`) : void 0;
      return screens;
    }
    return [...screens, screen];
  }
  function removeScreen({
    screens
  }, screen) {
    return screens.filter((s3) => s3.id !== screen.id);
  }
  function goTo(state, path, options2 = {}) {
    const {
      focusSelectors
    } = state;
    const currentLocation = {
      ...state.currentLocation
    };
    const {
      // Default assignments
      isBack = false,
      skipFocus = false,
      // Extract to avoid forwarding
      replace: replace3,
      focusTargetSelector,
      // Rest
      ...restOptions
    } = options2;
    if (currentLocation.path === path) {
      return {
        currentLocation,
        focusSelectors
      };
    }
    let focusSelectorsCopy;
    function getFocusSelectorsCopy() {
      focusSelectorsCopy = focusSelectorsCopy ?? new Map(state.focusSelectors);
      return focusSelectorsCopy;
    }
    if (focusTargetSelector && currentLocation.path) {
      getFocusSelectorsCopy().set(currentLocation.path, focusTargetSelector);
    }
    let currentFocusSelector;
    if (focusSelectors.get(path)) {
      if (isBack) {
        currentFocusSelector = focusSelectors.get(path);
      }
      getFocusSelectorsCopy().delete(path);
    }
    return {
      currentLocation: {
        ...restOptions,
        isInitial: false,
        path,
        isBack,
        hasRestoredFocus: false,
        focusTargetSelector: currentFocusSelector,
        skipFocus
      },
      focusSelectors: focusSelectorsCopy ?? focusSelectors
    };
  }
  function goToParent(state, options2 = {}) {
    const {
      screens,
      focusSelectors
    } = state;
    const currentLocation = {
      ...state.currentLocation
    };
    const currentPath = currentLocation.path;
    if (currentPath === void 0) {
      return {
        currentLocation,
        focusSelectors
      };
    }
    const parentPath = findParent(currentPath, screens);
    if (parentPath === void 0) {
      return {
        currentLocation,
        focusSelectors
      };
    }
    return goTo(state, parentPath, {
      ...options2,
      isBack: true
    });
  }
  function routerReducer(state, action) {
    let {
      screens,
      currentLocation,
      matchedPath,
      focusSelectors,
      ...restState
    } = state;
    switch (action.type) {
      case "add":
        screens = addScreen(state, action.screen);
        break;
      case "remove":
        screens = removeScreen(state, action.screen);
        break;
      case "goto":
        ({
          currentLocation,
          focusSelectors
        } = goTo(state, action.path, action.options));
        break;
      case "gotoparent":
        ({
          currentLocation,
          focusSelectors
        } = goToParent(state, action.options));
        break;
    }
    if (screens === state.screens && currentLocation === state.currentLocation) {
      return state;
    }
    const currentPath = currentLocation.path;
    matchedPath = currentPath !== void 0 ? patternMatch(currentPath, screens) : void 0;
    if (matchedPath && state.matchedPath && matchedPath.id === state.matchedPath.id && (0, import_is_shallow_equal3.isShallowEqual)(matchedPath.params, state.matchedPath.params)) {
      matchedPath = state.matchedPath;
    }
    return {
      ...restState,
      screens,
      currentLocation,
      matchedPath,
      focusSelectors
    };
  }
  function UnconnectedNavigator(props, forwardedRef) {
    const {
      initialPath: initialPathProp,
      children,
      className: className2,
      ...otherProps
    } = useContextSystem(props, "Navigator");
    const [routerState, dispatch] = (0, import_element150.useReducer)(routerReducer, initialPathProp, (path) => ({
      screens: [],
      currentLocation: {
        path,
        isInitial: true
      },
      matchedPath: void 0,
      focusSelectors: /* @__PURE__ */ new Map(),
      initialPath: initialPathProp
    }));
    const methods = (0, import_element150.useMemo)(() => ({
      // Note: calling goBack calls `goToParent` internally, as it was established
      // that `goBack` should behave like `goToParent`, and `goToParent` should
      // be marked as deprecated.
      goBack: (options2) => dispatch({
        type: "gotoparent",
        options: options2
      }),
      goTo: (path, options2) => dispatch({
        type: "goto",
        path,
        options: options2
      }),
      goToParent: (options2) => {
        (0, import_deprecated19.default)(`wp.components.useNavigator().goToParent`, {
          since: "6.7",
          alternative: "wp.components.useNavigator().goBack"
        });
        dispatch({
          type: "gotoparent",
          options: options2
        });
      },
      addScreen: (screen) => dispatch({
        type: "add",
        screen
      }),
      removeScreen: (screen) => dispatch({
        type: "remove",
        screen
      })
    }), []);
    const {
      currentLocation,
      matchedPath
    } = routerState;
    const navigatorContextValue = (0, import_element150.useMemo)(() => ({
      location: currentLocation,
      params: matchedPath?.params ?? {},
      match: matchedPath?.id,
      ...methods
    }), [currentLocation, matchedPath, methods]);
    const cx2 = useCx();
    const classes = (0, import_element150.useMemo)(() => cx2(navigatorWrapper, className2), [className2, cx2]);
    return /* @__PURE__ */ (0, import_jsx_runtime229.jsx)(component_default, {
      ref: forwardedRef,
      className: classes,
      ...otherProps,
      children: /* @__PURE__ */ (0, import_jsx_runtime229.jsx)(NavigatorContext.Provider, {
        value: navigatorContextValue,
        children
      })
    });
  }
  var Navigator2 = contextConnect(UnconnectedNavigator, "Navigator");

  // packages/components/build-module/navigator/navigator-screen/component.mjs
  var import_dom8 = __toESM(require_dom(), 1);
  var import_element152 = __toESM(require_element(), 1);
  var import_compose63 = __toESM(require_compose(), 1);
  var import_escape_html = __toESM(require_escape_html(), 1);
  var import_warning8 = __toESM(require_warning(), 1);

  // packages/components/build-module/navigator/navigator-screen/use-screen-animate-presence.mjs
  var import_element151 = __toESM(require_element(), 1);
  var import_compose62 = __toESM(require_compose(), 1);
  var import_i18n60 = __toESM(require_i18n(), 1);
  var ANIMATION_TIMEOUT_MARGIN = 1.2;
  var isEnterAnimation = (animationDirection, animationStatus, animationName) => animationStatus === "ANIMATING_IN" && animationName === ANIMATION_END_NAMES[animationDirection].in;
  var isExitAnimation = (animationDirection, animationStatus, animationName) => animationStatus === "ANIMATING_OUT" && animationName === ANIMATION_END_NAMES[animationDirection].out;
  function useScreenAnimatePresence({
    isMatch,
    skipAnimation,
    isBack,
    onAnimationEnd
  }) {
    const isRTL19 = (0, import_i18n60.isRTL)();
    const prefersReducedMotion2 = (0, import_compose62.useReducedMotion)();
    const [animationStatus, setAnimationStatus] = (0, import_element151.useState)("INITIAL");
    const becameSelected = animationStatus !== "ANIMATING_IN" && animationStatus !== "IN" && isMatch;
    const becameUnselected = animationStatus !== "ANIMATING_OUT" && animationStatus !== "OUT" && !isMatch;
    (0, import_element151.useLayoutEffect)(() => {
      if (becameSelected) {
        setAnimationStatus(skipAnimation || prefersReducedMotion2 ? "IN" : "ANIMATING_IN");
      } else if (becameUnselected) {
        setAnimationStatus(skipAnimation || prefersReducedMotion2 ? "OUT" : "ANIMATING_OUT");
      }
    }, [becameSelected, becameUnselected, skipAnimation, prefersReducedMotion2]);
    const animationDirection = isRTL19 && isBack || !isRTL19 && !isBack ? "end" : "start";
    const isAnimatingIn = animationStatus === "ANIMATING_IN";
    const isAnimatingOut = animationStatus === "ANIMATING_OUT";
    let animationType;
    if (isAnimatingIn) {
      animationType = "in";
    } else if (isAnimatingOut) {
      animationType = "out";
    }
    const onScreenAnimationEnd = (0, import_element151.useCallback)((e3) => {
      onAnimationEnd?.(e3);
      if (isExitAnimation(animationDirection, animationStatus, e3.animationName)) {
        setAnimationStatus("OUT");
      } else if (isEnterAnimation(animationDirection, animationStatus, e3.animationName)) {
        setAnimationStatus("IN");
      }
    }, [onAnimationEnd, animationStatus, animationDirection]);
    (0, import_element151.useEffect)(() => {
      let animationTimeout;
      if (isAnimatingOut) {
        animationTimeout = window.setTimeout(() => {
          setAnimationStatus("OUT");
          animationTimeout = void 0;
        }, TOTAL_ANIMATION_DURATION.OUT * ANIMATION_TIMEOUT_MARGIN);
      } else if (isAnimatingIn) {
        animationTimeout = window.setTimeout(() => {
          setAnimationStatus("IN");
          animationTimeout = void 0;
        }, TOTAL_ANIMATION_DURATION.IN * ANIMATION_TIMEOUT_MARGIN);
      }
      return () => {
        if (animationTimeout) {
          window.clearTimeout(animationTimeout);
          animationTimeout = void 0;
        }
      };
    }, [isAnimatingOut, isAnimatingIn]);
    return {
      animationStyles: navigatorScreenAnimation,
      // Render the screen's contents in the DOM not only when the screen is
      // selected, but also while it is animating out.
      shouldRenderScreen: isMatch || animationStatus === "IN" || animationStatus === "ANIMATING_OUT",
      screenProps: {
        onAnimationEnd: onScreenAnimationEnd,
        "data-animation-direction": animationDirection,
        "data-animation-type": animationType,
        "data-skip-animation": skipAnimation || void 0
      }
    };
  }

  // packages/components/build-module/navigator/navigator-screen/component.mjs
  var import_jsx_runtime230 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedNavigatorScreen(props, forwardedRef) {
    if (!/^\//.test(props.path)) {
      true ? (0, import_warning8.default)("wp.components.Navigator.Screen: the `path` should follow a URL-like scheme; it should start with and be separated by the `/` character.") : void 0;
    }
    const screenId = (0, import_element152.useId)();
    const {
      children,
      className: className2,
      path,
      onAnimationEnd: onAnimationEndProp,
      ...otherProps
    } = useContextSystem(props, "Navigator.Screen");
    const {
      location,
      match: match4,
      addScreen: addScreen2,
      removeScreen: removeScreen2
    } = (0, import_element152.useContext)(NavigatorContext);
    const {
      isInitial,
      isBack,
      focusTargetSelector,
      skipFocus
    } = location;
    const isMatch = match4 === screenId;
    const wrapperRef = (0, import_element152.useRef)(null);
    const skipAnimationAndFocusRestoration = !!isInitial && !isBack;
    (0, import_element152.useEffect)(() => {
      const screen = {
        id: screenId,
        path: (0, import_escape_html.escapeAttribute)(path)
      };
      addScreen2(screen);
      return () => removeScreen2(screen);
    }, [screenId, path, addScreen2, removeScreen2]);
    const {
      animationStyles,
      shouldRenderScreen,
      screenProps
    } = useScreenAnimatePresence({
      isMatch,
      isBack,
      onAnimationEnd: onAnimationEndProp,
      skipAnimation: skipAnimationAndFocusRestoration
    });
    const cx2 = useCx();
    const classes = (0, import_element152.useMemo)(() => cx2(navigatorScreen, animationStyles, className2), [className2, cx2, animationStyles]);
    const locationRef = (0, import_element152.useRef)(location);
    (0, import_element152.useEffect)(() => {
      locationRef.current = location;
    }, [location]);
    (0, import_element152.useEffect)(() => {
      const wrapperEl = wrapperRef.current;
      if (skipAnimationAndFocusRestoration || !isMatch || !wrapperEl || locationRef.current.hasRestoredFocus || skipFocus) {
        return;
      }
      const activeElement = wrapperEl.ownerDocument.activeElement;
      if (wrapperEl.contains(activeElement)) {
        return;
      }
      let elementToFocus = null;
      if (isBack && focusTargetSelector) {
        elementToFocus = wrapperEl.querySelector(focusTargetSelector);
      }
      if (!elementToFocus) {
        const [firstTabbable] = import_dom8.focus.tabbable.find(wrapperEl);
        elementToFocus = firstTabbable ?? wrapperEl;
      }
      locationRef.current.hasRestoredFocus = true;
      elementToFocus.focus();
    }, [skipAnimationAndFocusRestoration, isMatch, isBack, focusTargetSelector, skipFocus]);
    const mergedWrapperRef = (0, import_compose63.useMergeRefs)([forwardedRef, wrapperRef]);
    return shouldRenderScreen ? /* @__PURE__ */ (0, import_jsx_runtime230.jsx)(component_default, {
      ref: mergedWrapperRef,
      className: classes,
      ...screenProps,
      ...otherProps,
      children
    }) : null;
  }
  var NavigatorScreen = contextConnect(UnconnectedNavigatorScreen, "Navigator.Screen");

  // packages/components/build-module/navigator/navigator-button/hook.mjs
  var import_element154 = __toESM(require_element(), 1);
  var import_escape_html2 = __toESM(require_escape_html(), 1);

  // packages/components/build-module/navigator/use-navigator.mjs
  var import_element153 = __toESM(require_element(), 1);
  function useNavigator() {
    const {
      location,
      params,
      goTo: goTo2,
      goBack,
      goToParent: goToParent2
    } = (0, import_element153.useContext)(NavigatorContext);
    return {
      location,
      goTo: goTo2,
      goBack,
      goToParent: goToParent2,
      params
    };
  }

  // packages/components/build-module/navigator/navigator-button/hook.mjs
  var cssSelectorForAttribute = (attrName, attrValue) => `[${attrName}="${attrValue}"]`;
  function useNavigatorButton(props) {
    const {
      path,
      onClick,
      as = button_default,
      attributeName = "id",
      ...otherProps
    } = useContextSystem(props, "Navigator.Button");
    const escapedPath = (0, import_escape_html2.escapeAttribute)(path);
    const {
      goTo: goTo2
    } = useNavigator();
    const handleClick = (0, import_element154.useCallback)((e3) => {
      e3.preventDefault();
      goTo2(escapedPath, {
        focusTargetSelector: cssSelectorForAttribute(attributeName, escapedPath)
      });
      onClick?.(e3);
    }, [goTo2, onClick, attributeName, escapedPath]);
    return {
      as,
      onClick: handleClick,
      ...otherProps,
      [attributeName]: escapedPath
    };
  }

  // packages/components/build-module/navigator/navigator-button/component.mjs
  var import_jsx_runtime231 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedNavigatorButton(props, forwardedRef) {
    const navigatorButtonProps = useNavigatorButton(props);
    return /* @__PURE__ */ (0, import_jsx_runtime231.jsx)(component_default, {
      ref: forwardedRef,
      ...navigatorButtonProps
    });
  }
  var NavigatorButton = contextConnect(UnconnectedNavigatorButton, "Navigator.Button");

  // packages/components/build-module/navigator/navigator-back-button/hook.mjs
  var import_element155 = __toESM(require_element(), 1);
  function useNavigatorBackButton(props) {
    const {
      onClick,
      as = button_default,
      ...otherProps
    } = useContextSystem(props, "Navigator.BackButton");
    const {
      goBack
    } = useNavigator();
    const handleClick = (0, import_element155.useCallback)((e3) => {
      e3.preventDefault();
      goBack();
      onClick?.(e3);
    }, [goBack, onClick]);
    return {
      as,
      onClick: handleClick,
      ...otherProps
    };
  }

  // packages/components/build-module/navigator/navigator-back-button/component.mjs
  var import_jsx_runtime232 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedNavigatorBackButton(props, forwardedRef) {
    const navigatorBackButtonProps = useNavigatorBackButton(props);
    return /* @__PURE__ */ (0, import_jsx_runtime232.jsx)(component_default, {
      ref: forwardedRef,
      ...navigatorBackButtonProps
    });
  }
  var NavigatorBackButton = contextConnect(UnconnectedNavigatorBackButton, "Navigator.BackButton");

  // packages/components/build-module/navigator/navigator-to-parent-button/component.mjs
  var import_deprecated20 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime233 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedNavigatorToParentButton(props, forwardedRef) {
    (0, import_deprecated20.default)("wp.components.NavigatorToParentButton", {
      since: "6.7",
      alternative: "wp.components.Navigator.BackButton"
    });
    return /* @__PURE__ */ (0, import_jsx_runtime233.jsx)(NavigatorBackButton, {
      ref: forwardedRef,
      ...props
    });
  }
  var NavigatorToParentButton = contextConnect(UnconnectedNavigatorToParentButton, "Navigator.ToParentButton");

  // packages/components/build-module/navigator/legacy.mjs
  var NavigatorProvider = Object.assign(Navigator2, {
    displayName: "NavigatorProvider"
  });
  var NavigatorScreen2 = Object.assign(NavigatorScreen, {
    displayName: "NavigatorScreen"
  });
  var NavigatorButton2 = Object.assign(NavigatorButton, {
    displayName: "NavigatorButton"
  });
  var NavigatorBackButton2 = Object.assign(NavigatorBackButton, {
    displayName: "NavigatorBackButton"
  });
  var NavigatorToParentButton2 = Object.assign(NavigatorToParentButton, {
    displayName: "NavigatorToParentButton"
  });

  // packages/components/build-module/navigator/index.mjs
  var Navigator3 = Object.assign(Navigator2, {
    /**
     * The `Navigator.Screen` component represents a single view/screen/panel and
     * should be used in combination with the `Navigator`, the `Navigator.Button`
     * and the `Navigator.BackButton` components.
     *
     * @example
     * ```jsx
     * import { Navigator } from '@wordpress/components';
     *
     * const MyNavigation = () => (
     *   <Navigator initialPath="/">
     *     <Navigator.Screen path="/">
     *       <p>This is the home screen.</p>
     *        <Navigator.Button path="/child">
     *          Navigate to child screen.
     *       </Navigator.Button>
     *     </Navigator.Screen>
     *
     *     <Navigator.Screen path="/child">
     *       <p>This is the child screen.</p>
     *       <Navigator.BackButton>
     *         Go back
     *       </Navigator.BackButton>
     *     </Navigator.Screen>
     *   </Navigator>
     * );
     * ```
     */
    Screen: Object.assign(NavigatorScreen, {
      displayName: "Navigator.Screen"
    }),
    /**
     * The `Navigator.Button` component can be used to navigate to a screen and
     * should be used in combination with the `Navigator`, the `Navigator.Screen`
     * and the `Navigator.BackButton` components.
     *
     * @example
     * ```jsx
     * import { Navigator } from '@wordpress/components';
     *
     * const MyNavigation = () => (
     *   <Navigator initialPath="/">
     *     <Navigator.Screen path="/">
     *       <p>This is the home screen.</p>
     *        <Navigator.Button path="/child">
     *          Navigate to child screen.
     *       </Navigator.Button>
     *     </Navigator.Screen>
     *
     *     <Navigator.Screen path="/child">
     *       <p>This is the child screen.</p>
     *       <Navigator.BackButton>
     *         Go back
     *       </Navigator.BackButton>
     *     </Navigator.Screen>
     *   </Navigator>
     * );
     * ```
     */
    Button: Object.assign(NavigatorButton, {
      displayName: "Navigator.Button"
    }),
    /**
     * The `Navigator.BackButton` component can be used to navigate to a screen and
     * should be used in combination with the `Navigator`, the `Navigator.Screen`
     * and the `Navigator.Button` components.
     *
     * @example
     * ```jsx
     * import { Navigator } from '@wordpress/components';
     *
     * const MyNavigation = () => (
     *   <Navigator initialPath="/">
     *     <Navigator.Screen path="/">
     *       <p>This is the home screen.</p>
     *        <Navigator.Button path="/child">
     *          Navigate to child screen.
     *       </Navigator.Button>
     *     </Navigator.Screen>
     *
     *     <Navigator.Screen path="/child">
     *       <p>This is the child screen.</p>
     *       <Navigator.BackButton>
     *         Go back
     *       </Navigator.BackButton>
     *     </Navigator.Screen>
     *   </Navigator>
     * );
     * ```
     */
    BackButton: Object.assign(NavigatorBackButton, {
      displayName: "Navigator.BackButton"
    })
  });

  // packages/components/build-module/notice/index.mjs
  var import_i18n61 = __toESM(require_i18n(), 1);
  var import_element156 = __toESM(require_element(), 1);
  var import_a11y7 = __toESM(require_a11y(), 1);
  var import_jsx_runtime234 = __toESM(require_jsx_runtime(), 1);
  var noop19 = () => {
  };
  function useSpokenMessage(message2, politeness) {
    const spokenMessage = typeof message2 === "string" ? message2 : (0, import_element156.renderToString)(message2);
    (0, import_element156.useEffect)(() => {
      if (spokenMessage) {
        (0, import_a11y7.speak)(spokenMessage, politeness);
      }
    }, [spokenMessage, politeness]);
  }
  function getDefaultPoliteness(status) {
    switch (status) {
      case "success":
      case "warning":
      case "info":
        return "polite";
      // The default will also catch the 'error' status.
      default:
        return "assertive";
    }
  }
  function getStatusLabel(status) {
    switch (status) {
      case "warning":
        return (0, import_i18n61.__)("Warning notice");
      case "info":
        return (0, import_i18n61.__)("Information notice");
      case "error":
        return (0, import_i18n61.__)("Error notice");
      // The default will also catch the 'success' status.
      default:
        return (0, import_i18n61.__)("Notice");
    }
  }
  function Notice({
    className: className2,
    status = "info",
    children,
    spokenMessage = children,
    onRemove = noop19,
    isDismissible = true,
    actions = [],
    politeness = getDefaultPoliteness(status),
    __unstableHTML,
    // onDismiss is a callback executed when the notice is dismissed.
    // It is distinct from onRemove, which _looks_ like a callback but is
    // actually the function to call to remove the notice from the UI.
    onDismiss = noop19
  }) {
    useSpokenMessage(spokenMessage, politeness);
    const classes = clsx_default(className2, "components-notice", "is-" + status);
    if (__unstableHTML && typeof children === "string") {
      children = /* @__PURE__ */ (0, import_jsx_runtime234.jsx)(import_element156.RawHTML, {
        children
      });
    }
    const onDismissNotice = () => {
      onDismiss();
      onRemove();
    };
    return /* @__PURE__ */ (0, import_jsx_runtime234.jsxs)("div", {
      className: classes,
      children: [/* @__PURE__ */ (0, import_jsx_runtime234.jsx)(component_default2, {
        children: getStatusLabel(status)
      }), /* @__PURE__ */ (0, import_jsx_runtime234.jsx)("div", {
        className: "components-notice__content",
        children
      }), actions.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime234.jsx)("div", {
        className: "components-notice__actions",
        children: actions.map(({
          className: buttonCustomClasses,
          label,
          isPrimary,
          variant,
          noDefaultClasses = false,
          onClick,
          url,
          disabled
        }, index2) => {
          let computedVariant = variant;
          if (variant !== "primary" && !noDefaultClasses) {
            computedVariant = !url ? "secondary" : "link";
          }
          if (typeof computedVariant === "undefined" && isPrimary) {
            computedVariant = "primary";
          }
          return /* @__PURE__ */ (0, import_jsx_runtime234.jsx)(button_default, {
            size: "compact",
            href: url,
            variant: computedVariant,
            onClick,
            disabled,
            accessibleWhenDisabled: true,
            className: clsx_default("components-notice__action", buttonCustomClasses),
            children: label
          }, index2);
        })
      }), isDismissible && /* @__PURE__ */ (0, import_jsx_runtime234.jsx)(button_default, {
        size: "small",
        className: "components-notice__dismiss",
        icon: close_small_default,
        label: (0, import_i18n61.__)("Close"),
        onClick: onDismissNotice
      })]
    });
  }
  var notice_default = Notice;

  // packages/components/build-module/notice/list.mjs
  var import_react114 = __toESM(require_react(), 1);
  var import_jsx_runtime235 = __toESM(require_jsx_runtime(), 1);
  var noop20 = () => {
  };
  function NoticeList({
    notices,
    onRemove = noop20,
    className: className2,
    children
  }) {
    const removeNotice = (id3) => () => onRemove(id3);
    className2 = clsx_default("components-notice-list", className2);
    return /* @__PURE__ */ (0, import_jsx_runtime235.jsxs)("div", {
      className: className2,
      children: [children, [...notices].reverse().map((notice) => {
        const {
          content,
          ...restNotice
        } = notice;
        return /* @__PURE__ */ (0, import_react114.createElement)(notice_default, {
          ...restNotice,
          key: notice.id,
          onRemove: removeNotice(notice.id)
        }, notice.content);
      })]
    });
  }
  var list_default = NoticeList;

  // packages/components/build-module/panel/index.mjs
  var import_element157 = __toESM(require_element(), 1);

  // packages/components/build-module/panel/header.mjs
  var import_jsx_runtime236 = __toESM(require_jsx_runtime(), 1);
  function PanelHeader({
    label,
    children
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime236.jsxs)("div", {
      className: "components-panel__header",
      children: [label && /* @__PURE__ */ (0, import_jsx_runtime236.jsx)("h2", {
        children: label
      }), children]
    });
  }
  var header_default = PanelHeader;

  // packages/components/build-module/panel/index.mjs
  var import_jsx_runtime237 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedPanel({
    header,
    className: className2,
    children
  }, ref) {
    const classNames = clsx_default(className2, "components-panel");
    return /* @__PURE__ */ (0, import_jsx_runtime237.jsxs)("div", {
      className: classNames,
      ref,
      children: [header && /* @__PURE__ */ (0, import_jsx_runtime237.jsx)(header_default, {
        label: header
      }), children]
    });
  }
  var Panel = (0, import_element157.forwardRef)(UnforwardedPanel);
  Panel.displayName = "Panel";
  var panel_default = Panel;

  // packages/components/build-module/panel/body.mjs
  var import_compose64 = __toESM(require_compose(), 1);
  var import_element158 = __toESM(require_element(), 1);
  var import_jsx_runtime238 = __toESM(require_jsx_runtime(), 1);
  var noop21 = () => {
  };
  function UnforwardedPanelBody(props, ref) {
    const {
      buttonProps = {},
      children,
      className: className2,
      icon,
      initialOpen,
      onToggle = noop21,
      opened,
      title,
      scrollAfterOpen = true
    } = props;
    const [isOpened, setIsOpened] = use_controlled_state_default(opened, {
      initial: initialOpen === void 0 ? true : initialOpen,
      fallback: false
    });
    const nodeRef = (0, import_element158.useRef)(null);
    const scrollBehavior = (0, import_compose64.useReducedMotion)() ? "auto" : "smooth";
    const handleOnToggle = (event) => {
      event.preventDefault();
      const next2 = !isOpened;
      setIsOpened(next2);
      onToggle(next2);
    };
    const scrollAfterOpenRef = (0, import_element158.useRef)(void 0);
    scrollAfterOpenRef.current = scrollAfterOpen;
    use_update_effect_default(() => {
      if (isOpened && scrollAfterOpenRef.current && nodeRef.current?.scrollIntoView) {
        nodeRef.current.scrollIntoView({
          inline: "nearest",
          block: "nearest",
          behavior: scrollBehavior
        });
      }
    }, [isOpened, scrollBehavior]);
    const classes = clsx_default("components-panel__body", className2, {
      "is-opened": isOpened
    });
    return /* @__PURE__ */ (0, import_jsx_runtime238.jsxs)("div", {
      className: classes,
      ref: (0, import_compose64.useMergeRefs)([nodeRef, ref]),
      children: [/* @__PURE__ */ (0, import_jsx_runtime238.jsx)(PanelBodyTitle, {
        icon,
        isOpened: Boolean(isOpened),
        onClick: handleOnToggle,
        title,
        ...buttonProps
      }), typeof children === "function" ? children({
        opened: Boolean(isOpened)
      }) : isOpened && children]
    });
  }
  var PanelBodyTitle = (0, import_element158.forwardRef)(({
    isOpened,
    icon,
    title,
    ...props
  }, ref) => {
    if (!title) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime238.jsx)("h2", {
      className: "components-panel__body-title",
      children: /* @__PURE__ */ (0, import_jsx_runtime238.jsxs)(button_default, {
        __next40pxDefaultSize: true,
        className: "components-panel__body-toggle",
        "aria-expanded": isOpened,
        ref,
        ...props,
        children: [/* @__PURE__ */ (0, import_jsx_runtime238.jsx)("span", {
          "aria-hidden": "true",
          children: /* @__PURE__ */ (0, import_jsx_runtime238.jsx)(icon_default3, {
            className: "components-panel__arrow",
            icon: isOpened ? chevron_up_default : chevron_down_default
          })
        }), title, icon && /* @__PURE__ */ (0, import_jsx_runtime238.jsx)(icon_default3, {
          icon,
          className: "components-panel__icon",
          size: 20
        })]
      })
    });
  });
  var PanelBody = (0, import_element158.forwardRef)(UnforwardedPanelBody);
  PanelBody.displayName = "PanelBody";
  var body_default = PanelBody;

  // packages/components/build-module/panel/row.mjs
  var import_element159 = __toESM(require_element(), 1);
  var import_jsx_runtime239 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedPanelRow({
    className: className2,
    children
  }, ref) {
    return /* @__PURE__ */ (0, import_jsx_runtime239.jsx)("div", {
      className: clsx_default("components-panel__row", className2),
      ref,
      children
    });
  }
  var PanelRow = (0, import_element159.forwardRef)(UnforwardedPanelRow);
  PanelRow.displayName = "PanelRow";
  var row_default = PanelRow;

  // packages/components/build-module/placeholder/index.mjs
  var import_compose65 = __toESM(require_compose(), 1);
  var import_primitives33 = __toESM(require_primitives(), 1);
  var import_element160 = __toESM(require_element(), 1);
  var import_a11y8 = __toESM(require_a11y(), 1);
  var import_jsx_runtime240 = __toESM(require_jsx_runtime(), 1);
  var PlaceholderIllustration = /* @__PURE__ */ (0, import_jsx_runtime240.jsx)(import_primitives33.SVG, {
    className: "components-placeholder__illustration",
    fill: "none",
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 60 60",
    preserveAspectRatio: "none",
    children: /* @__PURE__ */ (0, import_jsx_runtime240.jsx)(import_primitives33.Path, {
      vectorEffect: "non-scaling-stroke",
      d: "M60 60 0 0"
    })
  });
  function Placeholder(props) {
    const {
      icon,
      children,
      label,
      instructions,
      className: className2,
      notices,
      preview,
      isColumnLayout,
      withIllustration,
      ...additionalProps
    } = props;
    const [resizeListener, {
      width
    }] = (0, import_compose65.useResizeObserver)();
    let modifierClassNames;
    if (typeof width === "number") {
      modifierClassNames = {
        "is-large": width >= 480,
        "is-medium": width >= 160 && width < 480,
        "is-small": width < 160
      };
    }
    const classes = clsx_default("components-placeholder", className2, modifierClassNames, withIllustration ? "has-illustration" : null);
    const fieldsetClasses = clsx_default("components-placeholder__fieldset", {
      "is-column-layout": isColumnLayout
    });
    (0, import_element160.useEffect)(() => {
      if (instructions) {
        (0, import_a11y8.speak)(instructions);
      }
    }, [instructions]);
    return /* @__PURE__ */ (0, import_jsx_runtime240.jsxs)("div", {
      ...additionalProps,
      className: classes,
      children: [withIllustration ? PlaceholderIllustration : null, resizeListener, notices, preview && /* @__PURE__ */ (0, import_jsx_runtime240.jsx)("div", {
        className: "components-placeholder__preview",
        children: preview
      }), /* @__PURE__ */ (0, import_jsx_runtime240.jsxs)("div", {
        className: "components-placeholder__label",
        children: [/* @__PURE__ */ (0, import_jsx_runtime240.jsx)(icon_default3, {
          icon
        }), label]
      }), !!instructions && /* @__PURE__ */ (0, import_jsx_runtime240.jsx)("div", {
        className: "components-placeholder__instructions",
        children: instructions
      }), /* @__PURE__ */ (0, import_jsx_runtime240.jsx)("div", {
        className: fieldsetClasses,
        children
      })]
    });
  }
  var placeholder_default = Placeholder;

  // packages/components/build-module/progress-bar/index.mjs
  var import_i18n63 = __toESM(require_i18n(), 1);
  var import_element161 = __toESM(require_element(), 1);

  // packages/components/build-module/progress-bar/styles.mjs
  var import_i18n62 = __toESM(require_i18n(), 1);
  function _EMOTION_STRINGIFIED_CSS_ERROR__32() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  function animateProgressBar(isRtl = false) {
    const animationDirection = isRtl ? "right" : "left";
    return keyframes2({
      "0%": {
        [animationDirection]: "-50%"
      },
      "100%": {
        [animationDirection]: "100%"
      }
    });
  }
  var INDETERMINATE_TRACK_WIDTH = 50;
  var Track2 = /* @__PURE__ */ createStyled("div", false ? {
    target: "e15u147w2"
  } : {
    target: "e15u147w2",
    label: "Track"
  })("position:relative;overflow:hidden;height:", config_values_default.borderWidthFocus, ";background-color:color-mix(\n		in srgb,\n		", COLORS.theme.foreground, ",\n		transparent 90%\n	);border-radius:", config_values_default.radiusFull, ";outline:2px solid transparent;outline-offset:2px;:where( & ){width:160px;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var _ref7 = false ? {
    name: "152sa26",
    styles: "width:var(--indicator-width);transition:width 0.4s ease-in-out"
  } : {
    name: "1ox6xu8-Indicator",
    styles: "width:var(--indicator-width);transition:width 0.4s ease-in-out;label:Indicator;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__32
  };
  var Indicator = /* @__PURE__ */ createStyled("div", false ? {
    target: "e15u147w1"
  } : {
    target: "e15u147w1",
    label: "Indicator"
  })("display:inline-block;position:absolute;top:0;height:100%;border-radius:", config_values_default.radiusFull, ";background-color:color-mix(\n		in srgb,\n		", COLORS.theme.foreground, ",\n		transparent 10%\n	);outline:2px solid transparent;outline-offset:-2px;", ({
    isIndeterminate
  }) => isIndeterminate ? /* @__PURE__ */ css({
    animationDuration: "1.5s",
    animationTimingFunction: "ease-in-out",
    animationIterationCount: "infinite",
    animationName: animateProgressBar((0, import_i18n62.isRTL)()),
    width: `${INDETERMINATE_TRACK_WIDTH}%`
  }, false ? "" : ";label:Indicator;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */") : _ref7, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));
  var ProgressElement = /* @__PURE__ */ createStyled("progress", false ? {
    target: "e15u147w0"
  } : {
    target: "e15u147w0",
    label: "ProgressElement"
  })(false ? {
    name: "11fb690",
    styles: "position:absolute;top:0;left:0;opacity:0;width:100%;height:100%"
  } : {
    name: "11fb690",
    styles: "position:absolute;top:0;left:0;opacity:0;width:100%;height:100%/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__32
  });

  // packages/components/build-module/progress-bar/index.mjs
  var import_jsx_runtime241 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedProgressBar(props, ref) {
    const {
      className: className2,
      value,
      ...progressProps
    } = props;
    const isIndeterminate = !Number.isFinite(value);
    return /* @__PURE__ */ (0, import_jsx_runtime241.jsxs)(Track2, {
      className: className2,
      children: [/* @__PURE__ */ (0, import_jsx_runtime241.jsx)(Indicator, {
        style: {
          "--indicator-width": !isIndeterminate ? `${value}%` : void 0
        },
        isIndeterminate
      }), /* @__PURE__ */ (0, import_jsx_runtime241.jsx)(ProgressElement, {
        max: 100,
        value,
        "aria-label": (0, import_i18n63.__)("Loading \u2026"),
        ref,
        ...progressProps
      })]
    });
  }
  var ProgressBar = (0, import_element161.forwardRef)(UnforwardedProgressBar);
  ProgressBar.displayName = "ProgressBar";
  var progress_bar_default = ProgressBar;

  // packages/components/build-module/query-controls/index.mjs
  var import_i18n64 = __toESM(require_i18n(), 1);

  // packages/components/build-module/query-controls/terms.mjs
  var ensureParentsAreDefined = (terms) => {
    return terms.every((term) => term.parent !== null);
  };
  function buildTermsTree(flatTerms) {
    const flatTermsWithParentAndChildren = flatTerms.map((term) => ({
      children: [],
      parent: null,
      ...term,
      id: String(term.id)
    }));
    if (!ensureParentsAreDefined(flatTermsWithParentAndChildren)) {
      return flatTermsWithParentAndChildren;
    }
    const termsByParent = flatTermsWithParentAndChildren.reduce((acc, term) => {
      const {
        parent
      } = term;
      if (!acc[parent]) {
        acc[parent] = [];
      }
      acc[parent].push(term);
      return acc;
    }, {});
    const fillWithChildren = (terms) => {
      return terms.map((term) => {
        const children = termsByParent[term.id];
        return {
          ...term,
          children: children && children.length ? fillWithChildren(children) : []
        };
      });
    };
    return fillWithChildren(termsByParent["0"] || []);
  }

  // packages/components/build-module/tree-select/index.mjs
  var import_element162 = __toESM(require_element(), 1);
  var import_html_entities = __toESM(require_html_entities(), 1);
  var import_jsx_runtime242 = __toESM(require_jsx_runtime(), 1);
  function getSelectOptions(tree, level = 0) {
    return tree.flatMap((treeNode) => [{
      value: treeNode.id,
      label: "\xA0".repeat(level * 3) + (0, import_html_entities.decodeEntities)(treeNode.name)
    }, ...getSelectOptions(treeNode.children || [], level + 1)]);
  }
  function TreeSelect(props) {
    const {
      // Prevent passing legacy props to internal component.
      __nextHasNoMarginBottom: _2,
      __next40pxDefaultSize: _next40pxDefaultSize,
      label,
      noOptionLabel,
      onChange,
      selectedId,
      tree = [],
      ...restProps
    } = props;
    const options2 = (0, import_element162.useMemo)(() => {
      return [noOptionLabel && {
        value: "",
        label: noOptionLabel
      }, ...getSelectOptions(tree)].filter((option) => !!option);
    }, [noOptionLabel, tree]);
    return /* @__PURE__ */ (0, import_jsx_runtime242.jsx)(SelectControl, {
      label,
      options: options2,
      onChange,
      value: selectedId,
      ...restProps
    });
  }
  var tree_select_default = TreeSelect;

  // packages/components/build-module/query-controls/author-select.mjs
  var import_jsx_runtime243 = __toESM(require_jsx_runtime(), 1);
  function AuthorSelect({
    label,
    noOptionLabel,
    authorList,
    selectedAuthorId,
    onChange: onChangeProp
  }) {
    if (!authorList) {
      return null;
    }
    const termsTree = buildTermsTree(authorList);
    return /* @__PURE__ */ (0, import_jsx_runtime243.jsx)(tree_select_default, {
      label,
      noOptionLabel,
      onChange: onChangeProp,
      tree: termsTree,
      selectedId: selectedAuthorId !== void 0 ? String(selectedAuthorId) : void 0
    });
  }

  // packages/components/build-module/query-controls/category-select.mjs
  var import_element163 = __toESM(require_element(), 1);
  var import_jsx_runtime244 = __toESM(require_jsx_runtime(), 1);
  function CategorySelect({
    label,
    noOptionLabel,
    categoriesList,
    selectedCategoryId,
    onChange: onChangeProp,
    ...props
  }) {
    const termsTree = (0, import_element163.useMemo)(() => {
      return buildTermsTree(categoriesList);
    }, [categoriesList]);
    return /* @__PURE__ */ (0, import_jsx_runtime244.jsx)(tree_select_default, {
      label,
      noOptionLabel,
      onChange: onChangeProp,
      tree: termsTree,
      selectedId: selectedCategoryId !== void 0 ? String(selectedCategoryId) : void 0,
      ...props
    });
  }

  // packages/components/build-module/query-controls/index.mjs
  var import_jsx_runtime245 = __toESM(require_jsx_runtime(), 1);
  var DEFAULT_MIN_ITEMS = 1;
  var DEFAULT_MAX_ITEMS = 100;
  var MAX_CATEGORIES_SUGGESTIONS = 20;
  function isSingleCategorySelection(props) {
    return "categoriesList" in props;
  }
  function isMultipleCategorySelection(props) {
    return "categorySuggestions" in props;
  }
  var defaultOrderByOptions = [{
    label: (0, import_i18n64.__)("Newest to oldest"),
    value: "date/desc"
  }, {
    label: (0, import_i18n64.__)("Oldest to newest"),
    value: "date/asc"
  }, {
    /* translators: Label for ordering posts by title in ascending order. */
    label: (0, import_i18n64.__)("A \u2192 Z"),
    value: "title/asc"
  }, {
    /* translators: Label for ordering posts by title in descending order. */
    label: (0, import_i18n64.__)("Z \u2192 A"),
    value: "title/desc"
  }];
  function QueryControls({
    authorList,
    selectedAuthorId,
    numberOfItems,
    order,
    orderBy,
    orderByOptions = defaultOrderByOptions,
    maxItems = DEFAULT_MAX_ITEMS,
    minItems = DEFAULT_MIN_ITEMS,
    onAuthorChange,
    onNumberOfItemsChange,
    onOrderChange,
    onOrderByChange,
    // Props for single OR multiple category selection are not destructured here,
    // but instead are destructured inline where necessary.
    ...props
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime245.jsx)(component_default18, {
      spacing: "4",
      className: "components-query-controls",
      children: [onOrderChange && onOrderByChange && /* @__PURE__ */ (0, import_jsx_runtime245.jsx)(select_control_default, {
        label: (0, import_i18n64.__)("Order by"),
        value: orderBy === void 0 || order === void 0 ? void 0 : `${orderBy}/${order}`,
        options: orderByOptions,
        onChange: (value) => {
          if (typeof value !== "string") {
            return;
          }
          const [newOrderBy, newOrder] = value.split("/");
          if (newOrder !== order) {
            onOrderChange(newOrder);
          }
          if (newOrderBy !== orderBy) {
            onOrderByChange(newOrderBy);
          }
        }
      }, "query-controls-order-select"), isSingleCategorySelection(props) && props.categoriesList && props.onCategoryChange && /* @__PURE__ */ (0, import_jsx_runtime245.jsx)(CategorySelect, {
        categoriesList: props.categoriesList,
        label: (0, import_i18n64.__)("Category"),
        noOptionLabel: (0, import_i18n64._x)("All", "categories"),
        selectedCategoryId: props.selectedCategoryId,
        onChange: props.onCategoryChange
      }, "query-controls-category-select"), isMultipleCategorySelection(props) && props.categorySuggestions && props.onCategoryChange && /* @__PURE__ */ (0, import_jsx_runtime245.jsx)(form_token_field_default, {
        label: (0, import_i18n64.__)("Categories"),
        value: props.selectedCategories && props.selectedCategories.map((item2) => ({
          id: item2.id,
          // Keeping the fallback to `item.value` for legacy reasons,
          // even if items of `selectedCategories` should not have a
          // `value` property.
          // @ts-expect-error
          value: item2.name || item2.value
        })),
        suggestions: Object.keys(props.categorySuggestions),
        onChange: props.onCategoryChange,
        maxSuggestions: MAX_CATEGORIES_SUGGESTIONS
      }, "query-controls-categories-select"), onAuthorChange && /* @__PURE__ */ (0, import_jsx_runtime245.jsx)(AuthorSelect, {
        authorList,
        label: (0, import_i18n64.__)("Author"),
        noOptionLabel: (0, import_i18n64._x)("All", "authors"),
        selectedAuthorId,
        onChange: onAuthorChange
      }, "query-controls-author-select"), onNumberOfItemsChange && /* @__PURE__ */ (0, import_jsx_runtime245.jsx)(range_control_default, {
        label: (0, import_i18n64.__)("Number of items"),
        value: numberOfItems,
        onChange: onNumberOfItemsChange,
        min: minItems,
        max: maxItems,
        required: true
      }, "query-controls-range-control")]
    });
  }
  var query_controls_default = QueryControls;

  // packages/components/build-module/radio-group/radio.mjs
  var import_element165 = __toESM(require_element(), 1);

  // packages/components/build-module/radio-group/context.mjs
  var import_element164 = __toESM(require_element(), 1);
  var RadioGroupContext = (0, import_element164.createContext)({
    store: void 0,
    disabled: void 0
  });
  RadioGroupContext.displayName = "RadioGroupContext";

  // packages/components/build-module/radio-group/radio.mjs
  var import_jsx_runtime246 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedRadio({
    value,
    children,
    __next40pxDefaultSize: _next40pxDefaultSize,
    ...props
  }, ref) {
    const {
      store,
      disabled
    } = (0, import_element165.useContext)(RadioGroupContext);
    const selectedValue = useStoreState(store, "value");
    const isChecked = selectedValue !== void 0 && selectedValue === value;
    return /* @__PURE__ */ (0, import_jsx_runtime246.jsx)(Radio, {
      disabled,
      store,
      ref,
      value,
      render: /* @__PURE__ */ (0, import_jsx_runtime246.jsx)(button_default, {
        variant: isChecked ? "primary" : "secondary",
        __next40pxDefaultSize: true,
        ...props
      }),
      children: children || value
    });
  }
  var Radio22 = (0, import_element165.forwardRef)(UnforwardedRadio);
  Radio22.displayName = "Radio";
  var radio_default = Radio22;

  // packages/components/build-module/radio-group/index.mjs
  var import_deprecated21 = __toESM(require_deprecated(), 1);
  var import_element166 = __toESM(require_element(), 1);
  var import_i18n65 = __toESM(require_i18n(), 1);
  var import_jsx_runtime247 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedRadioGroup({
    label,
    checked,
    defaultChecked,
    disabled,
    onChange,
    children,
    ...props
  }, ref) {
    const radioStore = useRadioStore({
      value: checked,
      defaultValue: defaultChecked,
      setValue: (newValue) => {
        onChange?.(newValue ?? void 0);
      },
      rtl: (0, import_i18n65.isRTL)()
    });
    const contextValue = (0, import_element166.useMemo)(() => ({
      store: radioStore,
      disabled
    }), [radioStore, disabled]);
    (0, import_deprecated21.default)("wp.components.__experimentalRadioGroup", {
      alternative: "wp.components.RadioControl or wp.components.__experimentalToggleGroupControl",
      since: "6.8"
    });
    return /* @__PURE__ */ (0, import_jsx_runtime247.jsx)(RadioGroupContext.Provider, {
      value: contextValue,
      children: /* @__PURE__ */ (0, import_jsx_runtime247.jsx)(RadioGroup, {
        store: radioStore,
        render: /* @__PURE__ */ (0, import_jsx_runtime247.jsx)(button_group_default, {
          __shouldNotWarnDeprecated: true,
          children
        }),
        "aria-label": label,
        ref,
        ...props
      })
    });
  }
  var RadioGroup22 = (0, import_element166.forwardRef)(UnforwardedRadioGroup);
  RadioGroup22.displayName = "RadioGroup";
  var radio_group_default = RadioGroup22;

  // packages/components/build-module/radio-control/index.mjs
  var import_compose66 = __toESM(require_compose(), 1);
  var import_jsx_runtime248 = __toESM(require_jsx_runtime(), 1);
  function generateOptionDescriptionId(radioGroupId, index2) {
    return `${radioGroupId}-${index2}-option-description`;
  }
  function generateOptionId(radioGroupId, index2) {
    return `${radioGroupId}-${index2}`;
  }
  function generateHelpId(radioGroupId) {
    return `${radioGroupId}__help`;
  }
  function RadioControl(props) {
    const {
      label,
      className: className2,
      selected,
      help,
      onChange,
      onClick,
      hideLabelFromVision,
      disabled,
      options: options2 = [],
      id: preferredId,
      ...additionalProps
    } = props;
    const id3 = (0, import_compose66.useInstanceId)(RadioControl, "inspector-radio-control", preferredId);
    const onChangeValue = (event) => onChange(event.target.value);
    if (!options2?.length) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime248.jsxs)("fieldset", {
      id: id3,
      role: "radiogroup",
      className: clsx_default(className2, "components-radio-control"),
      disabled,
      "aria-describedby": !!help ? generateHelpId(id3) : void 0,
      children: [hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime248.jsx)(component_default2, {
        as: "legend",
        children: label
      }) : /* @__PURE__ */ (0, import_jsx_runtime248.jsx)(base_control_default.VisualLabel, {
        as: "legend",
        children: label
      }), /* @__PURE__ */ (0, import_jsx_runtime248.jsx)(component_default18, {
        spacing: 3,
        className: clsx_default("components-radio-control__group-wrapper", {
          "has-help": !!help
        }),
        children: options2.map((option, index2) => /* @__PURE__ */ (0, import_jsx_runtime248.jsxs)("div", {
          className: "components-radio-control__option",
          children: [/* @__PURE__ */ (0, import_jsx_runtime248.jsx)("input", {
            id: generateOptionId(id3, index2),
            className: "components-radio-control__input",
            type: "radio",
            name: id3,
            value: option.value,
            onChange: onChangeValue,
            checked: option.value === selected,
            "aria-describedby": !!option.description ? generateOptionDescriptionId(id3, index2) : void 0,
            onClick: (event) => {
              event.currentTarget.focus();
              onClick?.(event);
            },
            ...additionalProps
          }), /* @__PURE__ */ (0, import_jsx_runtime248.jsx)("label", {
            className: "components-radio-control__label",
            htmlFor: generateOptionId(id3, index2),
            children: option.label
          }), !!option.description ? /* @__PURE__ */ (0, import_jsx_runtime248.jsx)(StyledHelp, {
            id: generateOptionDescriptionId(id3, index2),
            className: "components-radio-control__option-description",
            children: option.description
          }) : null]
        }, generateOptionId(id3, index2)))
      }), !!help && /* @__PURE__ */ (0, import_jsx_runtime248.jsx)(StyledHelp, {
        id: generateHelpId(id3),
        className: "components-base-control__help",
        children: help
      })]
    });
  }
  var radio_control_default = RadioControl;

  // packages/components/build-module/resizable-box/index.mjs
  var import_element170 = __toESM(require_element(), 1);

  // node_modules/re-resizable/lib/index.js
  var React12 = __toESM(require_react());

  // node_modules/re-resizable/lib/resizer.js
  var React11 = __toESM(require_react());
  var __extends = /* @__PURE__ */ (function() {
    var extendStatics = function(d3, b3) {
      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d4, b4) {
        d4.__proto__ = b4;
      } || function(d4, b4) {
        for (var p3 in b4) if (b4.hasOwnProperty(p3)) d4[p3] = b4[p3];
      };
      return extendStatics(d3, b3);
    };
    return function(d3, b3) {
      extendStatics(d3, b3);
      function __63() {
        this.constructor = d3;
      }
      d3.prototype = b3 === null ? Object.create(b3) : (__63.prototype = b3.prototype, new __63());
    };
  })();
  var __assign2 = function() {
    __assign2 = Object.assign || function(t4) {
      for (var s3, i3 = 1, n3 = arguments.length; i3 < n3; i3++) {
        s3 = arguments[i3];
        for (var p3 in s3) if (Object.prototype.hasOwnProperty.call(s3, p3))
          t4[p3] = s3[p3];
      }
      return t4;
    };
    return __assign2.apply(this, arguments);
  };
  var styles2 = {
    top: {
      width: "100%",
      height: "10px",
      top: "-5px",
      left: "0px",
      cursor: "row-resize"
    },
    right: {
      width: "10px",
      height: "100%",
      top: "0px",
      right: "-5px",
      cursor: "col-resize"
    },
    bottom: {
      width: "100%",
      height: "10px",
      bottom: "-5px",
      left: "0px",
      cursor: "row-resize"
    },
    left: {
      width: "10px",
      height: "100%",
      top: "0px",
      left: "-5px",
      cursor: "col-resize"
    },
    topRight: {
      width: "20px",
      height: "20px",
      position: "absolute",
      right: "-10px",
      top: "-10px",
      cursor: "ne-resize"
    },
    bottomRight: {
      width: "20px",
      height: "20px",
      position: "absolute",
      right: "-10px",
      bottom: "-10px",
      cursor: "se-resize"
    },
    bottomLeft: {
      width: "20px",
      height: "20px",
      position: "absolute",
      left: "-10px",
      bottom: "-10px",
      cursor: "sw-resize"
    },
    topLeft: {
      width: "20px",
      height: "20px",
      position: "absolute",
      left: "-10px",
      top: "-10px",
      cursor: "nw-resize"
    }
  };
  var Resizer = (
    /** @class */
    (function(_super) {
      __extends(Resizer2, _super);
      function Resizer2() {
        var _this = _super !== null && _super.apply(this, arguments) || this;
        _this.onMouseDown = function(e3) {
          _this.props.onResizeStart(e3, _this.props.direction);
        };
        _this.onTouchStart = function(e3) {
          _this.props.onResizeStart(e3, _this.props.direction);
        };
        return _this;
      }
      Resizer2.prototype.render = function() {
        return React11.createElement("div", { className: this.props.className || "", style: __assign2(__assign2({ position: "absolute", userSelect: "none" }, styles2[this.props.direction]), this.props.replaceStyles || {}), onMouseDown: this.onMouseDown, onTouchStart: this.onTouchStart }, this.props.children);
      };
      return Resizer2;
    })(React11.PureComponent)
  );

  // node_modules/re-resizable/lib/index.js
  var import_fast_memoize = __toESM(require_src());
  var __extends2 = /* @__PURE__ */ (function() {
    var extendStatics = function(d3, b3) {
      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d4, b4) {
        d4.__proto__ = b4;
      } || function(d4, b4) {
        for (var p3 in b4) if (b4.hasOwnProperty(p3)) d4[p3] = b4[p3];
      };
      return extendStatics(d3, b3);
    };
    return function(d3, b3) {
      extendStatics(d3, b3);
      function __63() {
        this.constructor = d3;
      }
      d3.prototype = b3 === null ? Object.create(b3) : (__63.prototype = b3.prototype, new __63());
    };
  })();
  var __assign3 = function() {
    __assign3 = Object.assign || function(t4) {
      for (var s3, i3 = 1, n3 = arguments.length; i3 < n3; i3++) {
        s3 = arguments[i3];
        for (var p3 in s3) if (Object.prototype.hasOwnProperty.call(s3, p3))
          t4[p3] = s3[p3];
      }
      return t4;
    };
    return __assign3.apply(this, arguments);
  };
  var DEFAULT_SIZE = {
    width: "auto",
    height: "auto"
  };
  var clamp5 = (0, import_fast_memoize.default)(function(n3, min3, max3) {
    return Math.max(Math.min(n3, max3), min3);
  });
  var snap = (0, import_fast_memoize.default)(function(n3, size4) {
    return Math.round(n3 / size4) * size4;
  });
  var hasDirection = (0, import_fast_memoize.default)(function(dir, target) {
    return new RegExp(dir, "i").test(target);
  });
  var isTouchEvent = function(event) {
    return Boolean(event.touches && event.touches.length);
  };
  var isMouseEvent = function(event) {
    return Boolean((event.clientX || event.clientX === 0) && (event.clientY || event.clientY === 0));
  };
  var findClosestSnap = (0, import_fast_memoize.default)(function(n3, snapArray, snapGap) {
    if (snapGap === void 0) {
      snapGap = 0;
    }
    var closestGapIndex = snapArray.reduce(function(prev2, curr, index2) {
      return Math.abs(curr - n3) < Math.abs(snapArray[prev2] - n3) ? index2 : prev2;
    }, 0);
    var gap = Math.abs(snapArray[closestGapIndex] - n3);
    return snapGap === 0 || gap < snapGap ? snapArray[closestGapIndex] : n3;
  });
  var endsWith = (0, import_fast_memoize.default)(function(str, searchStr) {
    return str.substr(str.length - searchStr.length, searchStr.length) === searchStr;
  });
  var getStringSize = (0, import_fast_memoize.default)(function(n3) {
    n3 = n3.toString();
    if (n3 === "auto") {
      return n3;
    }
    if (endsWith(n3, "px")) {
      return n3;
    }
    if (endsWith(n3, "%")) {
      return n3;
    }
    if (endsWith(n3, "vh")) {
      return n3;
    }
    if (endsWith(n3, "vw")) {
      return n3;
    }
    if (endsWith(n3, "vmax")) {
      return n3;
    }
    if (endsWith(n3, "vmin")) {
      return n3;
    }
    return n3 + "px";
  });
  var getPixelSize = function(size4, parentSize, innerWidth, innerHeight) {
    if (size4 && typeof size4 === "string") {
      if (endsWith(size4, "px")) {
        return Number(size4.replace("px", ""));
      }
      if (endsWith(size4, "%")) {
        var ratio = Number(size4.replace("%", "")) / 100;
        return parentSize * ratio;
      }
      if (endsWith(size4, "vw")) {
        var ratio = Number(size4.replace("vw", "")) / 100;
        return innerWidth * ratio;
      }
      if (endsWith(size4, "vh")) {
        var ratio = Number(size4.replace("vh", "")) / 100;
        return innerHeight * ratio;
      }
    }
    return size4;
  };
  var calculateNewMax = (0, import_fast_memoize.default)(function(parentSize, innerWidth, innerHeight, maxWidth, maxHeight, minWidth, minHeight) {
    maxWidth = getPixelSize(maxWidth, parentSize.width, innerWidth, innerHeight);
    maxHeight = getPixelSize(maxHeight, parentSize.height, innerWidth, innerHeight);
    minWidth = getPixelSize(minWidth, parentSize.width, innerWidth, innerHeight);
    minHeight = getPixelSize(minHeight, parentSize.height, innerWidth, innerHeight);
    return {
      maxWidth: typeof maxWidth === "undefined" ? void 0 : Number(maxWidth),
      maxHeight: typeof maxHeight === "undefined" ? void 0 : Number(maxHeight),
      minWidth: typeof minWidth === "undefined" ? void 0 : Number(minWidth),
      minHeight: typeof minHeight === "undefined" ? void 0 : Number(minHeight)
    };
  });
  var definedProps = [
    "as",
    "style",
    "className",
    "grid",
    "snap",
    "bounds",
    "boundsByDirection",
    "size",
    "defaultSize",
    "minWidth",
    "minHeight",
    "maxWidth",
    "maxHeight",
    "lockAspectRatio",
    "lockAspectRatioExtraWidth",
    "lockAspectRatioExtraHeight",
    "enable",
    "handleStyles",
    "handleClasses",
    "handleWrapperStyle",
    "handleWrapperClass",
    "children",
    "onResizeStart",
    "onResize",
    "onResizeStop",
    "handleComponent",
    "scale",
    "resizeRatio",
    "snapGap"
  ];
  var baseClassName = "__resizable_base__";
  var Resizable = (
    /** @class */
    (function(_super) {
      __extends2(Resizable2, _super);
      function Resizable2(props) {
        var _this = _super.call(this, props) || this;
        _this.ratio = 1;
        _this.resizable = null;
        _this.parentLeft = 0;
        _this.parentTop = 0;
        _this.resizableLeft = 0;
        _this.resizableRight = 0;
        _this.resizableTop = 0;
        _this.resizableBottom = 0;
        _this.targetLeft = 0;
        _this.targetTop = 0;
        _this.appendBase = function() {
          if (!_this.resizable || !_this.window) {
            return null;
          }
          var parent = _this.parentNode;
          if (!parent) {
            return null;
          }
          var element = _this.window.document.createElement("div");
          element.style.width = "100%";
          element.style.height = "100%";
          element.style.position = "absolute";
          element.style.transform = "scale(0, 0)";
          element.style.left = "0";
          element.style.flex = "0";
          if (element.classList) {
            element.classList.add(baseClassName);
          } else {
            element.className += baseClassName;
          }
          parent.appendChild(element);
          return element;
        };
        _this.removeBase = function(base) {
          var parent = _this.parentNode;
          if (!parent) {
            return;
          }
          parent.removeChild(base);
        };
        _this.ref = function(c3) {
          if (c3) {
            _this.resizable = c3;
          }
        };
        _this.state = {
          isResizing: false,
          width: typeof (_this.propsSize && _this.propsSize.width) === "undefined" ? "auto" : _this.propsSize && _this.propsSize.width,
          height: typeof (_this.propsSize && _this.propsSize.height) === "undefined" ? "auto" : _this.propsSize && _this.propsSize.height,
          direction: "right",
          original: {
            x: 0,
            y: 0,
            width: 0,
            height: 0
          },
          backgroundStyle: {
            height: "100%",
            width: "100%",
            backgroundColor: "rgba(0,0,0,0)",
            cursor: "auto",
            opacity: 0,
            position: "fixed",
            zIndex: 9999,
            top: "0",
            left: "0",
            bottom: "0",
            right: "0"
          },
          flexBasis: void 0
        };
        _this.onResizeStart = _this.onResizeStart.bind(_this);
        _this.onMouseMove = _this.onMouseMove.bind(_this);
        _this.onMouseUp = _this.onMouseUp.bind(_this);
        return _this;
      }
      Object.defineProperty(Resizable2.prototype, "parentNode", {
        get: function() {
          if (!this.resizable) {
            return null;
          }
          return this.resizable.parentNode;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Resizable2.prototype, "window", {
        get: function() {
          if (!this.resizable) {
            return null;
          }
          if (!this.resizable.ownerDocument) {
            return null;
          }
          return this.resizable.ownerDocument.defaultView;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Resizable2.prototype, "propsSize", {
        get: function() {
          return this.props.size || this.props.defaultSize || DEFAULT_SIZE;
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Resizable2.prototype, "size", {
        get: function() {
          var width = 0;
          var height = 0;
          if (this.resizable && this.window) {
            var orgWidth = this.resizable.offsetWidth;
            var orgHeight = this.resizable.offsetHeight;
            var orgPosition = this.resizable.style.position;
            if (orgPosition !== "relative") {
              this.resizable.style.position = "relative";
            }
            width = this.resizable.style.width !== "auto" ? this.resizable.offsetWidth : orgWidth;
            height = this.resizable.style.height !== "auto" ? this.resizable.offsetHeight : orgHeight;
            this.resizable.style.position = orgPosition;
          }
          return { width, height };
        },
        enumerable: false,
        configurable: true
      });
      Object.defineProperty(Resizable2.prototype, "sizeStyle", {
        get: function() {
          var _this = this;
          var size4 = this.props.size;
          var getSize = function(key) {
            if (typeof _this.state[key] === "undefined" || _this.state[key] === "auto") {
              return "auto";
            }
            if (_this.propsSize && _this.propsSize[key] && endsWith(_this.propsSize[key].toString(), "%")) {
              if (endsWith(_this.state[key].toString(), "%")) {
                return _this.state[key].toString();
              }
              var parentSize = _this.getParentSize();
              var value = Number(_this.state[key].toString().replace("px", ""));
              var percent2 = value / parentSize[key] * 100;
              return percent2 + "%";
            }
            return getStringSize(_this.state[key]);
          };
          var width = size4 && typeof size4.width !== "undefined" && !this.state.isResizing ? getStringSize(size4.width) : getSize("width");
          var height = size4 && typeof size4.height !== "undefined" && !this.state.isResizing ? getStringSize(size4.height) : getSize("height");
          return { width, height };
        },
        enumerable: false,
        configurable: true
      });
      Resizable2.prototype.getParentSize = function() {
        if (!this.parentNode) {
          if (!this.window) {
            return { width: 0, height: 0 };
          }
          return { width: this.window.innerWidth, height: this.window.innerHeight };
        }
        var base = this.appendBase();
        if (!base) {
          return { width: 0, height: 0 };
        }
        var wrapChanged = false;
        var wrap = this.parentNode.style.flexWrap;
        if (wrap !== "wrap") {
          wrapChanged = true;
          this.parentNode.style.flexWrap = "wrap";
        }
        base.style.position = "relative";
        base.style.minWidth = "100%";
        var size4 = {
          width: base.offsetWidth,
          height: base.offsetHeight
        };
        if (wrapChanged) {
          this.parentNode.style.flexWrap = wrap;
        }
        this.removeBase(base);
        return size4;
      };
      Resizable2.prototype.bindEvents = function() {
        if (this.window) {
          this.window.addEventListener("mouseup", this.onMouseUp);
          this.window.addEventListener("mousemove", this.onMouseMove);
          this.window.addEventListener("mouseleave", this.onMouseUp);
          this.window.addEventListener("touchmove", this.onMouseMove, {
            capture: true,
            passive: false
          });
          this.window.addEventListener("touchend", this.onMouseUp);
        }
      };
      Resizable2.prototype.unbindEvents = function() {
        if (this.window) {
          this.window.removeEventListener("mouseup", this.onMouseUp);
          this.window.removeEventListener("mousemove", this.onMouseMove);
          this.window.removeEventListener("mouseleave", this.onMouseUp);
          this.window.removeEventListener("touchmove", this.onMouseMove, true);
          this.window.removeEventListener("touchend", this.onMouseUp);
        }
      };
      Resizable2.prototype.componentDidMount = function() {
        if (!this.resizable || !this.window) {
          return;
        }
        var computedStyle = this.window.getComputedStyle(this.resizable);
        this.setState({
          width: this.state.width || this.size.width,
          height: this.state.height || this.size.height,
          flexBasis: computedStyle.flexBasis !== "auto" ? computedStyle.flexBasis : void 0
        });
      };
      Resizable2.prototype.componentWillUnmount = function() {
        if (this.window) {
          this.unbindEvents();
        }
      };
      Resizable2.prototype.createSizeForCssProperty = function(newSize, kind) {
        var propsSize = this.propsSize && this.propsSize[kind];
        return this.state[kind] === "auto" && this.state.original[kind] === newSize && (typeof propsSize === "undefined" || propsSize === "auto") ? "auto" : newSize;
      };
      Resizable2.prototype.calculateNewMaxFromBoundary = function(maxWidth, maxHeight) {
        var boundsByDirection = this.props.boundsByDirection;
        var direction = this.state.direction;
        var widthByDirection = boundsByDirection && hasDirection("left", direction);
        var heightByDirection = boundsByDirection && hasDirection("top", direction);
        var boundWidth;
        var boundHeight;
        if (this.props.bounds === "parent") {
          var parent_1 = this.parentNode;
          if (parent_1) {
            boundWidth = widthByDirection ? this.resizableRight - this.parentLeft : parent_1.offsetWidth + (this.parentLeft - this.resizableLeft);
            boundHeight = heightByDirection ? this.resizableBottom - this.parentTop : parent_1.offsetHeight + (this.parentTop - this.resizableTop);
          }
        } else if (this.props.bounds === "window") {
          if (this.window) {
            boundWidth = widthByDirection ? this.resizableRight : this.window.innerWidth - this.resizableLeft;
            boundHeight = heightByDirection ? this.resizableBottom : this.window.innerHeight - this.resizableTop;
          }
        } else if (this.props.bounds) {
          boundWidth = widthByDirection ? this.resizableRight - this.targetLeft : this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft);
          boundHeight = heightByDirection ? this.resizableBottom - this.targetTop : this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop);
        }
        if (boundWidth && Number.isFinite(boundWidth)) {
          maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth;
        }
        if (boundHeight && Number.isFinite(boundHeight)) {
          maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight;
        }
        return { maxWidth, maxHeight };
      };
      Resizable2.prototype.calculateNewSizeFromDirection = function(clientX, clientY) {
        var scale2 = this.props.scale || 1;
        var resizeRatio = this.props.resizeRatio || 1;
        var _a = this.state, direction = _a.direction, original = _a.original;
        var _b = this.props, lockAspectRatio = _b.lockAspectRatio, lockAspectRatioExtraHeight = _b.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _b.lockAspectRatioExtraWidth;
        var newWidth = original.width;
        var newHeight = original.height;
        var extraHeight = lockAspectRatioExtraHeight || 0;
        var extraWidth = lockAspectRatioExtraWidth || 0;
        if (hasDirection("right", direction)) {
          newWidth = original.width + (clientX - original.x) * resizeRatio / scale2;
          if (lockAspectRatio) {
            newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;
          }
        }
        if (hasDirection("left", direction)) {
          newWidth = original.width - (clientX - original.x) * resizeRatio / scale2;
          if (lockAspectRatio) {
            newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;
          }
        }
        if (hasDirection("bottom", direction)) {
          newHeight = original.height + (clientY - original.y) * resizeRatio / scale2;
          if (lockAspectRatio) {
            newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;
          }
        }
        if (hasDirection("top", direction)) {
          newHeight = original.height - (clientY - original.y) * resizeRatio / scale2;
          if (lockAspectRatio) {
            newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;
          }
        }
        return { newWidth, newHeight };
      };
      Resizable2.prototype.calculateNewSizeFromAspectRatio = function(newWidth, newHeight, max3, min3) {
        var _a = this.props, lockAspectRatio = _a.lockAspectRatio, lockAspectRatioExtraHeight = _a.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _a.lockAspectRatioExtraWidth;
        var computedMinWidth = typeof min3.width === "undefined" ? 10 : min3.width;
        var computedMaxWidth = typeof max3.width === "undefined" || max3.width < 0 ? newWidth : max3.width;
        var computedMinHeight = typeof min3.height === "undefined" ? 10 : min3.height;
        var computedMaxHeight = typeof max3.height === "undefined" || max3.height < 0 ? newHeight : max3.height;
        var extraHeight = lockAspectRatioExtraHeight || 0;
        var extraWidth = lockAspectRatioExtraWidth || 0;
        if (lockAspectRatio) {
          var extraMinWidth = (computedMinHeight - extraHeight) * this.ratio + extraWidth;
          var extraMaxWidth = (computedMaxHeight - extraHeight) * this.ratio + extraWidth;
          var extraMinHeight = (computedMinWidth - extraWidth) / this.ratio + extraHeight;
          var extraMaxHeight = (computedMaxWidth - extraWidth) / this.ratio + extraHeight;
          var lockedMinWidth = Math.max(computedMinWidth, extraMinWidth);
          var lockedMaxWidth = Math.min(computedMaxWidth, extraMaxWidth);
          var lockedMinHeight = Math.max(computedMinHeight, extraMinHeight);
          var lockedMaxHeight = Math.min(computedMaxHeight, extraMaxHeight);
          newWidth = clamp5(newWidth, lockedMinWidth, lockedMaxWidth);
          newHeight = clamp5(newHeight, lockedMinHeight, lockedMaxHeight);
        } else {
          newWidth = clamp5(newWidth, computedMinWidth, computedMaxWidth);
          newHeight = clamp5(newHeight, computedMinHeight, computedMaxHeight);
        }
        return { newWidth, newHeight };
      };
      Resizable2.prototype.setBoundingClientRect = function() {
        if (this.props.bounds === "parent") {
          var parent_2 = this.parentNode;
          if (parent_2) {
            var parentRect = parent_2.getBoundingClientRect();
            this.parentLeft = parentRect.left;
            this.parentTop = parentRect.top;
          }
        }
        if (this.props.bounds && typeof this.props.bounds !== "string") {
          var targetRect = this.props.bounds.getBoundingClientRect();
          this.targetLeft = targetRect.left;
          this.targetTop = targetRect.top;
        }
        if (this.resizable) {
          var _a = this.resizable.getBoundingClientRect(), left = _a.left, top_1 = _a.top, right = _a.right, bottom = _a.bottom;
          this.resizableLeft = left;
          this.resizableRight = right;
          this.resizableTop = top_1;
          this.resizableBottom = bottom;
        }
      };
      Resizable2.prototype.onResizeStart = function(event, direction) {
        if (!this.resizable || !this.window) {
          return;
        }
        var clientX = 0;
        var clientY = 0;
        if (event.nativeEvent && isMouseEvent(event.nativeEvent)) {
          clientX = event.nativeEvent.clientX;
          clientY = event.nativeEvent.clientY;
          if (event.nativeEvent.which === 3) {
            return;
          }
        } else if (event.nativeEvent && isTouchEvent(event.nativeEvent)) {
          clientX = event.nativeEvent.touches[0].clientX;
          clientY = event.nativeEvent.touches[0].clientY;
        }
        if (this.props.onResizeStart) {
          if (this.resizable) {
            var startResize = this.props.onResizeStart(event, direction, this.resizable);
            if (startResize === false) {
              return;
            }
          }
        }
        if (this.props.size) {
          if (typeof this.props.size.height !== "undefined" && this.props.size.height !== this.state.height) {
            this.setState({ height: this.props.size.height });
          }
          if (typeof this.props.size.width !== "undefined" && this.props.size.width !== this.state.width) {
            this.setState({ width: this.props.size.width });
          }
        }
        this.ratio = typeof this.props.lockAspectRatio === "number" ? this.props.lockAspectRatio : this.size.width / this.size.height;
        var flexBasis;
        var computedStyle = this.window.getComputedStyle(this.resizable);
        if (computedStyle.flexBasis !== "auto") {
          var parent_3 = this.parentNode;
          if (parent_3) {
            var dir = this.window.getComputedStyle(parent_3).flexDirection;
            this.flexDir = dir.startsWith("row") ? "row" : "column";
            flexBasis = computedStyle.flexBasis;
          }
        }
        this.setBoundingClientRect();
        this.bindEvents();
        var state = {
          original: {
            x: clientX,
            y: clientY,
            width: this.size.width,
            height: this.size.height
          },
          isResizing: true,
          backgroundStyle: __assign3(__assign3({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(event.target).cursor || "auto" }),
          direction,
          flexBasis
        };
        this.setState(state);
      };
      Resizable2.prototype.onMouseMove = function(event) {
        if (!this.state.isResizing || !this.resizable || !this.window) {
          return;
        }
        if (this.window.TouchEvent && isTouchEvent(event)) {
          try {
            event.preventDefault();
            event.stopPropagation();
          } catch (e3) {
          }
        }
        var _a = this.props, maxWidth = _a.maxWidth, maxHeight = _a.maxHeight, minWidth = _a.minWidth, minHeight = _a.minHeight;
        var clientX = isTouchEvent(event) ? event.touches[0].clientX : event.clientX;
        var clientY = isTouchEvent(event) ? event.touches[0].clientY : event.clientY;
        var _b = this.state, direction = _b.direction, original = _b.original, width = _b.width, height = _b.height;
        var parentSize = this.getParentSize();
        var max3 = calculateNewMax(parentSize, this.window.innerWidth, this.window.innerHeight, maxWidth, maxHeight, minWidth, minHeight);
        maxWidth = max3.maxWidth;
        maxHeight = max3.maxHeight;
        minWidth = max3.minWidth;
        minHeight = max3.minHeight;
        var _c = this.calculateNewSizeFromDirection(clientX, clientY), newHeight = _c.newHeight, newWidth = _c.newWidth;
        var boundaryMax = this.calculateNewMaxFromBoundary(maxWidth, maxHeight);
        var newSize = this.calculateNewSizeFromAspectRatio(newWidth, newHeight, { width: boundaryMax.maxWidth, height: boundaryMax.maxHeight }, { width: minWidth, height: minHeight });
        newWidth = newSize.newWidth;
        newHeight = newSize.newHeight;
        if (this.props.grid) {
          var newGridWidth = snap(newWidth, this.props.grid[0]);
          var newGridHeight = snap(newHeight, this.props.grid[1]);
          var gap = this.props.snapGap || 0;
          newWidth = gap === 0 || Math.abs(newGridWidth - newWidth) <= gap ? newGridWidth : newWidth;
          newHeight = gap === 0 || Math.abs(newGridHeight - newHeight) <= gap ? newGridHeight : newHeight;
        }
        if (this.props.snap && this.props.snap.x) {
          newWidth = findClosestSnap(newWidth, this.props.snap.x, this.props.snapGap);
        }
        if (this.props.snap && this.props.snap.y) {
          newHeight = findClosestSnap(newHeight, this.props.snap.y, this.props.snapGap);
        }
        var delta = {
          width: newWidth - original.width,
          height: newHeight - original.height
        };
        if (width && typeof width === "string") {
          if (endsWith(width, "%")) {
            var percent2 = newWidth / parentSize.width * 100;
            newWidth = percent2 + "%";
          } else if (endsWith(width, "vw")) {
            var vw2 = newWidth / this.window.innerWidth * 100;
            newWidth = vw2 + "vw";
          } else if (endsWith(width, "vh")) {
            var vh2 = newWidth / this.window.innerHeight * 100;
            newWidth = vh2 + "vh";
          }
        }
        if (height && typeof height === "string") {
          if (endsWith(height, "%")) {
            var percent2 = newHeight / parentSize.height * 100;
            newHeight = percent2 + "%";
          } else if (endsWith(height, "vw")) {
            var vw2 = newHeight / this.window.innerWidth * 100;
            newHeight = vw2 + "vw";
          } else if (endsWith(height, "vh")) {
            var vh2 = newHeight / this.window.innerHeight * 100;
            newHeight = vh2 + "vh";
          }
        }
        var newState = {
          width: this.createSizeForCssProperty(newWidth, "width"),
          height: this.createSizeForCssProperty(newHeight, "height")
        };
        if (this.flexDir === "row") {
          newState.flexBasis = newState.width;
        } else if (this.flexDir === "column") {
          newState.flexBasis = newState.height;
        }
        this.setState(newState);
        if (this.props.onResize) {
          this.props.onResize(event, direction, this.resizable, delta);
        }
      };
      Resizable2.prototype.onMouseUp = function(event) {
        var _a = this.state, isResizing = _a.isResizing, direction = _a.direction, original = _a.original;
        if (!isResizing || !this.resizable) {
          return;
        }
        var delta = {
          width: this.size.width - original.width,
          height: this.size.height - original.height
        };
        if (this.props.onResizeStop) {
          this.props.onResizeStop(event, direction, this.resizable, delta);
        }
        if (this.props.size) {
          this.setState(this.props.size);
        }
        this.unbindEvents();
        this.setState({
          isResizing: false,
          backgroundStyle: __assign3(__assign3({}, this.state.backgroundStyle), { cursor: "auto" })
        });
      };
      Resizable2.prototype.updateSize = function(size4) {
        this.setState({ width: size4.width, height: size4.height });
      };
      Resizable2.prototype.renderResizer = function() {
        var _this = this;
        var _a = this.props, enable = _a.enable, handleStyles = _a.handleStyles, handleClasses = _a.handleClasses, handleWrapperStyle = _a.handleWrapperStyle, handleWrapperClass = _a.handleWrapperClass, handleComponent = _a.handleComponent;
        if (!enable) {
          return null;
        }
        var resizers = Object.keys(enable).map(function(dir) {
          if (enable[dir] !== false) {
            return React12.createElement(Resizer, { key: dir, direction: dir, onResizeStart: _this.onResizeStart, replaceStyles: handleStyles && handleStyles[dir], className: handleClasses && handleClasses[dir] }, handleComponent && handleComponent[dir] ? handleComponent[dir] : null);
          }
          return null;
        });
        return React12.createElement("div", { className: handleWrapperClass, style: handleWrapperStyle }, resizers);
      };
      Resizable2.prototype.render = function() {
        var _this = this;
        var extendsProps = Object.keys(this.props).reduce(function(acc, key) {
          if (definedProps.indexOf(key) !== -1) {
            return acc;
          }
          acc[key] = _this.props[key];
          return acc;
        }, {});
        var style2 = __assign3(__assign3(__assign3({ position: "relative", userSelect: this.state.isResizing ? "none" : "auto" }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: "border-box", flexShrink: 0 });
        if (this.state.flexBasis) {
          style2.flexBasis = this.state.flexBasis;
        }
        var Wrapper6 = this.props.as || "div";
        return React12.createElement(
          Wrapper6,
          __assign3({ ref: this.ref, style: style2, className: this.props.className }, extendsProps),
          this.state.isResizing && React12.createElement("div", { style: this.state.backgroundStyle }),
          this.props.children,
          this.renderResizer()
        );
      };
      Resizable2.defaultProps = {
        as: "div",
        onResizeStart: function() {
        },
        onResize: function() {
        },
        onResizeStop: function() {
        },
        enable: {
          top: true,
          right: true,
          bottom: true,
          left: true,
          topRight: true,
          bottomRight: true,
          bottomLeft: true,
          topLeft: true
        },
        style: {},
        grid: [1, 1],
        lockAspectRatio: false,
        lockAspectRatioExtraWidth: 0,
        lockAspectRatioExtraHeight: 0,
        scale: 1,
        resizeRatio: 1,
        snapGap: 0
      };
      return Resizable2;
    })(React12.PureComponent)
  );

  // packages/components/build-module/resizable-box/resize-tooltip/index.mjs
  var import_element169 = __toESM(require_element(), 1);

  // packages/components/build-module/resizable-box/resize-tooltip/label.mjs
  var import_element168 = __toESM(require_element(), 1);
  var import_i18n66 = __toESM(require_i18n(), 1);

  // packages/components/build-module/resizable-box/resize-tooltip/utils.mjs
  var import_element167 = __toESM(require_element(), 1);
  var import_compose67 = __toESM(require_compose(), 1);
  var noop22 = () => {
  };
  var POSITIONS = {
    bottom: "bottom",
    corner: "corner"
  };
  function useResizeLabel({
    axis,
    fadeTimeout = 180,
    onResize = noop22,
    position: position2 = POSITIONS.bottom,
    showPx = false
  }) {
    const [resizeListener, sizes] = (0, import_compose67.useResizeObserver)();
    const isAxisControlled = !!axis;
    const [moveX, setMoveX] = (0, import_element167.useState)(false);
    const [moveY, setMoveY] = (0, import_element167.useState)(false);
    const {
      width,
      height
    } = sizes;
    const heightRef = (0, import_element167.useRef)(height);
    const widthRef = (0, import_element167.useRef)(width);
    const moveTimeoutRef = (0, import_element167.useRef)(void 0);
    const debounceUnsetMoveXY = (0, import_element167.useCallback)(() => {
      const unsetMoveXY = () => {
        if (isAxisControlled) {
          return;
        }
        setMoveX(false);
        setMoveY(false);
      };
      if (moveTimeoutRef.current) {
        window.clearTimeout(moveTimeoutRef.current);
      }
      moveTimeoutRef.current = window.setTimeout(unsetMoveXY, fadeTimeout);
    }, [fadeTimeout, isAxisControlled]);
    (0, import_element167.useEffect)(() => {
      const isRendered = width !== null || height !== null;
      if (!isRendered) {
        return;
      }
      const didWidthChange = width !== widthRef.current;
      const didHeightChange = height !== heightRef.current;
      if (!didWidthChange && !didHeightChange) {
        return;
      }
      if (width && !widthRef.current && height && !heightRef.current) {
        widthRef.current = width;
        heightRef.current = height;
        return;
      }
      if (didWidthChange) {
        setMoveX(true);
        widthRef.current = width;
      }
      if (didHeightChange) {
        setMoveY(true);
        heightRef.current = height;
      }
      onResize({
        width,
        height
      });
      debounceUnsetMoveXY();
    }, [width, height, onResize, debounceUnsetMoveXY]);
    const label = getSizeLabel({
      axis,
      height,
      moveX,
      moveY,
      position: position2,
      showPx,
      width
    });
    return {
      label,
      resizeListener
    };
  }
  function getSizeLabel({
    axis,
    height,
    moveX = false,
    moveY = false,
    position: position2 = POSITIONS.bottom,
    showPx = false,
    width
  }) {
    if (!moveX && !moveY) {
      return void 0;
    }
    if (position2 === POSITIONS.corner) {
      return `${width} x ${height}`;
    }
    const labelUnit = showPx ? " px" : "";
    if (axis) {
      if (axis === "x" && moveX) {
        return `${width}${labelUnit}`;
      }
      if (axis === "y" && moveY) {
        return `${height}${labelUnit}`;
      }
    }
    if (moveX && moveY) {
      return `${width} x ${height}`;
    }
    if (moveX) {
      return `${width}${labelUnit}`;
    }
    if (moveY) {
      return `${height}${labelUnit}`;
    }
    return void 0;
  }

  // packages/components/build-module/resizable-box/resize-tooltip/styles/resize-tooltip.styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__33() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var Root4 = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1wq7y4k3"
  } : {
    target: "e1wq7y4k3",
    label: "Root"
  })(false ? {
    name: "1cd7zoc",
    styles: "bottom:0;box-sizing:border-box;left:0;pointer-events:none;position:absolute;right:0;top:0"
  } : {
    name: "1cd7zoc",
    styles: "bottom:0;box-sizing:border-box;left:0;pointer-events:none;position:absolute;right:0;top:0/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJlc2l6ZS10b29sdGlwLnN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXOEIiLCJmaWxlIjoicmVzaXplLXRvb2x0aXAuc3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBUZXh0IH0gZnJvbSAnLi4vLi4vLi4vdGV4dCc7XG5pbXBvcnQgeyBmb250LCBDT0xPUlMsIENPTkZJRyB9IGZyb20gJy4uLy4uLy4uL3V0aWxzJztcblxuZXhwb3J0IGNvbnN0IFJvb3QgPSBzdHlsZWQuZGl2YFxuXHRib3R0b206IDA7XG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGxlZnQ6IDA7XG5cdHBvaW50ZXItZXZlbnRzOiBub25lO1xuXHRwb3NpdGlvbjogYWJzb2x1dGU7XG5cdHJpZ2h0OiAwO1xuXHR0b3A6IDA7XG5gO1xuXG5leHBvcnQgY29uc3QgVG9vbHRpcFdyYXBwZXIgPSBzdHlsZWQuZGl2YFxuXHRhbGlnbi1pdGVtczogY2VudGVyO1xuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHRkaXNwbGF5OiBpbmxpbmUtZmxleDtcblx0anVzdGlmeS1jb250ZW50OiBjZW50ZXI7XG5cdG9wYWNpdHk6IDA7XG5cdHBvaW50ZXItZXZlbnRzOiBub25lO1xuXHR0cmFuc2l0aW9uOiBvcGFjaXR5IDEyMG1zIGxpbmVhcjtcbmA7XG5cbmV4cG9ydCBjb25zdCBUb29sdGlwID0gc3R5bGVkLmRpdmBcblx0YmFja2dyb3VuZDogJHsgQ09MT1JTLnRoZW1lLmZvcmVncm91bmQgfTtcblx0Ym9yZGVyLXJhZGl1czogJHsgQ09ORklHLnJhZGl1c1NtYWxsIH07XG5cdGJveC1zaXppbmc6IGJvcmRlci1ib3g7XG5cdGZvbnQtZmFtaWx5OiAkeyBmb250KCAnZGVmYXVsdC5mb250RmFtaWx5JyApIH07XG5cdGZvbnQtc2l6ZTogMTJweDtcblx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5mb3JlZ3JvdW5kSW52ZXJ0ZWQgfTtcblx0cGFkZGluZzogNHB4IDhweDtcblx0cG9zaXRpb246IHJlbGF0aXZlO1xuYDtcblxuLy8gVE9ETzogUmVzb2x2ZSBuZWVkIHRvIHVzZSAmJiYgdG8gaW5jcmVhc2Ugc3BlY2lmaWNpdHlcbi8vIGh0dHBzOi8vZ2l0aHViLmNvbS9Xb3JkUHJlc3MvZ3V0ZW5iZXJnL2lzc3Vlcy8xODQ4M1xuXG5leHBvcnQgY29uc3QgTGFiZWxUZXh0ID0gc3R5bGVkKCBUZXh0IClgXG5cdCYmJiB7XG5cdFx0Y29sb3I6ICR7IENPTE9SUy50aGVtZS5mb3JlZ3JvdW5kSW52ZXJ0ZWQgfTtcblx0XHRkaXNwbGF5OiBibG9jaztcblx0XHRmb250LXNpemU6IDEzcHg7XG5cdFx0bGluZS1oZWlnaHQ6IDEuNDtcblx0XHR3aGl0ZS1zcGFjZTogbm93cmFwO1xuXHR9XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__33
  });
  var TooltipWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1wq7y4k2"
  } : {
    target: "e1wq7y4k2",
    label: "TooltipWrapper"
  })(false ? {
    name: "ajymcs",
    styles: "align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;opacity:0;pointer-events:none;transition:opacity 120ms linear"
  } : {
    name: "ajymcs",
    styles: "align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;opacity:0;pointer-events:none;transition:opacity 120ms linear/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJlc2l6ZS10b29sdGlwLnN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFxQndDIiwiZmlsZSI6InJlc2l6ZS10b29sdGlwLnN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgVGV4dCB9IGZyb20gJy4uLy4uLy4uL3RleHQnO1xuaW1wb3J0IHsgZm9udCwgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi8uLi8uLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLmRpdmBcblx0Ym90dG9tOiAwO1xuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHRsZWZ0OiAwO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHRyaWdodDogMDtcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFRvb2x0aXBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0YWxpZ24taXRlbXM6IGNlbnRlcjtcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogaW5saW5lLWZsZXg7XG5cdGp1c3RpZnktY29udGVudDogY2VudGVyO1xuXHRvcGFjaXR5OiAwO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0dHJhbnNpdGlvbjogb3BhY2l0eSAxMjBtcyBsaW5lYXI7XG5gO1xuXG5leHBvcnQgY29uc3QgVG9vbHRpcCA9IHN0eWxlZC5kaXZgXG5cdGJhY2tncm91bmQ6ICR7IENPTE9SUy50aGVtZS5mb3JlZ3JvdW5kIH07XG5cdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHRmb250LWZhbWlseTogJHsgZm9udCggJ2RlZmF1bHQuZm9udEZhbWlseScgKSB9O1xuXHRmb250LXNpemU6IDEycHg7XG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuZm9yZWdyb3VuZEludmVydGVkIH07XG5cdHBhZGRpbmc6IDRweCA4cHg7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbi8vIFRPRE86IFJlc29sdmUgbmVlZCB0byB1c2UgJiYmIHRvIGluY3JlYXNlIHNwZWNpZmljaXR5XG4vLyBodHRwczovL2dpdGh1Yi5jb20vV29yZFByZXNzL2d1dGVuYmVyZy9pc3N1ZXMvMTg0ODNcblxuZXhwb3J0IGNvbnN0IExhYmVsVGV4dCA9IHN0eWxlZCggVGV4dCApYFxuXHQmJiYge1xuXHRcdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuZm9yZWdyb3VuZEludmVydGVkIH07XG5cdFx0ZGlzcGxheTogYmxvY2s7XG5cdFx0Zm9udC1zaXplOiAxM3B4O1xuXHRcdGxpbmUtaGVpZ2h0OiAxLjQ7XG5cdFx0d2hpdGUtc3BhY2U6IG5vd3JhcDtcblx0fVxuYDtcbiJdfQ== */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__33
  });
  var Tooltip4 = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1wq7y4k1"
  } : {
    target: "e1wq7y4k1",
    label: "Tooltip"
  })("background:", COLORS.theme.foreground, ";border-radius:", config_values_default.radiusSmall, ";box-sizing:border-box;font-family:", font("default.fontFamily"), ";font-size:12px;color:", COLORS.theme.foregroundInverted, ";padding:4px 8px;position:relative;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJlc2l6ZS10b29sdGlwLnN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUErQmlDIiwiZmlsZSI6InJlc2l6ZS10b29sdGlwLnN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgVGV4dCB9IGZyb20gJy4uLy4uLy4uL3RleHQnO1xuaW1wb3J0IHsgZm9udCwgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi8uLi8uLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLmRpdmBcblx0Ym90dG9tOiAwO1xuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHRsZWZ0OiAwO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHRyaWdodDogMDtcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFRvb2x0aXBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0YWxpZ24taXRlbXM6IGNlbnRlcjtcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogaW5saW5lLWZsZXg7XG5cdGp1c3RpZnktY29udGVudDogY2VudGVyO1xuXHRvcGFjaXR5OiAwO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0dHJhbnNpdGlvbjogb3BhY2l0eSAxMjBtcyBsaW5lYXI7XG5gO1xuXG5leHBvcnQgY29uc3QgVG9vbHRpcCA9IHN0eWxlZC5kaXZgXG5cdGJhY2tncm91bmQ6ICR7IENPTE9SUy50aGVtZS5mb3JlZ3JvdW5kIH07XG5cdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHRmb250LWZhbWlseTogJHsgZm9udCggJ2RlZmF1bHQuZm9udEZhbWlseScgKSB9O1xuXHRmb250LXNpemU6IDEycHg7XG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuZm9yZWdyb3VuZEludmVydGVkIH07XG5cdHBhZGRpbmc6IDRweCA4cHg7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbi8vIFRPRE86IFJlc29sdmUgbmVlZCB0byB1c2UgJiYmIHRvIGluY3JlYXNlIHNwZWNpZmljaXR5XG4vLyBodHRwczovL2dpdGh1Yi5jb20vV29yZFByZXNzL2d1dGVuYmVyZy9pc3N1ZXMvMTg0ODNcblxuZXhwb3J0IGNvbnN0IExhYmVsVGV4dCA9IHN0eWxlZCggVGV4dCApYFxuXHQmJiYge1xuXHRcdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuZm9yZWdyb3VuZEludmVydGVkIH07XG5cdFx0ZGlzcGxheTogYmxvY2s7XG5cdFx0Zm9udC1zaXplOiAxM3B4O1xuXHRcdGxpbmUtaGVpZ2h0OiAxLjQ7XG5cdFx0d2hpdGUtc3BhY2U6IG5vd3JhcDtcblx0fVxuYDtcbiJdfQ== */"));
  var LabelText = /* @__PURE__ */ createStyled(component_default8, false ? {
    target: "e1wq7y4k0"
  } : {
    target: "e1wq7y4k0",
    label: "LabelText"
  })("&&&{color:", COLORS.theme.foregroundInverted, ";display:block;font-size:13px;line-height:1.4;white-space:nowrap;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInJlc2l6ZS10b29sdGlwLnN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUE2Q3VDIiwiZmlsZSI6InJlc2l6ZS10b29sdGlwLnN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgVGV4dCB9IGZyb20gJy4uLy4uLy4uL3RleHQnO1xuaW1wb3J0IHsgZm9udCwgQ09MT1JTLCBDT05GSUcgfSBmcm9tICcuLi8uLi8uLi91dGlscyc7XG5cbmV4cG9ydCBjb25zdCBSb290ID0gc3R5bGVkLmRpdmBcblx0Ym90dG9tOiAwO1xuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHRsZWZ0OiAwO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0cG9zaXRpb246IGFic29sdXRlO1xuXHRyaWdodDogMDtcblx0dG9wOiAwO1xuYDtcblxuZXhwb3J0IGNvbnN0IFRvb2x0aXBXcmFwcGVyID0gc3R5bGVkLmRpdmBcblx0YWxpZ24taXRlbXM6IGNlbnRlcjtcblx0Ym94LXNpemluZzogYm9yZGVyLWJveDtcblx0ZGlzcGxheTogaW5saW5lLWZsZXg7XG5cdGp1c3RpZnktY29udGVudDogY2VudGVyO1xuXHRvcGFjaXR5OiAwO1xuXHRwb2ludGVyLWV2ZW50czogbm9uZTtcblx0dHJhbnNpdGlvbjogb3BhY2l0eSAxMjBtcyBsaW5lYXI7XG5gO1xuXG5leHBvcnQgY29uc3QgVG9vbHRpcCA9IHN0eWxlZC5kaXZgXG5cdGJhY2tncm91bmQ6ICR7IENPTE9SUy50aGVtZS5mb3JlZ3JvdW5kIH07XG5cdGJvcmRlci1yYWRpdXM6ICR7IENPTkZJRy5yYWRpdXNTbWFsbCB9O1xuXHRib3gtc2l6aW5nOiBib3JkZXItYm94O1xuXHRmb250LWZhbWlseTogJHsgZm9udCggJ2RlZmF1bHQuZm9udEZhbWlseScgKSB9O1xuXHRmb250LXNpemU6IDEycHg7XG5cdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuZm9yZWdyb3VuZEludmVydGVkIH07XG5cdHBhZGRpbmc6IDRweCA4cHg7XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcbmA7XG5cbi8vIFRPRE86IFJlc29sdmUgbmVlZCB0byB1c2UgJiYmIHRvIGluY3JlYXNlIHNwZWNpZmljaXR5XG4vLyBodHRwczovL2dpdGh1Yi5jb20vV29yZFByZXNzL2d1dGVuYmVyZy9pc3N1ZXMvMTg0ODNcblxuZXhwb3J0IGNvbnN0IExhYmVsVGV4dCA9IHN0eWxlZCggVGV4dCApYFxuXHQmJiYge1xuXHRcdGNvbG9yOiAkeyBDT0xPUlMudGhlbWUuZm9yZWdyb3VuZEludmVydGVkIH07XG5cdFx0ZGlzcGxheTogYmxvY2s7XG5cdFx0Zm9udC1zaXplOiAxM3B4O1xuXHRcdGxpbmUtaGVpZ2h0OiAxLjQ7XG5cdFx0d2hpdGUtc3BhY2U6IG5vd3JhcDtcblx0fVxuYDtcbiJdfQ== */"));

  // packages/components/build-module/resizable-box/resize-tooltip/label.mjs
  var import_jsx_runtime249 = __toESM(require_jsx_runtime(), 1);
  var CORNER_OFFSET = 4;
  var CURSOR_OFFSET_TOP = CORNER_OFFSET * 2.5;
  function Label3({
    label,
    position: position2 = POSITIONS.corner,
    zIndex = 1e3,
    ...props
  }, ref) {
    const showLabel = !!label;
    const isBottom = position2 === POSITIONS.bottom;
    const isCorner = position2 === POSITIONS.corner;
    if (!showLabel) {
      return null;
    }
    let style2 = {
      opacity: showLabel ? 1 : void 0,
      zIndex
    };
    let labelStyle = {};
    if (isBottom) {
      style2 = {
        ...style2,
        position: "absolute",
        bottom: CURSOR_OFFSET_TOP * -1,
        left: "50%",
        transform: "translate(-50%, 0)"
      };
      labelStyle = {
        transform: `translate(0, 100%)`
      };
    }
    if (isCorner) {
      style2 = {
        ...style2,
        position: "absolute",
        top: CORNER_OFFSET,
        right: (0, import_i18n66.isRTL)() ? void 0 : CORNER_OFFSET,
        left: (0, import_i18n66.isRTL)() ? CORNER_OFFSET : void 0
      };
    }
    return /* @__PURE__ */ (0, import_jsx_runtime249.jsx)(TooltipWrapper, {
      "aria-hidden": "true",
      className: "components-resizable-tooltip__tooltip-wrapper",
      ref,
      style: style2,
      ...props,
      children: /* @__PURE__ */ (0, import_jsx_runtime249.jsx)(Tooltip4, {
        className: "components-resizable-tooltip__tooltip",
        style: labelStyle,
        children: /* @__PURE__ */ (0, import_jsx_runtime249.jsx)(LabelText, {
          as: "span",
          children: label
        })
      })
    });
  }
  var ForwardedComponent3 = (0, import_element168.forwardRef)(Label3);
  var label_default = ForwardedComponent3;

  // packages/components/build-module/resizable-box/resize-tooltip/index.mjs
  var import_jsx_runtime250 = __toESM(require_jsx_runtime(), 1);
  var noop23 = () => {
  };
  function ResizeTooltip({
    axis,
    className: className2,
    fadeTimeout = 180,
    isVisible: isVisible2 = true,
    labelRef,
    onResize = noop23,
    position: position2 = POSITIONS.bottom,
    showPx = true,
    zIndex = 1e3,
    ...props
  }, ref) {
    const {
      label,
      resizeListener
    } = useResizeLabel({
      axis,
      fadeTimeout,
      onResize,
      showPx,
      position: position2
    });
    if (!isVisible2) {
      return null;
    }
    const classes = clsx_default("components-resize-tooltip", className2);
    return /* @__PURE__ */ (0, import_jsx_runtime250.jsxs)(Root4, {
      "aria-hidden": "true",
      className: classes,
      ref,
      ...props,
      children: [resizeListener, /* @__PURE__ */ (0, import_jsx_runtime250.jsx)(label_default, {
        "aria-hidden": props["aria-hidden"],
        label,
        position: position2,
        ref: labelRef,
        zIndex
      })]
    });
  }
  var ForwardedComponent4 = (0, import_element169.forwardRef)(ResizeTooltip);
  var resize_tooltip_default = ForwardedComponent4;

  // packages/components/build-module/resizable-box/index.mjs
  var import_jsx_runtime251 = __toESM(require_jsx_runtime(), 1);
  var HANDLE_CLASS_NAME = "components-resizable-box__handle";
  var SIDE_HANDLE_CLASS_NAME = "components-resizable-box__side-handle";
  var CORNER_HANDLE_CLASS_NAME = "components-resizable-box__corner-handle";
  var HANDLE_CLASSES = {
    top: clsx_default(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-top"),
    right: clsx_default(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-right"),
    bottom: clsx_default(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-bottom"),
    left: clsx_default(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-left"),
    topLeft: clsx_default(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-top", "components-resizable-box__handle-left"),
    topRight: clsx_default(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-top", "components-resizable-box__handle-right"),
    bottomRight: clsx_default(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-bottom", "components-resizable-box__handle-right"),
    bottomLeft: clsx_default(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-bottom", "components-resizable-box__handle-left")
  };
  var HANDLE_STYLES_OVERRIDES = {
    width: void 0,
    height: void 0,
    top: void 0,
    right: void 0,
    bottom: void 0,
    left: void 0
  };
  var HANDLE_STYLES = {
    top: HANDLE_STYLES_OVERRIDES,
    right: HANDLE_STYLES_OVERRIDES,
    bottom: HANDLE_STYLES_OVERRIDES,
    left: HANDLE_STYLES_OVERRIDES,
    topLeft: HANDLE_STYLES_OVERRIDES,
    topRight: HANDLE_STYLES_OVERRIDES,
    bottomRight: HANDLE_STYLES_OVERRIDES,
    bottomLeft: HANDLE_STYLES_OVERRIDES
  };
  function UnforwardedResizableBox({
    className: className2,
    children,
    showHandle = true,
    __experimentalShowTooltip: showTooltip = false,
    __experimentalTooltipProps: tooltipProps = {},
    ...props
  }, ref) {
    return /* @__PURE__ */ (0, import_jsx_runtime251.jsxs)(Resizable, {
      className: clsx_default("components-resizable-box__container", showHandle && "has-show-handle", className2),
      handleComponent: Object.fromEntries(Object.keys(HANDLE_CLASSES).map((key) => [key, /* @__PURE__ */ (0, import_jsx_runtime251.jsx)("div", {
        tabIndex: -1
      }, key)])),
      handleClasses: HANDLE_CLASSES,
      handleStyles: HANDLE_STYLES,
      ref,
      ...props,
      children: [children, showTooltip && /* @__PURE__ */ (0, import_jsx_runtime251.jsx)(resize_tooltip_default, {
        ...tooltipProps
      })]
    });
  }
  var ResizableBox = (0, import_element170.forwardRef)(UnforwardedResizableBox);
  ResizableBox.displayName = "ResizableBox";
  var resizable_box_default = ResizableBox;

  // packages/components/build-module/responsive-wrapper/index.mjs
  var import_element171 = __toESM(require_element(), 1);
  var import_jsx_runtime252 = __toESM(require_jsx_runtime(), 1);
  function ResponsiveWrapper({
    naturalWidth,
    naturalHeight,
    children,
    isInline = false
  }) {
    if (import_element171.Children.count(children) !== 1) {
      return null;
    }
    const TagName59 = isInline ? "span" : "div";
    let aspectRatio2;
    if (naturalWidth && naturalHeight) {
      aspectRatio2 = `${naturalWidth} / ${naturalHeight}`;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime252.jsx)(TagName59, {
      className: "components-responsive-wrapper",
      children: /* @__PURE__ */ (0, import_jsx_runtime252.jsx)("div", {
        children: (0, import_element171.cloneElement)(children, {
          className: clsx_default("components-responsive-wrapper__content", children.props.className),
          style: {
            ...children.props.style,
            aspectRatio: aspectRatio2
          }
        })
      })
    });
  }
  var responsive_wrapper_default = ResponsiveWrapper;

  // packages/components/build-module/sandbox/index.mjs
  var import_element172 = __toESM(require_element(), 1);
  var import_compose68 = __toESM(require_compose(), 1);
  var import_jsx_runtime253 = __toESM(require_jsx_runtime(), 1);
  var observeAndResizeJS = function() {
    const {
      MutationObserver: MutationObserver2
    } = window;
    if (!MutationObserver2 || !window.parent) {
      return;
    }
    function sendResize() {
      if (!document.body) {
        return;
      }
      const clientBoundingRect = document.body.getBoundingClientRect();
      window.parent.postMessage({
        action: "resize",
        width: clientBoundingRect.width,
        height: clientBoundingRect.height
      }, "*");
    }
    function connect() {
      const {
        body
      } = document;
      if (!body) {
        return;
      }
      const observer = new MutationObserver2(sendResize);
      observer.observe(body, {
        attributes: true,
        attributeOldValue: false,
        characterData: true,
        characterDataOldValue: false,
        childList: true,
        subtree: true
      });
      function removeViewportStyles(ruleOrNode) {
        if (ruleOrNode.style) {
          ["width", "height", "minHeight", "maxHeight"].forEach(function(style2) {
            if (/^\d*\.?\d+(?:vw|vh|svw|lvw|dvw|svh|lvh|dvh|vi|svi|lvi|dvi|vb|svb|lvb|dvb|vmin|svmin|lvmin|dvmin|vmax|svmax|lvmax|dvmax)$/.test(ruleOrNode.style[style2])) {
              ruleOrNode.style[style2] = "";
            }
          });
        }
      }
      Array.prototype.forEach.call(document.querySelectorAll("[style]"), removeViewportStyles);
      Array.prototype.forEach.call(document.styleSheets, function(stylesheet) {
        let rules;
        try {
          rules = stylesheet.cssRules || stylesheet.rules;
        } catch {
          return;
        }
        Array.prototype.forEach.call(rules, removeViewportStyles);
      });
      body.style.position = "absolute";
      body.style.width = "100%";
      body.setAttribute("data-resizable-iframe-connected", "");
      sendResize();
    }
    window.addEventListener("load", sendResize, true);
    window.addEventListener("resize", sendResize, true);
    if (document.body) {
      connect();
    } else {
      document.addEventListener("DOMContentLoaded", connect);
    }
  };
  var style = `
	body {
		margin: 0;
	}
	html,
	body,
	body > div {
		width: 100%;
	}
	html.wp-has-aspect-ratio,
	body.wp-has-aspect-ratio,
	body.wp-has-aspect-ratio > div,
	body.wp-has-aspect-ratio > div iframe {
		width: 100%;
		height: 100%;
		overflow: hidden; /* If it has an aspect ratio, it shouldn't scroll. */
	}
	body > div > * {
		margin-top: 0 !important; /* Has to have !important to override inline styles. */
		margin-bottom: 0 !important;
	}
`;
  function buildSandBoxDocument({
    html,
    title,
    type,
    styles: styles3,
    scripts,
    lang
  }) {
    const htmlDoc = /* @__PURE__ */ (0, import_jsx_runtime253.jsxs)("html", {
      lang,
      className: type,
      children: [/* @__PURE__ */ (0, import_jsx_runtime253.jsxs)("head", {
        children: [/* @__PURE__ */ (0, import_jsx_runtime253.jsx)("title", {
          children: title
        }), /* @__PURE__ */ (0, import_jsx_runtime253.jsx)("style", {
          dangerouslySetInnerHTML: {
            __html: style
          }
        }), styles3.map((rules, i3) => /* @__PURE__ */ (0, import_jsx_runtime253.jsx)("style", {
          dangerouslySetInnerHTML: {
            __html: rules
          }
        }, i3)), /* @__PURE__ */ (0, import_jsx_runtime253.jsx)("script", {
          type: "text/javascript",
          dangerouslySetInnerHTML: {
            __html: `(${observeAndResizeJS.toString()})();`
          }
        })]
      }), /* @__PURE__ */ (0, import_jsx_runtime253.jsxs)("body", {
        "data-resizable-iframe-connected": "data-resizable-iframe-connected",
        className: type,
        children: [/* @__PURE__ */ (0, import_jsx_runtime253.jsx)("div", {
          dangerouslySetInnerHTML: {
            __html: html
          }
        }), scripts.map((src) => /* @__PURE__ */ (0, import_jsx_runtime253.jsx)("script", {
          src
        }, src))]
      })]
    });
    return "<!DOCTYPE html>" + (0, import_element172.renderToString)(htmlDoc);
  }
  function IsolatedSandBox({
    html = "",
    title = "",
    type,
    styles: styles3 = [],
    scripts = [],
    onFocus,
    tabIndex
  }) {
    const ref = (0, import_element172.useRef)(null);
    const [width, setWidth] = (0, import_element172.useState)(0);
    const [height, setHeight] = (0, import_element172.useState)(0);
    const srcDoc = (0, import_element172.useMemo)(() => buildSandBoxDocument({
      html,
      title,
      type,
      styles: styles3,
      scripts,
      // Read inside the memo: the `no-dom-globals-in-react-fc` lint
      // rule forbids DOM globals in the render body. `lang` rarely
      // changes after load, so leaving it out of the deps is fine.
      lang: document.documentElement.lang
    }), [html, title, type, styles3, scripts]);
    (0, import_element172.useEffect)(() => {
      const iframe = ref.current;
      if (!iframe) {
        return;
      }
      function checkMessageForResize(event) {
        if (!iframe || iframe.contentWindow !== event.source) {
          return;
        }
        let data = event.data || {};
        if ("string" === typeof data) {
          try {
            data = JSON.parse(data);
          } catch {
          }
        }
        if ("resize" !== data.action) {
          return;
        }
        setWidth(data.width);
        setHeight(data.height);
      }
      let currentView = null;
      function syncListener() {
        const view = iframe?.ownerDocument?.defaultView ?? null;
        if (view === currentView) {
          return;
        }
        currentView?.removeEventListener("message", checkMessageForResize);
        currentView = view;
        currentView?.addEventListener("message", checkMessageForResize);
      }
      syncListener();
      iframe.addEventListener("load", syncListener);
      return () => {
        iframe.removeEventListener("load", syncListener);
        currentView?.removeEventListener("message", checkMessageForResize);
      };
    }, []);
    return /* @__PURE__ */ (0, import_jsx_runtime253.jsx)("iframe", {
      ref: (0, import_compose68.useMergeRefs)([ref, (0, import_compose68.useFocusableIframe)()]),
      title,
      tabIndex,
      className: "components-sandbox",
      sandbox: "allow-scripts allow-presentation",
      srcDoc,
      onFocus,
      width: Math.ceil(width),
      height: Math.ceil(height)
    });
  }
  function SameOriginSandBox({
    html = "",
    title = "",
    type,
    styles: styles3 = [],
    scripts = [],
    onFocus,
    tabIndex
  }) {
    const ref = (0, import_element172.useRef)(null);
    const [width, setWidth] = (0, import_element172.useState)(0);
    const [height, setHeight] = (0, import_element172.useState)(0);
    function isFrameAccessible() {
      try {
        return !!ref.current?.contentDocument?.body;
      } catch {
        return false;
      }
    }
    function trySandBox(forceRerender = false) {
      if (!isFrameAccessible()) {
        return;
      }
      const {
        contentDocument,
        ownerDocument
      } = ref.current;
      if (!forceRerender && null !== contentDocument?.body.getAttribute("data-resizable-iframe-connected")) {
        return;
      }
      contentDocument.open();
      contentDocument.write(buildSandBoxDocument({
        html,
        title,
        type,
        styles: styles3,
        scripts,
        lang: ownerDocument.documentElement.lang
      }));
      contentDocument.close();
    }
    (0, import_element172.useEffect)(() => {
      trySandBox();
      function tryNoForceSandBox() {
        trySandBox(false);
      }
      function checkMessageForResize(event) {
        const iframe2 = ref.current;
        if (!iframe2 || iframe2.contentWindow !== event.source) {
          return;
        }
        let data = event.data || {};
        if ("string" === typeof data) {
          try {
            data = JSON.parse(data);
          } catch {
          }
        }
        if ("resize" !== data.action) {
          return;
        }
        setWidth(data.width);
        setHeight(data.height);
      }
      const iframe = ref.current;
      const defaultView = iframe?.ownerDocument?.defaultView;
      iframe?.addEventListener("load", tryNoForceSandBox, false);
      defaultView?.addEventListener("message", checkMessageForResize);
      return () => {
        iframe?.removeEventListener("load", tryNoForceSandBox, false);
        defaultView?.removeEventListener("message", checkMessageForResize);
      };
    }, []);
    (0, import_element172.useEffect)(() => {
      trySandBox();
    }, [title, styles3, scripts]);
    (0, import_element172.useEffect)(() => {
      trySandBox(true);
    }, [html, type]);
    return /* @__PURE__ */ (0, import_jsx_runtime253.jsx)("iframe", {
      ref: (0, import_compose68.useMergeRefs)([ref, (0, import_compose68.useFocusableIframe)()]),
      title,
      tabIndex,
      className: "components-sandbox",
      sandbox: "allow-scripts allow-same-origin allow-presentation",
      onFocus,
      width: Math.ceil(width),
      height: Math.ceil(height)
    });
  }
  function SandBox({
    allowSameOrigin = false,
    ...contentProps
  }) {
    if (allowSameOrigin) {
      return /* @__PURE__ */ (0, import_jsx_runtime253.jsx)(SameOriginSandBox, {
        ...contentProps
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime253.jsx)(IsolatedSandBox, {
      ...contentProps
    });
  }
  var sandbox_default = SandBox;

  // packages/components/build-module/search-control/index.mjs
  var import_compose69 = __toESM(require_compose(), 1);
  var import_i18n67 = __toESM(require_i18n(), 1);
  var import_element173 = __toESM(require_element(), 1);
  var import_deprecated22 = __toESM(require_deprecated(), 1);

  // packages/components/build-module/search-control/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__34() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var StyledInputControl = /* @__PURE__ */ createStyled(input_control_default, false ? {
    target: "effl84m1"
  } : {
    target: "effl84m1",
    label: "StyledInputControl"
  })(false ? {
    name: "37btb2",
    styles: "input[type='search']{&::-webkit-search-decoration,&::-webkit-search-cancel-button,&::-webkit-search-results-button,&::-webkit-search-results-decoration{-webkit-appearance:none;}}"
  } : {
    name: "37btb2",
    styles: "input[type='search']{&::-webkit-search-decoration,&::-webkit-search-cancel-button,&::-webkit-search-results-button,&::-webkit-search-results-decoration{-webkit-appearance:none;}}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXd0QiLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG4vKipcbiAqIEludGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgSW5wdXRDb250cm9sIGZyb20gJy4uL2lucHV0LWNvbnRyb2wnO1xuaW1wb3J0IEljb24gZnJvbSAnLi4vaWNvbic7XG5cbmV4cG9ydCBjb25zdCBTdHlsZWRJbnB1dENvbnRyb2wgPSBzdHlsZWQoIElucHV0Q29udHJvbCApYFxuXHRpbnB1dFt0eXBlPSdzZWFyY2gnXSB7XG5cdFx0Jjo6LXdlYmtpdC1zZWFyY2gtZGVjb3JhdGlvbixcblx0XHQmOjotd2Via2l0LXNlYXJjaC1jYW5jZWwtYnV0dG9uLFxuXHRcdCY6Oi13ZWJraXQtc2VhcmNoLXJlc3VsdHMtYnV0dG9uLFxuXHRcdCY6Oi13ZWJraXQtc2VhcmNoLXJlc3VsdHMtZGVjb3JhdGlvbiB7XG5cdFx0XHQtd2Via2l0LWFwcGVhcmFuY2U6IG5vbmU7XG5cdFx0fVxuXHR9XG5gO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkSWNvbiA9IHN0eWxlZCggSWNvbiApYFxuXHQmOmRpciggbHRyICkge1xuXHRcdHRyYW5zZm9ybTogc2NhbGVYKCAtMSApO1xuXHR9XG5gO1xuIl19 */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__34
  });
  var StyledIcon = /* @__PURE__ */ createStyled(icon_default3, false ? {
    target: "effl84m0"
  } : {
    target: "effl84m0",
    label: "StyledIcon"
  })(false ? {
    name: "1i54h4p",
    styles: "&:dir( ltr ){transform:scaleX( -1 );}"
  } : {
    name: "1i54h4p",
    styles: "&:dir( ltr ){transform:scaleX( -1 );}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQndDIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuLyoqXG4gKiBJbnRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IElucHV0Q29udHJvbCBmcm9tICcuLi9pbnB1dC1jb250cm9sJztcbmltcG9ydCBJY29uIGZyb20gJy4uL2ljb24nO1xuXG5leHBvcnQgY29uc3QgU3R5bGVkSW5wdXRDb250cm9sID0gc3R5bGVkKCBJbnB1dENvbnRyb2wgKWBcblx0aW5wdXRbdHlwZT0nc2VhcmNoJ10ge1xuXHRcdCY6Oi13ZWJraXQtc2VhcmNoLWRlY29yYXRpb24sXG5cdFx0Jjo6LXdlYmtpdC1zZWFyY2gtY2FuY2VsLWJ1dHRvbixcblx0XHQmOjotd2Via2l0LXNlYXJjaC1yZXN1bHRzLWJ1dHRvbixcblx0XHQmOjotd2Via2l0LXNlYXJjaC1yZXN1bHRzLWRlY29yYXRpb24ge1xuXHRcdFx0LXdlYmtpdC1hcHBlYXJhbmNlOiBub25lO1xuXHRcdH1cblx0fVxuYDtcblxuZXhwb3J0IGNvbnN0IFN0eWxlZEljb24gPSBzdHlsZWQoIEljb24gKWBcblx0JjpkaXIoIGx0ciApIHtcblx0XHR0cmFuc2Zvcm06IHNjYWxlWCggLTEgKTtcblx0fVxuYDtcbiJdfQ== */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__34
  });

  // packages/components/build-module/search-control/index.mjs
  var import_jsx_runtime254 = __toESM(require_jsx_runtime(), 1);
  function SuffixItem({
    searchRef,
    value,
    onChange,
    onClose
  }) {
    if (!onClose && !value) {
      return null;
    }
    if (onClose) {
      (0, import_deprecated22.default)("`onClose` prop in wp.components.SearchControl", {
        since: "6.8"
      });
    }
    const onReset = () => {
      onChange("");
      searchRef.current?.focus();
    };
    return /* @__PURE__ */ (0, import_jsx_runtime254.jsx)(InputControlSuffixWrapper, {
      variant: "control",
      children: /* @__PURE__ */ (0, import_jsx_runtime254.jsx)(button_default, {
        size: "small",
        icon: close_small_default,
        label: onClose ? (0, import_i18n67.__)("Close search") : (0, import_i18n67.__)("Reset search"),
        onClick: onClose ?? onReset
      })
    });
  }
  function UnforwardedSearchControl({
    // Prevent passing legacy props to internal component.
    __nextHasNoMarginBottom: _2,
    __next40pxDefaultSize: _next40pxDefaultSize,
    className: className2,
    onChange,
    value,
    label = (0, import_i18n67.__)("Search"),
    placeholder = (0, import_i18n67.__)("Search"),
    hideLabelFromVision = true,
    onClose,
    size: size4 = "default",
    ...restProps
  }, forwardedRef) {
    const {
      disabled,
      ...filteredRestProps
    } = restProps;
    const searchRef = (0, import_element173.useRef)(null);
    const instanceId = (0, import_compose69.useInstanceId)(SearchControl, "components-search-control");
    return /* @__PURE__ */ (0, import_jsx_runtime254.jsx)(StyledInputControl, {
      id: instanceId,
      hideLabelFromVision,
      label,
      ref: (0, import_compose69.useMergeRefs)([searchRef, forwardedRef]),
      type: "search",
      size: size4,
      className: clsx_default("components-search-control", className2),
      onChange: (nextValue) => onChange(nextValue ?? ""),
      autoComplete: "off",
      placeholder,
      value: value ?? "",
      prefix: /* @__PURE__ */ (0, import_jsx_runtime254.jsx)(InputControlPrefixWrapper, {
        variant: "icon",
        children: /* @__PURE__ */ (0, import_jsx_runtime254.jsx)(StyledIcon, {
          icon: search_default,
          fill: "currentColor"
        })
      }),
      suffix: /* @__PURE__ */ (0, import_jsx_runtime254.jsx)(SuffixItem, {
        searchRef,
        value,
        onChange,
        onClose
      }),
      ...filteredRestProps
    });
  }
  var SearchControl = (0, import_element173.forwardRef)(UnforwardedSearchControl);
  SearchControl.displayName = "SearchControl";
  var search_control_default = SearchControl;

  // packages/components/build-module/snackbar/index.mjs
  var import_a11y9 = __toESM(require_a11y(), 1);
  var import_element174 = __toESM(require_element(), 1);
  var import_i18n68 = __toESM(require_i18n(), 1);
  var import_warning9 = __toESM(require_warning(), 1);
  var import_jsx_runtime255 = __toESM(require_jsx_runtime(), 1);
  var NOTICE_TIMEOUT = 6e3;
  function useSpokenMessage2(message2, politeness) {
    const spokenMessage = typeof message2 === "string" ? message2 : (0, import_element174.renderToString)(message2);
    (0, import_element174.useEffect)(() => {
      if (spokenMessage) {
        (0, import_a11y9.speak)(spokenMessage, politeness);
      }
    }, [spokenMessage, politeness]);
  }
  function UnforwardedSnackbar({
    className: className2,
    children,
    spokenMessage = children,
    politeness = "polite",
    actions = [],
    onRemove,
    icon = null,
    explicitDismiss = false,
    // onDismiss is a callback executed when the snackbar is dismissed.
    // It is distinct from onRemove, which _looks_ like a callback but is
    // actually the function to call to remove the snackbar from the UI.
    onDismiss,
    listRef
  }, ref) {
    function dismissMe(event) {
      if (event && event.preventDefault) {
        event.preventDefault();
      }
      listRef?.current?.focus();
      onDismiss?.();
      onRemove?.();
    }
    function onActionClick(event, onClick) {
      event.stopPropagation();
      onRemove?.();
      if (onClick) {
        onClick(event);
      }
    }
    useSpokenMessage2(spokenMessage, politeness);
    const callbacksRef = (0, import_element174.useRef)({
      onDismiss,
      onRemove
    });
    (0, import_element174.useLayoutEffect)(() => {
      callbacksRef.current = {
        onDismiss,
        onRemove
      };
    });
    (0, import_element174.useEffect)(() => {
      const timeoutHandle = setTimeout(() => {
        if (!explicitDismiss) {
          callbacksRef.current.onDismiss?.();
          callbacksRef.current.onRemove?.();
        }
      }, NOTICE_TIMEOUT);
      return () => clearTimeout(timeoutHandle);
    }, [explicitDismiss]);
    const classes = clsx_default(className2, "components-snackbar", {
      "components-snackbar-explicit-dismiss": !!explicitDismiss
    });
    if (actions && actions.length > 1) {
      true ? (0, import_warning9.default)("Snackbar can only have one action. Use Notice if your message requires many actions.") : void 0;
      actions = [actions[0]];
    }
    const snackbarContentClassnames = clsx_default("components-snackbar__content", {
      "components-snackbar__content-with-icon": !!icon
    });
    return /* @__PURE__ */ (0, import_jsx_runtime255.jsx)("div", {
      ref,
      className: classes,
      onClick: !explicitDismiss ? dismissMe : void 0,
      tabIndex: 0,
      role: !explicitDismiss ? "button" : void 0,
      onKeyPress: !explicitDismiss ? dismissMe : void 0,
      "aria-label": !explicitDismiss ? (0, import_i18n68.__)("Dismiss this notice") : void 0,
      "data-testid": "snackbar",
      children: /* @__PURE__ */ (0, import_jsx_runtime255.jsxs)("div", {
        className: snackbarContentClassnames,
        children: [icon && /* @__PURE__ */ (0, import_jsx_runtime255.jsx)("div", {
          className: "components-snackbar__icon",
          children: icon
        }), children, actions.map(({
          label,
          onClick,
          url,
          openInNewTab = false
        }, index2) => url !== void 0 && openInNewTab ? /* @__PURE__ */ (0, import_jsx_runtime255.jsx)(external_link_default, {
          href: url,
          onClick: (event) => onActionClick(event, onClick),
          className: "components-snackbar__action",
          children: label
        }, index2) : /* @__PURE__ */ (0, import_jsx_runtime255.jsx)(button_default, {
          __next40pxDefaultSize: true,
          href: url,
          variant: "link",
          onClick: (event) => onActionClick(event, onClick),
          className: "components-snackbar__action",
          children: label
        }, index2)), explicitDismiss && /* @__PURE__ */ (0, import_jsx_runtime255.jsx)("span", {
          role: "button",
          "aria-label": (0, import_i18n68.__)("Dismiss this notice"),
          tabIndex: 0,
          className: "components-snackbar__dismiss-button",
          onClick: dismissMe,
          onKeyPress: dismissMe,
          children: "\u2715"
        })]
      })
    });
  }
  var Snackbar = (0, import_element174.forwardRef)(UnforwardedSnackbar);
  Snackbar.displayName = "Snackbar";
  var snackbar_default = Snackbar;

  // packages/components/build-module/snackbar/list.mjs
  var import_compose70 = __toESM(require_compose(), 1);
  var import_element175 = __toESM(require_element(), 1);
  var import_jsx_runtime256 = __toESM(require_jsx_runtime(), 1);
  var SNACKBAR_VARIANTS = {
    init: {
      height: 0,
      opacity: 0
    },
    open: {
      height: "auto",
      opacity: 1,
      transition: {
        height: {
          type: "tween",
          duration: 0.3,
          ease: [0, 0, 0.2, 1]
        },
        opacity: {
          type: "tween",
          duration: 0.25,
          delay: 0.05,
          ease: [0, 0, 0.2, 1]
        }
      }
    },
    exit: {
      opacity: 0,
      transition: {
        type: "tween",
        duration: 0.1,
        ease: [0, 0, 0.2, 1]
      }
    }
  };
  function SnackbarList({
    notices,
    className: className2,
    children,
    onRemove
  }) {
    const listRef = (0, import_element175.useRef)(null);
    const isReducedMotion = (0, import_compose70.useReducedMotion)();
    className2 = clsx_default("components-snackbar-list", className2);
    const removeNotice = (notice) => () => onRemove?.(notice.id);
    return /* @__PURE__ */ (0, import_jsx_runtime256.jsxs)("div", {
      className: className2,
      tabIndex: -1,
      ref: listRef,
      "data-testid": "snackbar-list",
      children: [children, /* @__PURE__ */ (0, import_jsx_runtime256.jsx)(AnimatePresence, {
        children: notices.map((notice) => {
          const {
            content,
            ...restNotice
          } = notice;
          return /* @__PURE__ */ (0, import_jsx_runtime256.jsx)(motion.div, {
            layout: isReducedMotion ? false : "position",
            style: {
              width: "100%"
            },
            initial: "init",
            animate: "open",
            exit: "exit",
            variants: isReducedMotion ? void 0 : SNACKBAR_VARIANTS,
            children: /* @__PURE__ */ (0, import_jsx_runtime256.jsx)("div", {
              className: "components-snackbar-list__notice-container",
              children: /* @__PURE__ */ (0, import_jsx_runtime256.jsx)(snackbar_default, {
                ...restNotice,
                onRemove: removeNotice(notice),
                listRef,
                children: notice.content
              })
            })
          }, notice.id);
        })
      })]
    });
  }
  var list_default2 = SnackbarList;

  // packages/components/build-module/tab-panel/index.mjs
  var import_element176 = __toESM(require_element(), 1);
  var import_compose71 = __toESM(require_compose(), 1);
  var import_i18n69 = __toESM(require_i18n(), 1);
  var import_jsx_runtime257 = __toESM(require_jsx_runtime(), 1);
  var extractTabName = (id3) => {
    if (typeof id3 === "undefined" || id3 === null) {
      return;
    }
    return id3.match(/^tab-panel-[0-9]*-(.*)/)?.[1];
  };
  var UnforwardedTabPanel = ({
    className: className2,
    children,
    tabs,
    selectOnMove = true,
    initialTabName,
    orientation = "horizontal",
    activeClass = "is-active",
    onSelect
  }, ref) => {
    const instanceId = (0, import_compose71.useInstanceId)(TabPanel22, "tab-panel");
    const prependInstanceId = (0, import_element176.useCallback)((tabName) => {
      if (typeof tabName === "undefined") {
        return;
      }
      return `${instanceId}-${tabName}`;
    }, [instanceId]);
    const tabStore = useTabStore({
      setSelectedId: (newTabValue) => {
        if (typeof newTabValue === "undefined" || newTabValue === null) {
          return;
        }
        const newTab = tabs.find((t4) => prependInstanceId(t4.name) === newTabValue);
        if (newTab?.disabled || newTab === selectedTab) {
          return;
        }
        const simplifiedTabName = extractTabName(newTabValue);
        if (typeof simplifiedTabName === "undefined") {
          return;
        }
        onSelect?.(simplifiedTabName);
      },
      orientation,
      selectOnMove,
      defaultSelectedId: prependInstanceId(initialTabName),
      rtl: (0, import_i18n69.isRTL)()
    });
    const selectedTabName = extractTabName(useStoreState(tabStore, "selectedId"));
    const setTabStoreSelectedId = (0, import_element176.useCallback)((tabName) => {
      tabStore.setState("selectedId", prependInstanceId(tabName));
    }, [prependInstanceId, tabStore]);
    const selectedTab = tabs.find(({
      name
    }) => name === selectedTabName);
    const previousSelectedTabName = (0, import_compose71.usePrevious)(selectedTabName);
    (0, import_element176.useEffect)(() => {
      if (previousSelectedTabName !== selectedTabName && selectedTabName === initialTabName && !!selectedTabName) {
        onSelect?.(selectedTabName);
      }
    }, [selectedTabName, initialTabName, onSelect, previousSelectedTabName]);
    (0, import_element176.useLayoutEffect)(() => {
      if (selectedTab) {
        return;
      }
      const initialTab = tabs.find((tab) => tab.name === initialTabName);
      if (initialTabName && !initialTab) {
        return;
      }
      if (initialTab && !initialTab.disabled) {
        setTabStoreSelectedId(initialTab.name);
      } else {
        const firstEnabledTab = tabs.find((tab) => !tab.disabled);
        if (firstEnabledTab) {
          setTabStoreSelectedId(firstEnabledTab.name);
        }
      }
    }, [tabs, selectedTab, initialTabName, instanceId, setTabStoreSelectedId]);
    (0, import_element176.useEffect)(() => {
      if (!selectedTab?.disabled) {
        return;
      }
      const firstEnabledTab = tabs.find((tab) => !tab.disabled);
      if (firstEnabledTab) {
        setTabStoreSelectedId(firstEnabledTab.name);
      }
    }, [tabs, selectedTab?.disabled, setTabStoreSelectedId, instanceId]);
    return /* @__PURE__ */ (0, import_jsx_runtime257.jsxs)("div", {
      className: className2,
      ref,
      children: [/* @__PURE__ */ (0, import_jsx_runtime257.jsx)(TabList, {
        store: tabStore,
        className: "components-tab-panel__tabs",
        children: tabs.map((tab) => {
          return /* @__PURE__ */ (0, import_jsx_runtime257.jsx)(Tab, {
            id: prependInstanceId(tab.name),
            className: clsx_default("components-tab-panel__tabs-item", tab.className, {
              [activeClass]: tab.name === selectedTabName
            }),
            disabled: tab.disabled,
            "aria-controls": `${prependInstanceId(tab.name)}-view`,
            render: /* @__PURE__ */ (0, import_jsx_runtime257.jsx)(button_default, {
              __next40pxDefaultSize: true,
              icon: tab.icon,
              label: tab.icon && tab.title,
              showTooltip: !!tab.icon
            }),
            children: !tab.icon && tab.title
          }, tab.name);
        })
      }), selectedTab && /* @__PURE__ */ (0, import_jsx_runtime257.jsx)(TabPanel, {
        id: `${prependInstanceId(selectedTab.name)}-view`,
        store: tabStore,
        tabId: prependInstanceId(selectedTab.name),
        className: "components-tab-panel__tab-content",
        children: children(selectedTab)
      })]
    });
  };
  var TabPanel22 = (0, import_element176.forwardRef)(UnforwardedTabPanel);
  TabPanel22.displayName = "TabPanel";
  var tab_panel_default = TabPanel22;

  // packages/components/build-module/text-control/index.mjs
  var import_compose72 = __toESM(require_compose(), 1);
  var import_element177 = __toESM(require_element(), 1);
  var import_jsx_runtime258 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedTextControl(props, ref) {
    const {
      // Prevent passing legacy props to `input`.
      __nextHasNoMarginBottom: _2,
      __next40pxDefaultSize: __63,
      label,
      hideLabelFromVision,
      value,
      help,
      id: idProp,
      className: className2,
      onChange,
      type = "text",
      ...additionalProps
    } = props;
    const id3 = (0, import_compose72.useInstanceId)(TextControl, "inspector-text-control", idProp);
    const onChangeValue = (event) => onChange(event.target.value);
    return /* @__PURE__ */ (0, import_jsx_runtime258.jsx)(base_control_default, {
      label,
      hideLabelFromVision,
      id: id3,
      help,
      className: className2,
      children: /* @__PURE__ */ (0, import_jsx_runtime258.jsx)("input", {
        className: "components-text-control__input",
        type,
        id: id3,
        value,
        onChange: onChangeValue,
        "aria-describedby": !!help ? id3 + "__help" : void 0,
        ref,
        ...additionalProps
      })
    });
  }
  var TextControl = (0, import_element177.forwardRef)(UnforwardedTextControl);
  TextControl.displayName = "TextControl";
  var text_control_default = TextControl;

  // packages/components/build-module/textarea-control/index.mjs
  var import_compose73 = __toESM(require_compose(), 1);
  var import_element178 = __toESM(require_element(), 1);

  // packages/components/build-module/textarea-control/styles/textarea-control-styles.mjs
  var inputStyleNeutral = /* @__PURE__ */ css("box-shadow:0 0 0 transparent;border-radius:", config_values_default.radiusSmall, ";border:", config_values_default.borderWidth, " solid ", COLORS.ui.border, ";@media not ( prefers-reduced-motion ){transition:box-shadow 0.1s linear;}" + (false ? "" : ";label:inputStyleNeutral;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var inputStyleFocus = /* @__PURE__ */ css("border-color:", COLORS.theme.accent, ";box-shadow:0 0 0 calc( ", config_values_default.borderWidthFocus, " - ", config_values_default.borderWidth, " ) ", COLORS.theme.accent, ";outline:2px solid transparent;" + (false ? "" : ";label:inputStyleFocus;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");
  var StyledTextarea = /* @__PURE__ */ createStyled("textarea", false ? {
    target: "e1w5nnrk0"
  } : {
    target: "e1w5nnrk0",
    label: "StyledTextarea"
  })("width:100%;display:block;font-family:", font("default.fontFamily"), ";line-height:20px;background:", COLORS.theme.background, ";color:", COLORS.theme.foreground, ";resize:vertical;padding:9px 11px;min-height:38px;", inputStyleNeutral, ";font-size:", font("mobileTextMinFontSize"), ";", breakpoint("small"), "{font-size:", font("default.fontSize"), ";}&:focus{", inputStyleFocus, ";}&:disabled{background:", COLORS.ui.backgroundDisabled, ";border-color:", COLORS.ui.borderDisabled, ";color:", COLORS.ui.textDisabled, ";}&::-webkit-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&::-moz-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&:-ms-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}.is-dark-theme &{&::-webkit-input-placeholder{color:", COLORS.ui.lightGrayPlaceholder, ";}&::-moz-placeholder{color:", COLORS.ui.lightGrayPlaceholder, ";}&:-ms-input-placeholder{color:", COLORS.ui.lightGrayPlaceholder, ";}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"));

  // packages/components/build-module/textarea-control/index.mjs
  var import_jsx_runtime259 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedTextareaControl(props, ref) {
    const {
      // Prevent passing this to `textarea`.
      __nextHasNoMarginBottom: _2,
      label,
      hideLabelFromVision,
      value,
      help,
      onChange,
      rows = 4,
      className: className2,
      ...additionalProps
    } = props;
    const instanceId = (0, import_compose73.useInstanceId)(TextareaControl);
    const id3 = `inspector-textarea-control-${instanceId}`;
    const onChangeValue = (event) => onChange(event.target.value);
    const classes = clsx_default("components-textarea-control", className2);
    return /* @__PURE__ */ (0, import_jsx_runtime259.jsx)(base_control_default, {
      label,
      hideLabelFromVision,
      id: id3,
      help,
      className: classes,
      children: /* @__PURE__ */ (0, import_jsx_runtime259.jsx)(StyledTextarea, {
        className: "components-textarea-control__input",
        id: id3,
        rows,
        onChange: onChangeValue,
        "aria-describedby": !!help ? id3 + "__help" : void 0,
        value,
        ref,
        ...additionalProps
      })
    });
  }
  var TextareaControl = (0, import_element178.forwardRef)(UnforwardedTextareaControl);
  TextareaControl.displayName = "TextareaControl";
  var textarea_control_default = TextareaControl;

  // packages/components/build-module/text-highlight/index.mjs
  var import_element179 = __toESM(require_element(), 1);
  var import_jsx_runtime260 = __toESM(require_jsx_runtime(), 1);
  var TextHighlight = (props) => {
    const {
      text = "",
      highlight = ""
    } = props;
    const trimmedHighlightText = highlight.trim();
    if (!trimmedHighlightText) {
      return /* @__PURE__ */ (0, import_jsx_runtime260.jsx)(import_jsx_runtime260.Fragment, {
        children: text
      });
    }
    const regex = new RegExp(`(${escapeRegExp(trimmedHighlightText)})`, "gi");
    return (0, import_element179.createInterpolateElement)(text.replace(regex, "<mark>$&</mark>"), {
      mark: /* @__PURE__ */ (0, import_jsx_runtime260.jsx)("mark", {})
    });
  };
  TextHighlight.displayName = "TextHighlight";
  var text_highlight_default = TextHighlight;

  // packages/components/build-module/tip/index.mjs
  var import_jsx_runtime261 = __toESM(require_jsx_runtime(), 1);
  function Tip(props) {
    const {
      children
    } = props;
    return /* @__PURE__ */ (0, import_jsx_runtime261.jsxs)("div", {
      className: "components-tip",
      children: [/* @__PURE__ */ (0, import_jsx_runtime261.jsx)(icon_default2, {
        icon: tip_default
      }), /* @__PURE__ */ (0, import_jsx_runtime261.jsx)("p", {
        children
      })]
    });
  }
  var tip_default2 = Tip;

  // packages/components/build-module/toggle-control/index.mjs
  var import_element180 = __toESM(require_element(), 1);
  var import_compose74 = __toESM(require_compose(), 1);
  var import_jsx_runtime262 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToggleControl({
    label,
    checked,
    help,
    className: className2,
    onChange,
    disabled,
    // Prevent passing to internal component.
    __nextHasNoMarginBottom: _2,
    ...additionalProps
  }, ref) {
    function onChangeToggle(event) {
      onChange(event.target.checked);
    }
    const instanceId = (0, import_compose74.useInstanceId)(ToggleControl);
    const id3 = `inspector-toggle-control-${instanceId}`;
    let describedBy, helpLabel;
    if (help) {
      if (typeof help === "function") {
        if (checked !== void 0) {
          helpLabel = help(checked);
        }
      } else {
        helpLabel = help;
      }
      if (helpLabel) {
        describedBy = id3 + "__help";
      }
    }
    return /* @__PURE__ */ (0, import_jsx_runtime262.jsx)(base_control_default, {
      id: id3,
      help: helpLabel && /* @__PURE__ */ (0, import_jsx_runtime262.jsx)("span", {
        className: "components-toggle-control__help",
        children: helpLabel
      }),
      className: clsx_default("components-toggle-control", className2),
      children: /* @__PURE__ */ (0, import_jsx_runtime262.jsxs)(component_default9, {
        justify: "flex-start",
        spacing: 2,
        children: [/* @__PURE__ */ (0, import_jsx_runtime262.jsx)(form_toggle_default, {
          id: id3,
          checked,
          onChange: onChangeToggle,
          "aria-describedby": describedBy,
          disabled,
          ref,
          ...additionalProps
        }), /* @__PURE__ */ (0, import_jsx_runtime262.jsx)(component_default5, {
          as: "label",
          htmlFor: id3,
          className: clsx_default("components-toggle-control__label", {
            "is-disabled": disabled
          }),
          children: label
        })]
      })
    });
  }
  var ToggleControl = (0, import_element180.forwardRef)(UnforwardedToggleControl);
  ToggleControl.displayName = "ToggleControl";
  var toggle_control_default = ToggleControl;

  // packages/components/build-module/toolbar/toolbar/index.mjs
  var import_element187 = __toESM(require_element(), 1);
  var import_deprecated23 = __toESM(require_deprecated(), 1);

  // packages/components/build-module/toolbar/toolbar-group/index.mjs
  var import_element185 = __toESM(require_element(), 1);

  // packages/components/build-module/toolbar/toolbar-button/index.mjs
  var import_element183 = __toESM(require_element(), 1);

  // packages/components/build-module/toolbar/toolbar-item/index.mjs
  var import_element182 = __toESM(require_element(), 1);
  var import_warning10 = __toESM(require_warning(), 1);

  // packages/components/build-module/toolbar/toolbar-context/index.mjs
  var import_element181 = __toESM(require_element(), 1);
  var ToolbarContext = (0, import_element181.createContext)(void 0);
  ToolbarContext.displayName = "ToolbarContext";
  var toolbar_context_default = ToolbarContext;

  // packages/components/build-module/toolbar/toolbar-item/index.mjs
  var import_jsx_runtime263 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToolbarItem({
    children,
    as: Component7,
    ...props
  }, ref) {
    const accessibleToolbarStore = (0, import_element182.useContext)(toolbar_context_default);
    const isRenderProp = typeof children === "function";
    if (!isRenderProp && !Component7) {
      true ? (0, import_warning10.default)("`ToolbarItem` is a generic headless component. You must pass either a `children` prop as a function or an `as` prop as a component. See https://developer.wordpress.org/block-editor/components/toolbar-item/") : void 0;
      return null;
    }
    const allProps = {
      ...props,
      ref,
      "data-toolbar-item": true
    };
    if (!accessibleToolbarStore) {
      if (Component7) {
        return /* @__PURE__ */ (0, import_jsx_runtime263.jsx)(Component7, {
          ...allProps,
          children
        });
      }
      if (!isRenderProp) {
        return null;
      }
      return children(allProps);
    }
    const render = isRenderProp ? children : Component7 && /* @__PURE__ */ (0, import_jsx_runtime263.jsx)(Component7, {
      children
    });
    return /* @__PURE__ */ (0, import_jsx_runtime263.jsx)(ToolbarItem, {
      accessibleWhenDisabled: true,
      ...allProps,
      store: accessibleToolbarStore,
      render
    });
  }
  var ToolbarItem22 = (0, import_element182.forwardRef)(UnforwardedToolbarItem);
  ToolbarItem22.displayName = "ToolbarItem";
  var toolbar_item_default = ToolbarItem22;

  // packages/components/build-module/toolbar/toolbar-button/toolbar-button-container.mjs
  var import_jsx_runtime264 = __toESM(require_jsx_runtime(), 1);
  var ToolbarButtonContainer = ({
    children,
    className: className2
  }) => /* @__PURE__ */ (0, import_jsx_runtime264.jsx)("div", {
    className: className2,
    children
  });
  var toolbar_button_container_default = ToolbarButtonContainer;

  // packages/components/build-module/toolbar/toolbar-button/index.mjs
  var import_jsx_runtime265 = __toESM(require_jsx_runtime(), 1);
  function useDeprecatedProps6({
    isDisabled,
    ...otherProps
  }) {
    return {
      disabled: isDisabled,
      ...otherProps
    };
  }
  function UnforwardedToolbarButton(props, ref) {
    const {
      children,
      className: className2,
      containerClassName,
      extraProps,
      isActive,
      title,
      ...restProps
    } = useDeprecatedProps6(props);
    const accessibleToolbarState = (0, import_element183.useContext)(toolbar_context_default);
    if (!accessibleToolbarState) {
      return /* @__PURE__ */ (0, import_jsx_runtime265.jsx)(toolbar_button_container_default, {
        className: containerClassName,
        children: /* @__PURE__ */ (0, import_jsx_runtime265.jsx)(button_default, {
          ref,
          icon: restProps.icon,
          size: "compact",
          label: title,
          shortcut: restProps.shortcut,
          "data-subscript": restProps.subscript,
          onClick: (event) => {
            event.stopPropagation();
            if (restProps.onClick) {
              restProps.onClick(event);
            }
          },
          className: clsx_default("components-toolbar__control", className2),
          isPressed: isActive,
          accessibleWhenDisabled: true,
          "data-toolbar-item": true,
          ...extraProps,
          ...restProps,
          children
        })
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime265.jsx)(toolbar_item_default, {
      className: clsx_default("components-toolbar-button", className2),
      ...extraProps,
      ...restProps,
      ref,
      children: (toolbarItemProps) => /* @__PURE__ */ (0, import_jsx_runtime265.jsx)(button_default, {
        size: "compact",
        label: title,
        isPressed: isActive,
        ...toolbarItemProps,
        children
      })
    });
  }
  var ToolbarButton = (0, import_element183.forwardRef)(UnforwardedToolbarButton);
  ToolbarButton.displayName = "ToolbarButton";
  var toolbar_button_default = ToolbarButton;

  // packages/components/build-module/toolbar/toolbar-group/toolbar-group-container.mjs
  var import_jsx_runtime266 = __toESM(require_jsx_runtime(), 1);
  var ToolbarGroupContainer = ({
    className: className2,
    children,
    ...props
  }) => /* @__PURE__ */ (0, import_jsx_runtime266.jsx)("div", {
    className: className2,
    ...props,
    children
  });
  var toolbar_group_container_default = ToolbarGroupContainer;

  // packages/components/build-module/toolbar/toolbar-group/toolbar-group-collapsed.mjs
  var import_element184 = __toESM(require_element(), 1);
  var import_jsx_runtime267 = __toESM(require_jsx_runtime(), 1);
  function ToolbarGroupCollapsed({
    controls = [],
    toggleProps,
    ...props
  }) {
    const accessibleToolbarState = (0, import_element184.useContext)(toolbar_context_default);
    const renderDropdownMenu = (internalToggleProps) => /* @__PURE__ */ (0, import_jsx_runtime267.jsx)(dropdown_menu_default, {
      controls,
      toggleProps: {
        ...internalToggleProps,
        "data-toolbar-item": true
      },
      ...props
    });
    if (accessibleToolbarState) {
      return /* @__PURE__ */ (0, import_jsx_runtime267.jsx)(toolbar_item_default, {
        ...toggleProps,
        children: renderDropdownMenu
      });
    }
    return renderDropdownMenu(toggleProps);
  }
  var toolbar_group_collapsed_default = ToolbarGroupCollapsed;

  // packages/components/build-module/toolbar/toolbar-group/index.mjs
  var import_jsx_runtime268 = __toESM(require_jsx_runtime(), 1);
  function isNestedArray(arr) {
    return Array.isArray(arr) && Array.isArray(arr[0]);
  }
  function ToolbarGroup({
    controls = [],
    children,
    className: className2,
    isCollapsed: isCollapsed2,
    title,
    ...props
  }) {
    const accessibleToolbarState = (0, import_element185.useContext)(toolbar_context_default);
    if ((!controls || !controls.length) && !children) {
      return null;
    }
    const finalClassName = clsx_default(
      // Unfortunately, there's legacy code referencing to `.components-toolbar`
      // So we can't get rid of it
      accessibleToolbarState ? "components-toolbar-group" : "components-toolbar",
      className2
    );
    let controlSets;
    if (isNestedArray(controls)) {
      controlSets = controls;
    } else {
      controlSets = [controls];
    }
    if (isCollapsed2) {
      return /* @__PURE__ */ (0, import_jsx_runtime268.jsx)(toolbar_group_collapsed_default, {
        label: title,
        controls: controlSets,
        className: finalClassName,
        children,
        ...props
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime268.jsxs)(toolbar_group_container_default, {
      className: finalClassName,
      ...props,
      children: [controlSets?.flatMap((controlSet, indexOfSet) => controlSet.map((control, indexOfControl) => /* @__PURE__ */ (0, import_jsx_runtime268.jsx)(toolbar_button_default, {
        containerClassName: indexOfSet > 0 && indexOfControl === 0 ? "has-left-divider" : void 0,
        ...control
      }, [indexOfSet, indexOfControl].join()))), children]
    });
  }
  var toolbar_group_default = ToolbarGroup;

  // packages/components/build-module/toolbar/toolbar/toolbar-container.mjs
  var import_element186 = __toESM(require_element(), 1);
  var import_i18n70 = __toESM(require_i18n(), 1);
  var import_jsx_runtime269 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToolbarContainer({
    label,
    ...props
  }, ref) {
    const toolbarStore = useToolbarStore({
      focusLoop: true,
      rtl: (0, import_i18n70.isRTL)()
    });
    return (
      // This will provide state for `ToolbarButton`'s
      /* @__PURE__ */ (0, import_jsx_runtime269.jsx)(toolbar_context_default.Provider, {
        value: toolbarStore,
        children: /* @__PURE__ */ (0, import_jsx_runtime269.jsx)(Toolbar, {
          ref,
          "aria-label": label,
          store: toolbarStore,
          ...props
        })
      })
    );
  }
  var ToolbarContainer2 = (0, import_element186.forwardRef)(UnforwardedToolbarContainer);
  ToolbarContainer2.displayName = "ToolbarContainer";
  var toolbar_container_default = ToolbarContainer2;

  // packages/components/build-module/toolbar/toolbar/index.mjs
  var import_jsx_runtime270 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToolbar({
    className: className2,
    label,
    variant,
    ...props
  }, ref) {
    const isVariantDefined = variant !== void 0;
    const contextSystemValue = (0, import_element187.useMemo)(() => {
      if (isVariantDefined) {
        return {};
      }
      return {
        DropdownMenu: {
          variant: "toolbar"
        },
        Dropdown: {
          variant: "toolbar"
        },
        Menu: {
          variant: "toolbar"
        }
      };
    }, [isVariantDefined]);
    if (!label) {
      (0, import_deprecated23.default)("Using Toolbar without label prop", {
        since: "5.6",
        alternative: "ToolbarGroup component",
        link: "https://developer.wordpress.org/block-editor/components/toolbar/"
      });
      const {
        title: _title,
        ...restProps
      } = props;
      return /* @__PURE__ */ (0, import_jsx_runtime270.jsx)(toolbar_group_default, {
        isCollapsed: false,
        ...restProps,
        className: className2
      });
    }
    const finalClassName = clsx_default("components-accessible-toolbar", className2, variant && `is-${variant}`);
    return /* @__PURE__ */ (0, import_jsx_runtime270.jsx)(ContextSystemProvider, {
      value: contextSystemValue,
      children: /* @__PURE__ */ (0, import_jsx_runtime270.jsx)(toolbar_container_default, {
        className: finalClassName,
        label,
        ref,
        ...props
      })
    });
  }
  var Toolbar3 = (0, import_element187.forwardRef)(UnforwardedToolbar);
  Toolbar3.displayName = "Toolbar";
  var toolbar_default = Toolbar3;

  // packages/components/build-module/toolbar/toolbar-dropdown-menu/index.mjs
  var import_element188 = __toESM(require_element(), 1);
  var import_jsx_runtime271 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedToolbarDropdownMenu(props, ref) {
    const accessibleToolbarState = (0, import_element188.useContext)(toolbar_context_default);
    if (!accessibleToolbarState) {
      return /* @__PURE__ */ (0, import_jsx_runtime271.jsx)(dropdown_menu_default, {
        ...props
      });
    }
    return /* @__PURE__ */ (0, import_jsx_runtime271.jsx)(toolbar_item_default, {
      ref,
      ...props.toggleProps,
      children: (toolbarItemProps) => /* @__PURE__ */ (0, import_jsx_runtime271.jsx)(dropdown_menu_default, {
        ...props,
        popoverProps: {
          ...props.popoverProps
        },
        toggleProps: toolbarItemProps
      })
    });
  }
  var ToolbarDropdownMenu = (0, import_element188.forwardRef)(UnforwardedToolbarDropdownMenu);
  ToolbarDropdownMenu.displayName = "ToolbarDropdownMenu";
  var toolbar_dropdown_menu_default = ToolbarDropdownMenu;

  // packages/components/build-module/tools-panel/tools-panel-header/component.mjs
  var import_a11y10 = __toESM(require_a11y(), 1);
  var import_i18n71 = __toESM(require_i18n(), 1);

  // packages/components/build-module/tools-panel/context.mjs
  var import_element189 = __toESM(require_element(), 1);
  var noop24 = () => void 0;
  var ToolsPanelContext = (0, import_element189.createContext)({
    menuItems: {
      default: {},
      optional: {}
    },
    hasMenuItems: false,
    isResetting: false,
    shouldRenderPlaceholderItems: false,
    registerPanelItem: noop24,
    deregisterPanelItem: noop24,
    flagItemCustomization: noop24,
    registerResetAllFilter: noop24,
    deregisterResetAllFilter: noop24,
    areAllOptionalControlsHidden: true
  });
  ToolsPanelContext.displayName = "ToolsPanelContext";
  var useToolsPanelContext = () => (0, import_element189.useContext)(ToolsPanelContext);

  // packages/components/build-module/tools-panel/tools-panel-header/hook.mjs
  var STYLE_HASH_ATTRIBUTE13 = "data-wp-hash";
  function getRuntime13() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument13(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash13(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE13}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE13) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle13(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime13();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash13(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE13, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument13(targetDocument) {
    const runtime = getRuntime13();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle13(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle12(hash2, css3) {
    const runtime = getRuntime13();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle13(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle12("29b739f451", "._62d714739f4dc308__tools-panel{border-top:1px solid #ddd;margin-top:-1px;padding:16px}._40db7f4f897b683d__tools-panel-with-inner-wrapper>div:not(:first-of-type){column-gap:16px;display:grid;grid-column:1/-1;grid-template-columns:repeat(2,minmax(0,1fr));row-gap:16px}._95a15674966f30a3__tools-panel-hidden-inner-wrapper>div:not(:first-of-type){display:none}._322a049b9b7d8674__tools-panel-header{gap:8px;grid-column:1/-1}._322a049b9b7d8674__tools-panel-header .components-dropdown-menu{line-height:0;margin:-4px 0}._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header .components-dropdown-menu__toggle{min-width:24px;padding:0}.b92a382d3b30104d__tools-panel-heading.b92a382d3b30104d__tools-panel-heading{font-size:inherit;line-height:normal;margin:0}._8005d68fffa9db91__tools-panel-item{grid-column:1/-1}._8005d68fffa9db91__tools-panel-item>div,._8005d68fffa9db91__tools-panel-item>fieldset{margin-bottom:0;max-width:100%;padding-bottom:0}._8005d68fffa9db91__tools-panel-item .components-base-control__help,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control .components-base-control__field:last-child{margin-bottom:0}._4f55e1a6e373746e__tools-panel-item-placeholder{display:none}.d40032517bff9e12__dropdown-menu{min-width:200px}.f135b96aa96ca6bb__reset-label{color:var(--wp-components-color-accent-darker-10,var(--wp-admin-theme-color-darker-10,#2145e6));font-size:var(--wpds-typography-font-size-xs,11px);font-weight:var(--wpds-typography-font-weight-emphasis,600);line-height:1.4;margin-inline-start:12px;text-transform:uppercase}._69b138dfa5570d9c__default-controls-item{color:#1e1e1e}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]{color:#757575;opacity:1}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]:hover{color:#757575}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true] .f135b96aa96ca6bb__reset-label{opacity:.3}");
  }
  var style_module_default11 = { "tools-panel": "_62d714739f4dc308__tools-panel", "tools-panel-with-inner-wrapper": "_40db7f4f897b683d__tools-panel-with-inner-wrapper", "tools-panel-hidden-inner-wrapper": "_95a15674966f30a3__tools-panel-hidden-inner-wrapper", "tools-panel-header": "_322a049b9b7d8674__tools-panel-header", "tools-panel-heading": "b92a382d3b30104d__tools-panel-heading", "tools-panel-item": "_8005d68fffa9db91__tools-panel-item", "tools-panel-item-placeholder": "_4f55e1a6e373746e__tools-panel-item-placeholder", "dropdown-menu": "d40032517bff9e12__dropdown-menu", "reset-label": "f135b96aa96ca6bb__reset-label", "default-controls-item": "_69b138dfa5570d9c__default-controls-item" };
  function useToolsPanelHeader(props) {
    const {
      className: className2,
      headingLevel = 2,
      ...otherProps
    } = useContextSystem(props, "ToolsPanelHeader");
    const {
      menuItems,
      hasMenuItems,
      areAllOptionalControlsHidden
    } = useToolsPanelContext();
    return {
      ...otherProps,
      areAllOptionalControlsHidden,
      defaultControlsItemClassName: style_module_default11["default-controls-item"],
      dropdownMenuClassName: style_module_default11["dropdown-menu"],
      hasMenuItems,
      headingClassName: style_module_default11["tools-panel-heading"],
      headingLevel,
      menuItems,
      className: clsx_default(style_module_default11["tools-panel-header"], className2)
    };
  }

  // packages/components/build-module/tools-panel/tools-panel-header/component.mjs
  var import_jsx_runtime272 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE14 = "data-wp-hash";
  function getRuntime14() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument14(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash14(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE14}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE14) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle14(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime14();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash14(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE14, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument14(targetDocument) {
    const runtime = getRuntime14();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle14(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle13(hash2, css3) {
    const runtime = getRuntime14();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle14(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle13("29b739f451", "._62d714739f4dc308__tools-panel{border-top:1px solid #ddd;margin-top:-1px;padding:16px}._40db7f4f897b683d__tools-panel-with-inner-wrapper>div:not(:first-of-type){column-gap:16px;display:grid;grid-column:1/-1;grid-template-columns:repeat(2,minmax(0,1fr));row-gap:16px}._95a15674966f30a3__tools-panel-hidden-inner-wrapper>div:not(:first-of-type){display:none}._322a049b9b7d8674__tools-panel-header{gap:8px;grid-column:1/-1}._322a049b9b7d8674__tools-panel-header .components-dropdown-menu{line-height:0;margin:-4px 0}._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header .components-dropdown-menu__toggle{min-width:24px;padding:0}.b92a382d3b30104d__tools-panel-heading.b92a382d3b30104d__tools-panel-heading{font-size:inherit;line-height:normal;margin:0}._8005d68fffa9db91__tools-panel-item{grid-column:1/-1}._8005d68fffa9db91__tools-panel-item>div,._8005d68fffa9db91__tools-panel-item>fieldset{margin-bottom:0;max-width:100%;padding-bottom:0}._8005d68fffa9db91__tools-panel-item .components-base-control__help,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control .components-base-control__field:last-child{margin-bottom:0}._4f55e1a6e373746e__tools-panel-item-placeholder{display:none}.d40032517bff9e12__dropdown-menu{min-width:200px}.f135b96aa96ca6bb__reset-label{color:var(--wp-components-color-accent-darker-10,var(--wp-admin-theme-color-darker-10,#2145e6));font-size:var(--wpds-typography-font-size-xs,11px);font-weight:var(--wpds-typography-font-weight-emphasis,600);line-height:1.4;margin-inline-start:12px;text-transform:uppercase}._69b138dfa5570d9c__default-controls-item{color:#1e1e1e}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]{color:#757575;opacity:1}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]:hover{color:#757575}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true] .f135b96aa96ca6bb__reset-label{opacity:.3}");
  }
  var style_module_default12 = { "tools-panel": "_62d714739f4dc308__tools-panel", "tools-panel-with-inner-wrapper": "_40db7f4f897b683d__tools-panel-with-inner-wrapper", "tools-panel-hidden-inner-wrapper": "_95a15674966f30a3__tools-panel-hidden-inner-wrapper", "tools-panel-header": "_322a049b9b7d8674__tools-panel-header", "tools-panel-heading": "b92a382d3b30104d__tools-panel-heading", "tools-panel-item": "_8005d68fffa9db91__tools-panel-item", "tools-panel-item-placeholder": "_4f55e1a6e373746e__tools-panel-item-placeholder", "dropdown-menu": "d40032517bff9e12__dropdown-menu", "reset-label": "f135b96aa96ca6bb__reset-label", "default-controls-item": "_69b138dfa5570d9c__default-controls-item" };
  var DefaultControlsGroup = ({
    itemClassName,
    items,
    toggleItem
  }) => {
    if (!items.length) {
      return null;
    }
    const resetSuffix = /* @__PURE__ */ (0, import_jsx_runtime272.jsx)("span", {
      "aria-hidden": true,
      className: style_module_default12["reset-label"],
      children: (0, import_i18n71.__)("Reset")
    });
    return /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(import_jsx_runtime272.Fragment, {
      children: items.map(([label, hasValue]) => {
        if (hasValue) {
          return /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(menu_item_default, {
            className: itemClassName,
            role: "menuitem",
            label: (0, import_i18n71.sprintf)(
              // translators: %s: The name of the control being reset e.g. "Padding".
              (0, import_i18n71.__)("Reset %s"),
              label
            ),
            onClick: () => {
              toggleItem(label);
              (0, import_a11y10.speak)((0, import_i18n71.sprintf)(
                // translators: %s: The name of the control being reset e.g. "Padding".
                (0, import_i18n71.__)("%s reset to default"),
                label
              ), "assertive");
            },
            suffix: resetSuffix,
            children: label
          }, label);
        }
        return /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(menu_item_default, {
          icon: check_default,
          className: itemClassName,
          role: "menuitemcheckbox",
          isSelected: true,
          "aria-disabled": true,
          children: label
        }, label);
      })
    });
  };
  var OptionalControlsGroup = ({
    items,
    toggleItem
  }) => {
    if (!items.length) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(import_jsx_runtime272.Fragment, {
      children: items.map(([label, isSelected2]) => {
        const itemLabel = isSelected2 ? (0, import_i18n71.sprintf)(
          // translators: %s: The name of the control being hidden and reset e.g. "Padding".
          (0, import_i18n71.__)("Hide and reset %s"),
          label
        ) : (0, import_i18n71.sprintf)(
          // translators: %s: The name of the control to display e.g. "Padding".
          (0, import_i18n71._x)("Show %s", "input control"),
          label
        );
        return /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(menu_item_default, {
          icon: isSelected2 ? check_default : null,
          isSelected: isSelected2,
          label: itemLabel,
          onClick: () => {
            if (isSelected2) {
              (0, import_a11y10.speak)((0, import_i18n71.sprintf)(
                // translators: %s: The name of the control being reset e.g. "Padding".
                (0, import_i18n71.__)("%s hidden and reset to default"),
                label
              ), "assertive");
            } else {
              (0, import_a11y10.speak)((0, import_i18n71.sprintf)(
                // translators: %s: The name of the control being reset e.g. "Padding".
                (0, import_i18n71.__)("%s is now visible"),
                label
              ), "assertive");
            }
            toggleItem(label);
          },
          role: "menuitemcheckbox",
          children: label
        }, label);
      })
    });
  };
  var ToolsPanelHeader = (props, forwardedRef) => {
    const {
      areAllOptionalControlsHidden,
      defaultControlsItemClassName,
      dropdownMenuClassName,
      hasMenuItems,
      headingClassName,
      headingLevel = 2,
      label: labelText,
      menuItems,
      resetAll,
      toggleItem,
      dropdownMenuProps,
      ...headerProps
    } = useToolsPanelHeader(props);
    if (!labelText) {
      return null;
    }
    const defaultItems = Object.entries(menuItems?.default || {});
    const optionalItems = Object.entries(menuItems?.optional || {});
    const dropDownMenuIcon = areAllOptionalControlsHidden ? plus_default : more_vertical_default;
    const dropDownMenuLabelText = (0, import_i18n71.sprintf)(
      // translators: %s: The name of the tool e.g. "Color" or "Typography".
      (0, import_i18n71._x)("%s options", "Button label to reveal tool panel options"),
      labelText
    );
    const dropdownMenuDescriptionText = areAllOptionalControlsHidden ? (0, import_i18n71.__)("All options are currently hidden") : void 0;
    const canResetAll = [...defaultItems, ...optionalItems].some(([, isSelected2]) => isSelected2);
    return /* @__PURE__ */ (0, import_jsx_runtime272.jsxs)(component_default9, {
      ...headerProps,
      ref: forwardedRef,
      children: [/* @__PURE__ */ (0, import_jsx_runtime272.jsx)(component_default19, {
        level: headingLevel,
        className: headingClassName,
        children: labelText
      }), hasMenuItems && /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(dropdown_menu_default, {
        ...dropdownMenuProps,
        icon: dropDownMenuIcon,
        label: dropDownMenuLabelText,
        menuProps: {
          className: dropdownMenuClassName
        },
        toggleProps: {
          size: "small",
          description: dropdownMenuDescriptionText
        },
        children: () => /* @__PURE__ */ (0, import_jsx_runtime272.jsxs)(import_jsx_runtime272.Fragment, {
          children: [/* @__PURE__ */ (0, import_jsx_runtime272.jsxs)(menu_group_default, {
            label: labelText,
            children: [/* @__PURE__ */ (0, import_jsx_runtime272.jsx)(DefaultControlsGroup, {
              items: defaultItems,
              toggleItem,
              itemClassName: defaultControlsItemClassName
            }), /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(OptionalControlsGroup, {
              items: optionalItems,
              toggleItem
            })]
          }), /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(menu_group_default, {
            children: /* @__PURE__ */ (0, import_jsx_runtime272.jsx)(menu_item_default, {
              "aria-disabled": !canResetAll,
              variant: "tertiary",
              onClick: () => {
                if (canResetAll) {
                  resetAll();
                  (0, import_a11y10.speak)((0, import_i18n71.__)("All options reset"), "assertive");
                }
              },
              children: (0, import_i18n71.__)("Reset all")
            })
          })]
        })
      })]
    });
  };
  var ConnectedToolsPanelHeader = contextConnect(ToolsPanelHeader, "ToolsPanelHeader");
  var component_default38 = ConnectedToolsPanelHeader;

  // packages/components/build-module/tools-panel/tools-panel/hook.mjs
  var import_element190 = __toESM(require_element(), 1);
  var STYLE_HASH_ATTRIBUTE15 = "data-wp-hash";
  function getRuntime15() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument15(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash15(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE15}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE15) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle15(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime15();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash15(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE15, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument15(targetDocument) {
    const runtime = getRuntime15();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle15(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle14(hash2, css3) {
    const runtime = getRuntime15();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle15(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle14("29b739f451", "._62d714739f4dc308__tools-panel{border-top:1px solid #ddd;margin-top:-1px;padding:16px}._40db7f4f897b683d__tools-panel-with-inner-wrapper>div:not(:first-of-type){column-gap:16px;display:grid;grid-column:1/-1;grid-template-columns:repeat(2,minmax(0,1fr));row-gap:16px}._95a15674966f30a3__tools-panel-hidden-inner-wrapper>div:not(:first-of-type){display:none}._322a049b9b7d8674__tools-panel-header{gap:8px;grid-column:1/-1}._322a049b9b7d8674__tools-panel-header .components-dropdown-menu{line-height:0;margin:-4px 0}._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header .components-dropdown-menu__toggle{min-width:24px;padding:0}.b92a382d3b30104d__tools-panel-heading.b92a382d3b30104d__tools-panel-heading{font-size:inherit;line-height:normal;margin:0}._8005d68fffa9db91__tools-panel-item{grid-column:1/-1}._8005d68fffa9db91__tools-panel-item>div,._8005d68fffa9db91__tools-panel-item>fieldset{margin-bottom:0;max-width:100%;padding-bottom:0}._8005d68fffa9db91__tools-panel-item .components-base-control__help,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control .components-base-control__field:last-child{margin-bottom:0}._4f55e1a6e373746e__tools-panel-item-placeholder{display:none}.d40032517bff9e12__dropdown-menu{min-width:200px}.f135b96aa96ca6bb__reset-label{color:var(--wp-components-color-accent-darker-10,var(--wp-admin-theme-color-darker-10,#2145e6));font-size:var(--wpds-typography-font-size-xs,11px);font-weight:var(--wpds-typography-font-weight-emphasis,600);line-height:1.4;margin-inline-start:12px;text-transform:uppercase}._69b138dfa5570d9c__default-controls-item{color:#1e1e1e}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]{color:#757575;opacity:1}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]:hover{color:#757575}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true] .f135b96aa96ca6bb__reset-label{opacity:.3}");
  }
  var style_module_default13 = { "tools-panel": "_62d714739f4dc308__tools-panel", "tools-panel-with-inner-wrapper": "_40db7f4f897b683d__tools-panel-with-inner-wrapper", "tools-panel-hidden-inner-wrapper": "_95a15674966f30a3__tools-panel-hidden-inner-wrapper", "tools-panel-header": "_322a049b9b7d8674__tools-panel-header", "tools-panel-heading": "b92a382d3b30104d__tools-panel-heading", "tools-panel-item": "_8005d68fffa9db91__tools-panel-item", "tools-panel-item-placeholder": "_4f55e1a6e373746e__tools-panel-item-placeholder", "dropdown-menu": "d40032517bff9e12__dropdown-menu", "reset-label": "f135b96aa96ca6bb__reset-label", "default-controls-item": "_69b138dfa5570d9c__default-controls-item" };
  function emptyMenuItems() {
    return {
      default: {},
      optional: {}
    };
  }
  function emptyState() {
    return {
      panelItems: [],
      menuItemOrder: [],
      menuItems: emptyMenuItems()
    };
  }
  var generateMenuItems = ({
    panelItems,
    shouldReset,
    currentMenuItems,
    menuItemOrder
  }) => {
    const newMenuItems = emptyMenuItems();
    const menuItems = emptyMenuItems();
    panelItems.forEach(({
      hasValue,
      isShownByDefault,
      label
    }) => {
      const group = isShownByDefault ? "default" : "optional";
      const existingItemValue = currentMenuItems?.[group]?.[label];
      const value = existingItemValue ? existingItemValue : hasValue();
      newMenuItems[group][label] = shouldReset ? false : value;
    });
    menuItemOrder.forEach((key) => {
      if (newMenuItems.default.hasOwnProperty(key)) {
        menuItems.default[key] = newMenuItems.default[key];
      }
      if (newMenuItems.optional.hasOwnProperty(key)) {
        menuItems.optional[key] = newMenuItems.optional[key];
      }
    });
    Object.keys(newMenuItems.default).forEach((key) => {
      if (!menuItems.default.hasOwnProperty(key)) {
        menuItems.default[key] = newMenuItems.default[key];
      }
    });
    Object.keys(newMenuItems.optional).forEach((key) => {
      if (!menuItems.optional.hasOwnProperty(key)) {
        menuItems.optional[key] = newMenuItems.optional[key];
      }
    });
    return menuItems;
  };
  function panelItemsReducer(panelItems, action) {
    switch (action.type) {
      case "REGISTER_PANEL": {
        const newItems = [...panelItems];
        const existingIndex = newItems.findIndex((oldItem) => oldItem.label === action.item.label);
        if (existingIndex !== -1) {
          newItems.splice(existingIndex, 1);
        }
        newItems.push(action.item);
        return newItems;
      }
      case "UNREGISTER_PANEL": {
        const index2 = panelItems.findIndex((item2) => item2.label === action.label);
        if (index2 !== -1) {
          const newItems = [...panelItems];
          newItems.splice(index2, 1);
          return newItems;
        }
        return panelItems;
      }
      default:
        return panelItems;
    }
  }
  function menuItemOrderReducer(menuItemOrder, action) {
    switch (action.type) {
      case "REGISTER_PANEL": {
        if (menuItemOrder.includes(action.item.label)) {
          return menuItemOrder;
        }
        return [...menuItemOrder, action.item.label];
      }
      default:
        return menuItemOrder;
    }
  }
  function menuItemsReducer(state, action) {
    switch (action.type) {
      case "REGISTER_PANEL":
      case "UNREGISTER_PANEL":
        return generateMenuItems({
          currentMenuItems: state.menuItems,
          panelItems: state.panelItems,
          menuItemOrder: state.menuItemOrder,
          shouldReset: false
        });
      case "RESET_ALL":
        return generateMenuItems({
          panelItems: state.panelItems,
          menuItemOrder: state.menuItemOrder,
          shouldReset: true
        });
      case "UPDATE_VALUE": {
        const oldValue = state.menuItems[action.group][action.label];
        if (action.value === oldValue) {
          return state.menuItems;
        }
        return {
          ...state.menuItems,
          [action.group]: {
            ...state.menuItems[action.group],
            [action.label]: action.value
          }
        };
      }
      case "TOGGLE_VALUE": {
        const currentItem = state.panelItems.find((item2) => item2.label === action.label);
        if (!currentItem) {
          return state.menuItems;
        }
        const menuGroup = currentItem.isShownByDefault ? "default" : "optional";
        const newMenuItems = {
          ...state.menuItems,
          [menuGroup]: {
            ...state.menuItems[menuGroup],
            [action.label]: !state.menuItems[menuGroup][action.label]
          }
        };
        return newMenuItems;
      }
      default:
        return state.menuItems;
    }
  }
  function panelReducer(state, action) {
    const panelItems = panelItemsReducer(state.panelItems, action);
    const menuItemOrder = menuItemOrderReducer(state.menuItemOrder, action);
    const menuItems = menuItemsReducer({
      panelItems,
      menuItemOrder,
      menuItems: state.menuItems
    }, action);
    return {
      panelItems,
      menuItemOrder,
      menuItems
    };
  }
  function resetAllFiltersReducer(filters, action) {
    switch (action.type) {
      case "REGISTER":
        return [...filters, action.filter];
      case "UNREGISTER":
        return filters.filter((f3) => f3 !== action.filter);
      default:
        return filters;
    }
  }
  var isMenuItemTypeEmpty = (obj) => Object.keys(obj).length === 0;
  function useToolsPanel(props) {
    const {
      className: className2,
      headingLevel = 2,
      resetAll,
      panelId,
      hasInnerWrapper = false,
      shouldRenderPlaceholderItems = false,
      __experimentalFirstVisibleItemClass,
      __experimentalLastVisibleItemClass,
      ...otherProps
    } = useContextSystem(props, "ToolsPanel");
    const isResettingRef = (0, import_element190.useRef)(false);
    const wasResetting = isResettingRef.current;
    (0, import_element190.useEffect)(() => {
      if (wasResetting) {
        isResettingRef.current = false;
      }
    }, [wasResetting]);
    const [{
      panelItems,
      menuItems
    }, panelDispatch] = (0, import_element190.useReducer)(panelReducer, void 0, emptyState);
    const [resetAllFilters, dispatchResetAllFilters] = (0, import_element190.useReducer)(resetAllFiltersReducer, []);
    const registerPanelItem = (0, import_element190.useCallback)((item2) => {
      panelDispatch({
        type: "REGISTER_PANEL",
        item: item2
      });
    }, []);
    const deregisterPanelItem = (0, import_element190.useCallback)((label) => {
      panelDispatch({
        type: "UNREGISTER_PANEL",
        label
      });
    }, []);
    const registerResetAllFilter = (0, import_element190.useCallback)((filter2) => {
      dispatchResetAllFilters({
        type: "REGISTER",
        filter: filter2
      });
    }, []);
    const deregisterResetAllFilter = (0, import_element190.useCallback)((filter2) => {
      dispatchResetAllFilters({
        type: "UNREGISTER",
        filter: filter2
      });
    }, []);
    const flagItemCustomization = (0, import_element190.useCallback)((value, label, group = "default") => {
      panelDispatch({
        type: "UPDATE_VALUE",
        group,
        label,
        value
      });
    }, []);
    const areAllOptionalControlsHidden = (0, import_element190.useMemo)(() => {
      return isMenuItemTypeEmpty(menuItems.default) && !isMenuItemTypeEmpty(menuItems.optional) && Object.values(menuItems.optional).every((isSelected2) => !isSelected2);
    }, [menuItems]);
    const classes = clsx_default(style_module_default13["tools-panel"], hasInnerWrapper && style_module_default13["tools-panel-with-inner-wrapper"], areAllOptionalControlsHidden && style_module_default13["tools-panel-hidden-inner-wrapper"], className2);
    const toggleItem = (0, import_element190.useCallback)((label) => {
      panelDispatch({
        type: "TOGGLE_VALUE",
        label
      });
    }, []);
    const resetAllItems = (0, import_element190.useCallback)(() => {
      if (typeof resetAll === "function") {
        isResettingRef.current = true;
        resetAll(resetAllFilters);
      }
      panelDispatch({
        type: "RESET_ALL"
      });
    }, [resetAllFilters, resetAll]);
    const getFirstVisibleItemLabel = (items) => {
      const optionalItems = menuItems.optional || {};
      const firstItem = items.find((item2) => item2.isShownByDefault || optionalItems[item2.label]);
      return firstItem?.label;
    };
    const firstDisplayedItem = getFirstVisibleItemLabel(panelItems);
    const lastDisplayedItem = getFirstVisibleItemLabel([...panelItems].reverse());
    const hasMenuItems = panelItems.length > 0;
    const panelContext = (0, import_element190.useMemo)(() => ({
      areAllOptionalControlsHidden,
      deregisterPanelItem,
      deregisterResetAllFilter,
      firstDisplayedItem,
      flagItemCustomization,
      hasMenuItems,
      isResetting: isResettingRef.current,
      lastDisplayedItem,
      menuItems,
      panelId,
      registerPanelItem,
      registerResetAllFilter,
      shouldRenderPlaceholderItems,
      __experimentalFirstVisibleItemClass,
      __experimentalLastVisibleItemClass
    }), [areAllOptionalControlsHidden, deregisterPanelItem, deregisterResetAllFilter, firstDisplayedItem, flagItemCustomization, lastDisplayedItem, menuItems, panelId, hasMenuItems, registerResetAllFilter, registerPanelItem, shouldRenderPlaceholderItems, __experimentalFirstVisibleItemClass, __experimentalLastVisibleItemClass]);
    return {
      ...otherProps,
      headingLevel,
      panelContext,
      resetAllItems,
      toggleItem,
      className: classes
    };
  }

  // packages/components/build-module/tools-panel/tools-panel/component.mjs
  var import_jsx_runtime273 = __toESM(require_jsx_runtime(), 1);
  var TOOLS_PANEL_GAP = space(4);
  var UnconnectedToolsPanel = (props, forwardedRef) => {
    const {
      children,
      label,
      panelContext,
      resetAllItems,
      toggleItem,
      headingLevel,
      dropdownMenuProps,
      ...toolsPanelProps
    } = useToolsPanel(props);
    return /* @__PURE__ */ (0, import_jsx_runtime273.jsx)(component_default22, {
      ...toolsPanelProps,
      columns: 2,
      gap: 4,
      columnGap: TOOLS_PANEL_GAP,
      rowGap: TOOLS_PANEL_GAP,
      templateColumns: "repeat( 2, minmax(0, 1fr) )",
      ref: forwardedRef,
      children: /* @__PURE__ */ (0, import_jsx_runtime273.jsxs)(ToolsPanelContext.Provider, {
        value: panelContext,
        children: [/* @__PURE__ */ (0, import_jsx_runtime273.jsx)(component_default38, {
          label,
          resetAll: resetAllItems,
          toggleItem,
          headingLevel,
          dropdownMenuProps
        }), children]
      })
    });
  };
  var ToolsPanel = contextConnect(UnconnectedToolsPanel, "ToolsPanel");
  var component_default39 = ToolsPanel;

  // packages/components/build-module/tools-panel/tools-panel-item/hook.mjs
  var import_compose75 = __toESM(require_compose(), 1);
  var import_element191 = __toESM(require_element(), 1);
  var STYLE_HASH_ATTRIBUTE16 = "data-wp-hash";
  function getRuntime16() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument16(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash16(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE16}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE16) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle16(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime16();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash16(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE16, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument16(targetDocument) {
    const runtime = getRuntime16();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle16(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle15(hash2, css3) {
    const runtime = getRuntime16();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle16(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle15("29b739f451", "._62d714739f4dc308__tools-panel{border-top:1px solid #ddd;margin-top:-1px;padding:16px}._40db7f4f897b683d__tools-panel-with-inner-wrapper>div:not(:first-of-type){column-gap:16px;display:grid;grid-column:1/-1;grid-template-columns:repeat(2,minmax(0,1fr));row-gap:16px}._95a15674966f30a3__tools-panel-hidden-inner-wrapper>div:not(:first-of-type){display:none}._322a049b9b7d8674__tools-panel-header{gap:8px;grid-column:1/-1}._322a049b9b7d8674__tools-panel-header .components-dropdown-menu{line-height:0;margin:-4px 0}._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header._322a049b9b7d8674__tools-panel-header .components-dropdown-menu__toggle{min-width:24px;padding:0}.b92a382d3b30104d__tools-panel-heading.b92a382d3b30104d__tools-panel-heading{font-size:inherit;line-height:normal;margin:0}._8005d68fffa9db91__tools-panel-item{grid-column:1/-1}._8005d68fffa9db91__tools-panel-item>div,._8005d68fffa9db91__tools-panel-item>fieldset{margin-bottom:0;max-width:100%;padding-bottom:0}._8005d68fffa9db91__tools-panel-item .components-base-control__help,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control,._8005d68fffa9db91__tools-panel-item._8005d68fffa9db91__tools-panel-item .components-base-control .components-base-control__field:last-child{margin-bottom:0}._4f55e1a6e373746e__tools-panel-item-placeholder{display:none}.d40032517bff9e12__dropdown-menu{min-width:200px}.f135b96aa96ca6bb__reset-label{color:var(--wp-components-color-accent-darker-10,var(--wp-admin-theme-color-darker-10,#2145e6));font-size:var(--wpds-typography-font-size-xs,11px);font-weight:var(--wpds-typography-font-weight-emphasis,600);line-height:1.4;margin-inline-start:12px;text-transform:uppercase}._69b138dfa5570d9c__default-controls-item{color:#1e1e1e}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]{color:#757575;opacity:1}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true]:hover{color:#757575}._69b138dfa5570d9c__default-controls-item._69b138dfa5570d9c__default-controls-item[aria-disabled=true] .f135b96aa96ca6bb__reset-label{opacity:.3}");
  }
  var style_module_default14 = { "tools-panel": "_62d714739f4dc308__tools-panel", "tools-panel-with-inner-wrapper": "_40db7f4f897b683d__tools-panel-with-inner-wrapper", "tools-panel-hidden-inner-wrapper": "_95a15674966f30a3__tools-panel-hidden-inner-wrapper", "tools-panel-header": "_322a049b9b7d8674__tools-panel-header", "tools-panel-heading": "b92a382d3b30104d__tools-panel-heading", "tools-panel-item": "_8005d68fffa9db91__tools-panel-item", "tools-panel-item-placeholder": "_4f55e1a6e373746e__tools-panel-item-placeholder", "dropdown-menu": "d40032517bff9e12__dropdown-menu", "reset-label": "f135b96aa96ca6bb__reset-label", "default-controls-item": "_69b138dfa5570d9c__default-controls-item" };
  var noop25 = () => {
  };
  function useToolsPanelItem(props) {
    const {
      className: className2,
      hasValue,
      isShownByDefault = false,
      label,
      panelId,
      resetAllFilter = noop25,
      onDeselect,
      onSelect,
      ...otherProps
    } = useContextSystem(props, "ToolsPanelItem");
    const {
      panelId: currentPanelId,
      menuItems,
      registerResetAllFilter,
      deregisterResetAllFilter,
      registerPanelItem,
      deregisterPanelItem,
      flagItemCustomization,
      isResetting,
      shouldRenderPlaceholderItems: shouldRenderPlaceholder,
      firstDisplayedItem,
      lastDisplayedItem,
      __experimentalFirstVisibleItemClass,
      __experimentalLastVisibleItemClass
    } = useToolsPanelContext();
    const hasValueCallback = (0, import_element191.useCallback)(hasValue, [panelId]);
    const resetAllFilterCallback = (0, import_element191.useCallback)(resetAllFilter, [panelId]);
    const previousPanelId = (0, import_compose75.usePrevious)(currentPanelId);
    const hasMatchingPanel = currentPanelId === panelId || currentPanelId === null;
    (0, import_element191.useLayoutEffect)(() => {
      if (hasMatchingPanel && previousPanelId !== null) {
        registerPanelItem({
          hasValue: hasValueCallback,
          isShownByDefault,
          label,
          panelId
        });
      }
      return () => {
        if (previousPanelId === null && !!currentPanelId || currentPanelId === panelId) {
          deregisterPanelItem(label);
        }
      };
    }, [currentPanelId, hasMatchingPanel, isShownByDefault, label, hasValueCallback, panelId, previousPanelId, registerPanelItem, deregisterPanelItem]);
    (0, import_element191.useEffect)(() => {
      if (hasMatchingPanel) {
        registerResetAllFilter(resetAllFilterCallback);
      }
      return () => {
        if (hasMatchingPanel) {
          deregisterResetAllFilter(resetAllFilterCallback);
        }
      };
    }, [registerResetAllFilter, deregisterResetAllFilter, resetAllFilterCallback, hasMatchingPanel]);
    const menuGroup = isShownByDefault ? "default" : "optional";
    const isMenuItemChecked = menuItems?.[menuGroup]?.[label];
    const wasMenuItemChecked = (0, import_compose75.usePrevious)(isMenuItemChecked);
    const isRegistered = menuItems?.[menuGroup]?.[label] !== void 0;
    const isValueSet = hasValue();
    (0, import_element191.useEffect)(() => {
      if (!isShownByDefault && !isValueSet) {
        return;
      }
      flagItemCustomization(isValueSet, label, menuGroup);
    }, [isValueSet, menuGroup, label, flagItemCustomization, isShownByDefault]);
    (0, import_element191.useEffect)(() => {
      if (!isRegistered || isResetting || !hasMatchingPanel) {
        return;
      }
      if (isMenuItemChecked && !isValueSet && !wasMenuItemChecked) {
        onSelect?.();
      }
      if (!isMenuItemChecked && isValueSet && wasMenuItemChecked) {
        onDeselect?.();
      }
    }, [hasMatchingPanel, isMenuItemChecked, isRegistered, isResetting, isValueSet, wasMenuItemChecked, onSelect, onDeselect]);
    const isShown = isShownByDefault ? menuItems?.[menuGroup]?.[label] !== void 0 : isMenuItemChecked;
    const shouldApplyPlaceholderStyles = shouldRenderPlaceholder && !isShown;
    const classes = clsx_default(style_module_default14["tools-panel-item"], shouldApplyPlaceholderStyles && style_module_default14["tools-panel-item-placeholder"], !shouldApplyPlaceholderStyles && className2, firstDisplayedItem === label && __experimentalFirstVisibleItemClass, lastDisplayedItem === label && __experimentalLastVisibleItemClass);
    return {
      ...otherProps,
      isShown,
      shouldRenderPlaceholder,
      className: classes
    };
  }

  // packages/components/build-module/tools-panel/tools-panel-item/component.mjs
  var import_jsx_runtime274 = __toESM(require_jsx_runtime(), 1);
  var UnconnectedToolsPanelItem = (props, forwardedRef) => {
    const {
      children,
      isShown,
      shouldRenderPlaceholder,
      ...toolsPanelItemProps
    } = useToolsPanelItem(props);
    if (!isShown) {
      return shouldRenderPlaceholder ? /* @__PURE__ */ (0, import_jsx_runtime274.jsx)(component_default, {
        ...toolsPanelItemProps,
        ref: forwardedRef
      }) : null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime274.jsx)(component_default, {
      ...toolsPanelItemProps,
      ref: forwardedRef,
      children
    });
  };
  var ToolsPanelItem = contextConnect(UnconnectedToolsPanelItem, "ToolsPanelItem");
  var component_default40 = ToolsPanelItem;

  // packages/components/build-module/tree-grid/index.mjs
  var import_dom9 = __toESM(require_dom(), 1);
  var import_element198 = __toESM(require_element(), 1);
  var import_keycodes2 = __toESM(require_keycodes(), 1);

  // packages/components/build-module/tree-grid/roving-tab-index.mjs
  var import_element193 = __toESM(require_element(), 1);

  // packages/components/build-module/tree-grid/roving-tab-index-context.mjs
  var import_element192 = __toESM(require_element(), 1);
  var RovingTabIndexContext = (0, import_element192.createContext)(void 0);
  RovingTabIndexContext.displayName = "RovingTabIndexContext";
  var useRovingTabIndexContext = () => (0, import_element192.useContext)(RovingTabIndexContext);
  var RovingTabIndexProvider = RovingTabIndexContext.Provider;

  // packages/components/build-module/tree-grid/roving-tab-index.mjs
  var import_jsx_runtime275 = __toESM(require_jsx_runtime(), 1);
  function RovingTabIndex({
    children
  }) {
    const [lastFocusedElement, setLastFocusedElement] = (0, import_element193.useState)();
    const providerValue = (0, import_element193.useMemo)(() => ({
      lastFocusedElement,
      setLastFocusedElement
    }), [lastFocusedElement]);
    return /* @__PURE__ */ (0, import_jsx_runtime275.jsx)(RovingTabIndexProvider, {
      value: providerValue,
      children
    });
  }

  // packages/components/build-module/tree-grid/index.mjs
  var import_jsx_runtime280 = __toESM(require_jsx_runtime(), 1);

  // packages/components/build-module/tree-grid/row.mjs
  var import_element194 = __toESM(require_element(), 1);
  var import_jsx_runtime276 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedTreeGridRow({
    children,
    level,
    positionInSet,
    setSize,
    isExpanded,
    ...props
  }, ref) {
    return /* @__PURE__ */ (0, import_jsx_runtime276.jsx)("tr", {
      ...props,
      ref,
      role: "row",
      "aria-level": level,
      "aria-posinset": positionInSet,
      "aria-setsize": setSize,
      "aria-expanded": isExpanded,
      children
    });
  }
  var TreeGridRow = (0, import_element194.forwardRef)(UnforwardedTreeGridRow);
  TreeGridRow.displayName = "TreeGridRow";
  var row_default2 = TreeGridRow;

  // packages/components/build-module/tree-grid/cell.mjs
  var import_element197 = __toESM(require_element(), 1);

  // packages/components/build-module/tree-grid/item.mjs
  var import_element196 = __toESM(require_element(), 1);

  // packages/components/build-module/tree-grid/roving-tab-index-item.mjs
  var import_element195 = __toESM(require_element(), 1);
  var import_jsx_runtime277 = __toESM(require_jsx_runtime(), 1);
  var RovingTabIndexItem = (0, import_element195.forwardRef)(function UnforwardedRovingTabIndexItem({
    children,
    as: Component7,
    ...props
  }, forwardedRef) {
    const localRef = (0, import_element195.useRef)(null);
    const ref = forwardedRef || localRef;
    const {
      lastFocusedElement,
      setLastFocusedElement
    } = useRovingTabIndexContext();
    let tabIndex;
    if (lastFocusedElement) {
      tabIndex = lastFocusedElement === // TODO: The original implementation simply used `ref.current` here, assuming
      // that a forwarded ref would always be an object, which is not necessarily true.
      // This workaround maintains the original runtime behavior in a type-safe way,
      // but should be revisited.
      ("current" in ref ? ref.current : void 0) ? 0 : -1;
    }
    const onFocus = (event) => setLastFocusedElement?.(event.target);
    const allProps = {
      ref,
      tabIndex,
      onFocus,
      ...props
    };
    if (typeof children === "function") {
      return children(allProps);
    }
    if (!Component7) {
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime277.jsx)(Component7, {
      ...allProps,
      children
    });
  });
  RovingTabIndexItem.displayName = "RovingTabIndexItem";
  var roving_tab_index_item_default = RovingTabIndexItem;

  // packages/components/build-module/tree-grid/item.mjs
  var import_jsx_runtime278 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedTreeGridItem({
    children,
    ...props
  }, ref) {
    return /* @__PURE__ */ (0, import_jsx_runtime278.jsx)(roving_tab_index_item_default, {
      ref,
      ...props,
      children
    });
  }
  var TreeGridItem = (0, import_element196.forwardRef)(UnforwardedTreeGridItem);
  TreeGridItem.displayName = "TreeGridItem";
  var item_default2 = TreeGridItem;

  // packages/components/build-module/tree-grid/cell.mjs
  var import_jsx_runtime279 = __toESM(require_jsx_runtime(), 1);
  function UnforwardedTreeGridCell({
    children,
    withoutGridItem = false,
    ...props
  }, ref) {
    return /* @__PURE__ */ (0, import_jsx_runtime279.jsx)("td", {
      ...props,
      role: "gridcell",
      children: withoutGridItem ? /* @__PURE__ */ (0, import_jsx_runtime279.jsx)(import_jsx_runtime279.Fragment, {
        children: typeof children === "function" ? children({
          ...props,
          ref
        }) : children
      }) : /* @__PURE__ */ (0, import_jsx_runtime279.jsx)(item_default2, {
        ref,
        children
      })
    });
  }
  var TreeGridCell = (0, import_element197.forwardRef)(UnforwardedTreeGridCell);
  TreeGridCell.displayName = "TreeGridCell";
  var cell_default = TreeGridCell;

  // packages/components/build-module/tree-grid/index.mjs
  function getRowFocusables(rowElement) {
    const focusablesInRow = import_dom9.focus.focusable.find(rowElement, {
      sequential: true
    });
    return focusablesInRow.filter((focusable) => {
      return focusable.closest('[role="row"]') === rowElement;
    });
  }
  function UnforwardedTreeGrid({
    children,
    onExpandRow = () => {
    },
    onCollapseRow = () => {
    },
    onFocusRow = () => {
    },
    applicationAriaLabel,
    ...props
  }, ref) {
    const onKeyDown = (0, import_element198.useCallback)((event) => {
      const {
        keyCode,
        metaKey,
        ctrlKey,
        altKey
      } = event;
      const hasModifierKeyPressed = metaKey || ctrlKey || altKey;
      if (hasModifierKeyPressed || ![import_keycodes2.UP, import_keycodes2.DOWN, import_keycodes2.LEFT, import_keycodes2.RIGHT, import_keycodes2.HOME, import_keycodes2.END].includes(keyCode)) {
        return;
      }
      event.stopPropagation();
      const {
        activeElement
      } = document;
      const {
        currentTarget: treeGridElement
      } = event;
      if (!activeElement || !treeGridElement.contains(activeElement)) {
        return;
      }
      const activeRow = activeElement.closest('[role="row"]');
      if (!activeRow) {
        return;
      }
      const focusablesInRow = getRowFocusables(activeRow);
      const currentColumnIndex = focusablesInRow.indexOf(activeElement);
      const canExpandCollapse = 0 === currentColumnIndex;
      const cannotFocusNextColumn = canExpandCollapse && (activeRow.getAttribute("data-expanded") === "false" || activeRow.getAttribute("aria-expanded") === "false") && keyCode === import_keycodes2.RIGHT;
      if ([import_keycodes2.LEFT, import_keycodes2.RIGHT].includes(keyCode)) {
        let nextIndex;
        if (keyCode === import_keycodes2.LEFT) {
          nextIndex = Math.max(0, currentColumnIndex - 1);
        } else {
          nextIndex = Math.min(currentColumnIndex + 1, focusablesInRow.length - 1);
        }
        if (canExpandCollapse) {
          if (keyCode === import_keycodes2.LEFT) {
            if (activeRow.getAttribute("data-expanded") === "true" || activeRow.getAttribute("aria-expanded") === "true") {
              onCollapseRow(activeRow);
              event.preventDefault();
              return;
            }
            const level = Math.max(parseInt(activeRow?.getAttribute("aria-level") ?? "1", 10) - 1, 1);
            const rows = Array.from(treeGridElement.querySelectorAll('[role="row"]'));
            let parentRow = activeRow;
            const currentRowIndex = rows.indexOf(activeRow);
            for (let i3 = currentRowIndex; i3 >= 0; i3--) {
              const ariaLevel = rows[i3].getAttribute("aria-level");
              if (ariaLevel !== null && parseInt(ariaLevel, 10) === level) {
                parentRow = rows[i3];
                break;
              }
            }
            getRowFocusables(parentRow)?.[0]?.focus();
          }
          if (keyCode === import_keycodes2.RIGHT) {
            if (activeRow.getAttribute("data-expanded") === "false" || activeRow.getAttribute("aria-expanded") === "false") {
              onExpandRow(activeRow);
              event.preventDefault();
              return;
            }
            const focusableItems = getRowFocusables(activeRow);
            if (focusableItems.length > 0) {
              focusableItems[nextIndex]?.focus();
            }
          }
          event.preventDefault();
          return;
        }
        if (cannotFocusNextColumn) {
          return;
        }
        focusablesInRow[nextIndex].focus();
        event.preventDefault();
      } else if ([import_keycodes2.UP, import_keycodes2.DOWN].includes(keyCode)) {
        const rows = Array.from(treeGridElement.querySelectorAll('[role="row"]'));
        const currentRowIndex = rows.indexOf(activeRow);
        let nextRowIndex;
        if (keyCode === import_keycodes2.UP) {
          nextRowIndex = Math.max(0, currentRowIndex - 1);
        } else {
          nextRowIndex = Math.min(currentRowIndex + 1, rows.length - 1);
        }
        if (nextRowIndex === currentRowIndex) {
          event.preventDefault();
          return;
        }
        const focusablesInNextRow = getRowFocusables(rows[nextRowIndex]);
        if (!focusablesInNextRow || !focusablesInNextRow.length) {
          event.preventDefault();
          return;
        }
        const nextIndex = Math.min(currentColumnIndex, focusablesInNextRow.length - 1);
        focusablesInNextRow[nextIndex].focus();
        onFocusRow(event, activeRow, rows[nextRowIndex]);
        event.preventDefault();
      } else if ([import_keycodes2.HOME, import_keycodes2.END].includes(keyCode)) {
        const rows = Array.from(treeGridElement.querySelectorAll('[role="row"]'));
        const currentRowIndex = rows.indexOf(activeRow);
        let nextRowIndex;
        if (keyCode === import_keycodes2.HOME) {
          nextRowIndex = 0;
        } else {
          nextRowIndex = rows.length - 1;
        }
        if (nextRowIndex === currentRowIndex) {
          event.preventDefault();
          return;
        }
        const focusablesInNextRow = getRowFocusables(rows[nextRowIndex]);
        if (!focusablesInNextRow || !focusablesInNextRow.length) {
          event.preventDefault();
          return;
        }
        const nextIndex = Math.min(currentColumnIndex, focusablesInNextRow.length - 1);
        focusablesInNextRow[nextIndex].focus();
        onFocusRow(event, activeRow, rows[nextRowIndex]);
        event.preventDefault();
      }
    }, [onExpandRow, onCollapseRow, onFocusRow]);
    return /* @__PURE__ */ (0, import_jsx_runtime280.jsx)(RovingTabIndex, {
      children: /* @__PURE__ */ (0, import_jsx_runtime280.jsx)("div", {
        role: "application",
        "aria-label": applicationAriaLabel,
        children: /* @__PURE__ */ (0, import_jsx_runtime280.jsx)("table", {
          ...props,
          role: "treegrid",
          onKeyDown,
          ref,
          children: /* @__PURE__ */ (0, import_jsx_runtime280.jsx)("tbody", {
            children
          })
        })
      })
    });
  }
  var TreeGrid = (0, import_element198.forwardRef)(UnforwardedTreeGrid);
  TreeGrid.displayName = "TreeGrid";
  var tree_grid_default = TreeGrid;

  // packages/components/build-module/isolated-event-container/index.mjs
  var import_element199 = __toESM(require_element(), 1);
  var import_deprecated24 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime281 = __toESM(require_jsx_runtime(), 1);
  function stopPropagation(event) {
    event.stopPropagation();
  }
  var IsolatedEventContainer = (0, import_element199.forwardRef)((props, ref) => {
    (0, import_deprecated24.default)("wp.components.IsolatedEventContainer", {
      since: "5.7"
    });
    return /* @__PURE__ */ (0, import_jsx_runtime281.jsx)("div", {
      ...props,
      ref,
      onMouseDown: stopPropagation
    });
  });
  var isolated_event_container_default = IsolatedEventContainer;

  // packages/components/build-module/z-stack/component.mjs
  var import_element200 = __toESM(require_element(), 1);

  // packages/components/build-module/z-stack/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__35() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var ZStackChildView = /* @__PURE__ */ createStyled("div", false ? {
    target: "ebn2ljm1"
  } : {
    target: "ebn2ljm1",
    label: "ZStackChildView"
  })("&:not( :first-of-type ){", ({
    offsetAmount
  }) => /* @__PURE__ */ css({
    marginInlineStart: offsetAmount
  }, false ? "" : ";label:ZStackChildView;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFZRyIsImZpbGUiOiJzdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBaU3RhY2tDaGlsZFZpZXcgPSBzdHlsZWQuZGl2PCB7XG5cdG9mZnNldEFtb3VudDogbnVtYmVyO1xuXHR6SW5kZXg6IG51bWJlcjtcbn0gPmBcblx0Jjpub3QoIDpmaXJzdC1vZi10eXBlICkge1xuXHRcdCR7ICggeyBvZmZzZXRBbW91bnQgfSApID0+XG5cdFx0XHRjc3MoIHtcblx0XHRcdFx0bWFyZ2luSW5saW5lU3RhcnQ6IG9mZnNldEFtb3VudCxcblx0XHRcdH0gKSB9O1xuXHR9XG5cblx0JHsgKCB7IHpJbmRleCB9ICkgPT4gY3NzKCB7IHpJbmRleCB9ICkgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBaU3RhY2tWaWV3ID0gc3R5bGVkLmRpdjwge1xuXHRpc0xheWVyZWQ6IGJvb2xlYW47XG59ID5gXG5cdGRpc3BsYXk6IGlubGluZS1ncmlkO1xuXHRncmlkLWF1dG8tZmxvdzogY29sdW1uO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cblx0JiA+ICR7IFpTdGFja0NoaWxkVmlldyB9IHtcblx0XHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdFx0anVzdGlmeS1zZWxmOiBzdGFydDtcblxuXHRcdCR7ICggeyBpc0xheWVyZWQgfSApID0+XG5cdFx0XHRpc0xheWVyZWRcblx0XHRcdFx0PyAvLyBXaGVuIGBpc0xheWVyZWRgIGlzIHRydWUsIGFsbCBpdGVtcyBvdmVybGFwIGluIHRoZSBzYW1lIGdyaWQgY2VsbFxuXHRcdFx0XHQgIGNzcyggeyBncmlkUm93U3RhcnQ6IDEsIGdyaWRDb2x1bW5TdGFydDogMSB9IClcblx0XHRcdFx0OiB1bmRlZmluZWQgfTtcblx0fVxuYDtcbiJdfQ== */"), ";}", ({
    zIndex
  }) => /* @__PURE__ */ css({
    zIndex
  }, false ? "" : ";label:ZStackChildView;", false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFpQnNCIiwiZmlsZSI6InN0eWxlcy50cyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRXh0ZXJuYWwgZGVwZW5kZW5jaWVzXG4gKi9cbmltcG9ydCB7IGNzcyB9IGZyb20gJ0BlbW90aW9uL3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnQGVtb3Rpb24vc3R5bGVkJztcblxuZXhwb3J0IGNvbnN0IFpTdGFja0NoaWxkVmlldyA9IHN0eWxlZC5kaXY8IHtcblx0b2Zmc2V0QW1vdW50OiBudW1iZXI7XG5cdHpJbmRleDogbnVtYmVyO1xufSA+YFxuXHQmOm5vdCggOmZpcnN0LW9mLXR5cGUgKSB7XG5cdFx0JHsgKCB7IG9mZnNldEFtb3VudCB9ICkgPT5cblx0XHRcdGNzcygge1xuXHRcdFx0XHRtYXJnaW5JbmxpbmVTdGFydDogb2Zmc2V0QW1vdW50LFxuXHRcdFx0fSApIH07XG5cdH1cblxuXHQkeyAoIHsgekluZGV4IH0gKSA9PiBjc3MoIHsgekluZGV4IH0gKSB9O1xuYDtcblxuZXhwb3J0IGNvbnN0IFpTdGFja1ZpZXcgPSBzdHlsZWQuZGl2PCB7XG5cdGlzTGF5ZXJlZDogYm9vbGVhbjtcbn0gPmBcblx0ZGlzcGxheTogaW5saW5lLWdyaWQ7XG5cdGdyaWQtYXV0by1mbG93OiBjb2x1bW47XG5cdHBvc2l0aW9uOiByZWxhdGl2ZTtcblxuXHQmID4gJHsgWlN0YWNrQ2hpbGRWaWV3IH0ge1xuXHRcdHBvc2l0aW9uOiByZWxhdGl2ZTtcblx0XHRqdXN0aWZ5LXNlbGY6IHN0YXJ0O1xuXG5cdFx0JHsgKCB7IGlzTGF5ZXJlZCB9ICkgPT5cblx0XHRcdGlzTGF5ZXJlZFxuXHRcdFx0XHQ/IC8vIFdoZW4gYGlzTGF5ZXJlZGAgaXMgdHJ1ZSwgYWxsIGl0ZW1zIG92ZXJsYXAgaW4gdGhlIHNhbWUgZ3JpZCBjZWxsXG5cdFx0XHRcdCAgY3NzKCB7IGdyaWRSb3dTdGFydDogMSwgZ3JpZENvbHVtblN0YXJ0OiAxIH0gKVxuXHRcdFx0XHQ6IHVuZGVmaW5lZCB9O1xuXHR9XG5gO1xuIl19 */"), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTRyIsImZpbGUiOiJzdHlsZXMudHMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEV4dGVybmFsIGRlcGVuZGVuY2llc1xuICovXG5pbXBvcnQgeyBjc3MgfSBmcm9tICdAZW1vdGlvbi9yZWFjdCc7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ0BlbW90aW9uL3N0eWxlZCc7XG5cbmV4cG9ydCBjb25zdCBaU3RhY2tDaGlsZFZpZXcgPSBzdHlsZWQuZGl2PCB7XG5cdG9mZnNldEFtb3VudDogbnVtYmVyO1xuXHR6SW5kZXg6IG51bWJlcjtcbn0gPmBcblx0Jjpub3QoIDpmaXJzdC1vZi10eXBlICkge1xuXHRcdCR7ICggeyBvZmZzZXRBbW91bnQgfSApID0+XG5cdFx0XHRjc3MoIHtcblx0XHRcdFx0bWFyZ2luSW5saW5lU3RhcnQ6IG9mZnNldEFtb3VudCxcblx0XHRcdH0gKSB9O1xuXHR9XG5cblx0JHsgKCB7IHpJbmRleCB9ICkgPT4gY3NzKCB7IHpJbmRleCB9ICkgfTtcbmA7XG5cbmV4cG9ydCBjb25zdCBaU3RhY2tWaWV3ID0gc3R5bGVkLmRpdjwge1xuXHRpc0xheWVyZWQ6IGJvb2xlYW47XG59ID5gXG5cdGRpc3BsYXk6IGlubGluZS1ncmlkO1xuXHRncmlkLWF1dG8tZmxvdzogY29sdW1uO1xuXHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cblx0JiA+ICR7IFpTdGFja0NoaWxkVmlldyB9IHtcblx0XHRwb3NpdGlvbjogcmVsYXRpdmU7XG5cdFx0anVzdGlmeS1zZWxmOiBzdGFydDtcblxuXHRcdCR7ICggeyBpc0xheWVyZWQgfSApID0+XG5cdFx0XHRpc0xheWVyZWRcblx0XHRcdFx0PyAvLyBXaGVuIGBpc0xheWVyZWRgIGlzIHRydWUsIGFsbCBpdGVtcyBvdmVybGFwIGluIHRoZSBzYW1lIGdyaWQgY2VsbFxuXHRcdFx0XHQgIGNzcyggeyBncmlkUm93U3RhcnQ6IDEsIGdyaWRDb2x1bW5TdGFydDogMSB9IClcblx0XHRcdFx0OiB1bmRlZmluZWQgfTtcblx0fVxuYDtcbiJdfQ== */"));
  var _ref8 = false ? {
    name: "rs0gp6",
    styles: "grid-row-start:1;grid-column-start:1"
  } : {
    name: "80o7c0-ZStackView",
    styles: "grid-row-start:1;grid-column-start:1;label:ZStackView;/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFrQ00iLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG5leHBvcnQgY29uc3QgWlN0YWNrQ2hpbGRWaWV3ID0gc3R5bGVkLmRpdjwge1xuXHRvZmZzZXRBbW91bnQ6IG51bWJlcjtcblx0ekluZGV4OiBudW1iZXI7XG59ID5gXG5cdCY6bm90KCA6Zmlyc3Qtb2YtdHlwZSApIHtcblx0XHQkeyAoIHsgb2Zmc2V0QW1vdW50IH0gKSA9PlxuXHRcdFx0Y3NzKCB7XG5cdFx0XHRcdG1hcmdpbklubGluZVN0YXJ0OiBvZmZzZXRBbW91bnQsXG5cdFx0XHR9ICkgfTtcblx0fVxuXG5cdCR7ICggeyB6SW5kZXggfSApID0+IGNzcyggeyB6SW5kZXggfSApIH07XG5gO1xuXG5leHBvcnQgY29uc3QgWlN0YWNrVmlldyA9IHN0eWxlZC5kaXY8IHtcblx0aXNMYXllcmVkOiBib29sZWFuO1xufSA+YFxuXHRkaXNwbGF5OiBpbmxpbmUtZ3JpZDtcblx0Z3JpZC1hdXRvLWZsb3c6IGNvbHVtbjtcblx0cG9zaXRpb246IHJlbGF0aXZlO1xuXG5cdCYgPiAkeyBaU3RhY2tDaGlsZFZpZXcgfSB7XG5cdFx0cG9zaXRpb246IHJlbGF0aXZlO1xuXHRcdGp1c3RpZnktc2VsZjogc3RhcnQ7XG5cblx0XHQkeyAoIHsgaXNMYXllcmVkIH0gKSA9PlxuXHRcdFx0aXNMYXllcmVkXG5cdFx0XHRcdD8gLy8gV2hlbiBgaXNMYXllcmVkYCBpcyB0cnVlLCBhbGwgaXRlbXMgb3ZlcmxhcCBpbiB0aGUgc2FtZSBncmlkIGNlbGxcblx0XHRcdFx0ICBjc3MoIHsgZ3JpZFJvd1N0YXJ0OiAxLCBncmlkQ29sdW1uU3RhcnQ6IDEgfSApXG5cdFx0XHRcdDogdW5kZWZpbmVkIH07XG5cdH1cbmA7XG4iXX0= */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__35
  };
  var ZStackView = /* @__PURE__ */ createStyled("div", false ? {
    target: "ebn2ljm0"
  } : {
    target: "ebn2ljm0",
    label: "ZStackView"
  })("display:inline-grid;grid-auto-flow:column;position:relative;&>", ZStackChildView, "{position:relative;justify-self:start;", ({
    isLayered
  }) => isLayered ? (
    // When `isLayered` is true, all items overlap in the same grid cell
    _ref8
  ) : void 0, ";}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInN0eWxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQkciLCJmaWxlIjoic3R5bGVzLnRzIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRlcm5hbCBkZXBlbmRlbmNpZXNcbiAqL1xuaW1wb3J0IHsgY3NzIH0gZnJvbSAnQGVtb3Rpb24vcmVhY3QnO1xuaW1wb3J0IHN0eWxlZCBmcm9tICdAZW1vdGlvbi9zdHlsZWQnO1xuXG5leHBvcnQgY29uc3QgWlN0YWNrQ2hpbGRWaWV3ID0gc3R5bGVkLmRpdjwge1xuXHRvZmZzZXRBbW91bnQ6IG51bWJlcjtcblx0ekluZGV4OiBudW1iZXI7XG59ID5gXG5cdCY6bm90KCA6Zmlyc3Qtb2YtdHlwZSApIHtcblx0XHQkeyAoIHsgb2Zmc2V0QW1vdW50IH0gKSA9PlxuXHRcdFx0Y3NzKCB7XG5cdFx0XHRcdG1hcmdpbklubGluZVN0YXJ0OiBvZmZzZXRBbW91bnQsXG5cdFx0XHR9ICkgfTtcblx0fVxuXG5cdCR7ICggeyB6SW5kZXggfSApID0+IGNzcyggeyB6SW5kZXggfSApIH07XG5gO1xuXG5leHBvcnQgY29uc3QgWlN0YWNrVmlldyA9IHN0eWxlZC5kaXY8IHtcblx0aXNMYXllcmVkOiBib29sZWFuO1xufSA+YFxuXHRkaXNwbGF5OiBpbmxpbmUtZ3JpZDtcblx0Z3JpZC1hdXRvLWZsb3c6IGNvbHVtbjtcblx0cG9zaXRpb246IHJlbGF0aXZlO1xuXG5cdCYgPiAkeyBaU3RhY2tDaGlsZFZpZXcgfSB7XG5cdFx0cG9zaXRpb246IHJlbGF0aXZlO1xuXHRcdGp1c3RpZnktc2VsZjogc3RhcnQ7XG5cblx0XHQkeyAoIHsgaXNMYXllcmVkIH0gKSA9PlxuXHRcdFx0aXNMYXllcmVkXG5cdFx0XHRcdD8gLy8gV2hlbiBgaXNMYXllcmVkYCBpcyB0cnVlLCBhbGwgaXRlbXMgb3ZlcmxhcCBpbiB0aGUgc2FtZSBncmlkIGNlbGxcblx0XHRcdFx0ICBjc3MoIHsgZ3JpZFJvd1N0YXJ0OiAxLCBncmlkQ29sdW1uU3RhcnQ6IDEgfSApXG5cdFx0XHRcdDogdW5kZWZpbmVkIH07XG5cdH1cbmA7XG4iXX0= */"));

  // packages/components/build-module/z-stack/component.mjs
  var import_jsx_runtime282 = __toESM(require_jsx_runtime(), 1);
  function UnconnectedZStack(props, forwardedRef) {
    const {
      children,
      className: className2,
      isLayered = true,
      isReversed = false,
      offset: offset4 = 0,
      ...otherProps
    } = useContextSystem(props, "ZStack");
    const validChildren = getValidChildren(children);
    const childrenLastIndex = validChildren.length - 1;
    const clonedChildren = validChildren.map((child, index2) => {
      const zIndex = isReversed ? childrenLastIndex - index2 : index2;
      const offsetAmount = isLayered ? offset4 * index2 : offset4;
      const key = (0, import_element200.isValidElement)(child) ? child.key : index2;
      return /* @__PURE__ */ (0, import_jsx_runtime282.jsx)(ZStackChildView, {
        offsetAmount,
        zIndex,
        children: child
      }, key);
    });
    return /* @__PURE__ */ (0, import_jsx_runtime282.jsx)(ZStackView, {
      ...otherProps,
      className: className2,
      isLayered,
      ref: forwardedRef,
      children: clonedChildren
    });
  }
  var ZStack = contextConnect(UnconnectedZStack, "ZStack");
  var component_default41 = ZStack;

  // packages/components/build-module/higher-order/navigate-regions/index.mjs
  var import_element201 = __toESM(require_element(), 1);
  var import_compose76 = __toESM(require_compose(), 1);
  var import_keycodes3 = __toESM(require_keycodes(), 1);
  var import_jsx_runtime283 = __toESM(require_jsx_runtime(), 1);
  var defaultShortcuts = {
    previous: [{
      modifier: "ctrlShift",
      character: "`"
    }, {
      modifier: "ctrlShift",
      character: "~"
    }, {
      modifier: "access",
      character: "p"
    }],
    next: [{
      modifier: "ctrl",
      character: "`"
    }, {
      modifier: "access",
      character: "n"
    }]
  };
  function useNavigateRegions(shortcuts = defaultShortcuts) {
    const ref = (0, import_element201.useRef)(null);
    const [isFocusingRegions, setIsFocusingRegions] = (0, import_element201.useState)(false);
    function focusRegion(offset4) {
      const regions = Array.from(ref.current?.querySelectorAll('[role="region"][tabindex="-1"]') ?? []);
      if (!regions.length) {
        return;
      }
      let nextRegion = regions[0];
      const wrappingRegion = ref.current?.ownerDocument?.activeElement?.closest('[role="region"][tabindex="-1"]');
      const selectedIndex = wrappingRegion ? regions.indexOf(wrappingRegion) : -1;
      if (selectedIndex !== -1) {
        let nextIndex = selectedIndex + offset4;
        nextIndex = nextIndex === -1 ? regions.length - 1 : nextIndex;
        nextIndex = nextIndex === regions.length ? 0 : nextIndex;
        nextRegion = regions[nextIndex];
      }
      nextRegion.focus();
      setIsFocusingRegions(true);
    }
    const clickRef = (0, import_compose76.useRefEffect)((element) => {
      function onClick() {
        setIsFocusingRegions(false);
      }
      element.addEventListener("click", onClick);
      return () => {
        element.removeEventListener("click", onClick);
      };
    }, [setIsFocusingRegions]);
    return {
      ref: (0, import_compose76.useMergeRefs)([ref, clickRef]),
      className: isFocusingRegions ? "is-focusing-regions" : "",
      onKeyDown(event) {
        if (shortcuts.previous.some(({
          modifier,
          character: character2
        }) => {
          return import_keycodes3.isKeyboardEvent[modifier](event, character2);
        })) {
          focusRegion(-1);
        } else if (shortcuts.next.some(({
          modifier,
          character: character2
        }) => {
          return import_keycodes3.isKeyboardEvent[modifier](event, character2);
        })) {
          focusRegion(1);
        }
      }
    };
  }
  var navigate_regions_default = (0, import_compose76.createHigherOrderComponent)((Component7) => function NavigateRegions({
    shortcuts,
    ...props
  }) {
    return /* @__PURE__ */ (0, import_jsx_runtime283.jsx)("div", {
      ...useNavigateRegions(shortcuts),
      children: /* @__PURE__ */ (0, import_jsx_runtime283.jsx)(Component7, {
        ...props
      })
    });
  }, "navigateRegions");

  // packages/components/build-module/higher-order/with-constrained-tabbing/index.mjs
  var import_compose77 = __toESM(require_compose(), 1);
  var import_jsx_runtime284 = __toESM(require_jsx_runtime(), 1);
  var withConstrainedTabbing = (0, import_compose77.createHigherOrderComponent)((WrappedComponent) => function ComponentWithConstrainedTabbing(props) {
    const ref = (0, import_compose77.useConstrainedTabbing)();
    return /* @__PURE__ */ (0, import_jsx_runtime284.jsx)("div", {
      ref,
      tabIndex: -1,
      children: /* @__PURE__ */ (0, import_jsx_runtime284.jsx)(WrappedComponent, {
        ...props
      })
    });
  }, "withConstrainedTabbing");
  var with_constrained_tabbing_default = withConstrainedTabbing;

  // packages/components/build-module/higher-order/with-fallback-styles/index.mjs
  var import_es63 = __toESM(require_es6(), 1);
  var import_element202 = __toESM(require_element(), 1);
  var import_compose78 = __toESM(require_compose(), 1);
  var import_jsx_runtime285 = __toESM(require_jsx_runtime(), 1);
  var with_fallback_styles_default = (mapNodeToProps) => (0, import_compose78.createHigherOrderComponent)((WrappedComponent) => {
    return function WithFallbackStyles(props) {
      const [fallbackStyles, setFallbackStyles] = (0, import_element202.useState)(void 0);
      const nodeRef = (0, import_element202.useRef)(null);
      (0, import_compose78.useIsomorphicLayoutEffect)(() => {
        const node2 = props.node ?? nodeRef.current;
        const grabStylesCompleted = !!fallbackStyles && Object.values(fallbackStyles).every(Boolean);
        if (node2 && !grabStylesCompleted) {
          const newFallbackStyles = mapNodeToProps(node2, props);
          if (!(0, import_es63.default)(newFallbackStyles, fallbackStyles)) {
            setFallbackStyles(newFallbackStyles);
          }
        }
      });
      const wrappedComponent = /* @__PURE__ */ (0, import_jsx_runtime285.jsx)(WrappedComponent, {
        ...props,
        ...fallbackStyles
      });
      return props.node ? wrappedComponent : /* @__PURE__ */ (0, import_jsx_runtime285.jsxs)("div", {
        ref: nodeRef,
        children: [" ", wrappedComponent, " "]
      });
    };
  }, "withFallbackStyles");

  // packages/components/build-module/higher-order/with-filters/index.mjs
  var import_element203 = __toESM(require_element(), 1);
  var import_hooks11 = __toESM(require_hooks(), 1);
  var import_compose79 = __toESM(require_compose(), 1);
  var import_jsx_runtime286 = __toESM(require_jsx_runtime(), 1);
  var ANIMATION_FRAME_PERIOD = 16;
  function withFilters(hookName) {
    return (0, import_compose79.createHigherOrderComponent)((OriginalComponent) => {
      const namespace = "core/with-filters/" + hookName;
      let FilteredComponent;
      function ensureFilteredComponent() {
        if (FilteredComponent === void 0) {
          FilteredComponent = (0, import_hooks11.applyFilters)(hookName, OriginalComponent);
        }
      }
      class FilteredComponentRenderer extends import_element203.Component {
        constructor(props) {
          super(props);
          ensureFilteredComponent();
        }
        componentDidMount() {
          FilteredComponentRenderer.instances.push(this);
          if (FilteredComponentRenderer.instances.length === 1) {
            (0, import_hooks11.addAction)("hookRemoved", namespace, onHooksUpdated);
            (0, import_hooks11.addAction)("hookAdded", namespace, onHooksUpdated);
          }
        }
        componentWillUnmount() {
          FilteredComponentRenderer.instances = FilteredComponentRenderer.instances.filter((instance) => instance !== this);
          if (FilteredComponentRenderer.instances.length === 0) {
            (0, import_hooks11.removeAction)("hookRemoved", namespace);
            (0, import_hooks11.removeAction)("hookAdded", namespace);
          }
        }
        render() {
          return /* @__PURE__ */ (0, import_jsx_runtime286.jsx)(FilteredComponent, {
            ...this.props
          });
        }
      }
      FilteredComponentRenderer.instances = [];
      const throttledForceUpdate = (0, import_compose79.debounce)(() => {
        FilteredComponent = (0, import_hooks11.applyFilters)(hookName, OriginalComponent);
        FilteredComponentRenderer.instances.forEach((instance) => {
          instance.forceUpdate();
        });
      }, ANIMATION_FRAME_PERIOD);
      function onHooksUpdated(updatedHookName) {
        if (updatedHookName === hookName) {
          throttledForceUpdate();
        }
      }
      return FilteredComponentRenderer;
    }, "withFilters");
  }

  // packages/components/build-module/higher-order/with-focus-return/index.mjs
  var import_element204 = __toESM(require_element(), 1);
  var import_compose80 = __toESM(require_compose(), 1);
  var import_deprecated25 = __toESM(require_deprecated(), 1);
  var import_jsx_runtime287 = __toESM(require_jsx_runtime(), 1);
  function isComponentLike(object) {
    return object instanceof import_element204.Component || typeof object === "function";
  }
  var with_focus_return_default = (0, import_compose80.createHigherOrderComponent)(
    // @ts-expect-error TODO: Reconcile with intended `createHigherOrderComponent` types
    (options2) => {
      const HoC = ({
        onFocusReturn
      } = {}) => (WrappedComponent) => {
        const WithFocusReturn = (props) => {
          const ref = (0, import_compose80.useFocusReturn)(onFocusReturn);
          return /* @__PURE__ */ (0, import_jsx_runtime287.jsx)("div", {
            ref,
            children: /* @__PURE__ */ (0, import_jsx_runtime287.jsx)(WrappedComponent, {
              ...props
            })
          });
        };
        return WithFocusReturn;
      };
      if (isComponentLike(options2)) {
        const WrappedComponent = options2;
        return HoC()(WrappedComponent);
      }
      return HoC(options2);
    },
    "withFocusReturn"
  );
  var Provider3 = ({
    children
  }) => {
    (0, import_deprecated25.default)("wp.components.FocusReturnProvider component", {
      since: "5.7",
      hint: "This provider is not used anymore. You can just remove it from your codebase"
    });
    return children;
  };

  // packages/components/build-module/higher-order/with-notices/index.mjs
  var import_element205 = __toESM(require_element(), 1);
  var import_compose81 = __toESM(require_compose(), 1);
  var import_jsx_runtime288 = __toESM(require_jsx_runtime(), 1);
  var with_notices_default = (0, import_compose81.createHigherOrderComponent)((OriginalComponent) => {
    function Component7(props, ref) {
      const [noticeList, setNoticeList] = (0, import_element205.useState)([]);
      const noticeOperations = (0, import_element205.useMemo)(() => {
        const createNotice = (notice) => {
          const noticeToAdd = notice.id ? notice : {
            ...notice,
            id: v4_default()
          };
          setNoticeList((current) => [...current, noticeToAdd]);
        };
        return {
          createNotice,
          createErrorNotice: (msg) => {
            createNotice({
              status: "error",
              content: msg
            });
          },
          removeNotice: (id3) => {
            setNoticeList((current) => current.filter((notice) => notice.id !== id3));
          },
          removeAllNotices: () => {
            setNoticeList([]);
          }
        };
      }, []);
      const propsOut = {
        ...props,
        noticeList,
        noticeOperations,
        noticeUI: noticeList.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime288.jsx)(list_default, {
          className: "components-with-notices-ui",
          notices: noticeList,
          onRemove: noticeOperations.removeNotice
        })
      };
      return isForwardRef ? /* @__PURE__ */ (0, import_jsx_runtime288.jsx)(OriginalComponent, {
        ...propsOut,
        ref
      }) : /* @__PURE__ */ (0, import_jsx_runtime288.jsx)(OriginalComponent, {
        ...propsOut
      });
    }
    let isForwardRef;
    const {
      render
    } = OriginalComponent;
    if (typeof render === "function") {
      isForwardRef = true;
      return (0, import_element205.forwardRef)(Component7);
    }
    return Component7;
  }, "withNotices");

  // packages/components/build-module/higher-order/with-spoken-messages/index.mjs
  var import_compose82 = __toESM(require_compose(), 1);
  var import_a11y11 = __toESM(require_a11y(), 1);
  var import_jsx_runtime289 = __toESM(require_jsx_runtime(), 1);
  var with_spoken_messages_default = (0, import_compose82.createHigherOrderComponent)((Component7) => function WithSpokenMessages(props) {
    return /* @__PURE__ */ (0, import_jsx_runtime289.jsx)(Component7, {
      ...props,
      speak: import_a11y11.speak,
      debouncedSpeak: (0, import_compose82.useDebounce)(import_a11y11.speak, 500)
    });
  }, "withSpokenMessages");

  // packages/components/build-module/menu/index.mjs
  var import_element219 = __toESM(require_element(), 1);
  var import_i18n72 = __toESM(require_i18n(), 1);

  // packages/components/build-module/menu/context.mjs
  var import_element206 = __toESM(require_element(), 1);
  var Context2 = (0, import_element206.createContext)(void 0);
  Context2.displayName = "MenuContext";

  // packages/components/build-module/menu/item.mjs
  var import_element208 = __toESM(require_element(), 1);

  // packages/components/build-module/menu/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__36() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var CONTENT_WRAPPER_PADDING = space(1);
  var ITEM_PADDING_BLOCK = space(1);
  var ITEM_PADDING_INLINE = space(3);
  var DEFAULT_BORDER_COLOR = COLORS.theme.gray[300];
  var DIVIDER_COLOR = COLORS.theme.gray[200];
  var LIGHTER_TEXT_COLOR = COLORS.theme.gray[700];
  var LIGHT_BACKGROUND_COLOR = COLORS.theme.gray[100];
  var TOOLBAR_VARIANT_BORDER_COLOR = COLORS.theme.foreground;
  var DEFAULT_BOX_SHADOW = `0 0 0 ${config_values_default.borderWidth} ${DEFAULT_BORDER_COLOR}, ${config_values_default.elevationMedium}`;
  var TOOLBAR_VARIANT_BOX_SHADOW = `0 0 0 ${config_values_default.borderWidth} ${TOOLBAR_VARIANT_BORDER_COLOR}`;
  var GRID_TEMPLATE_COLS = "minmax( 0, max-content ) 1fr";
  var Menu22 = /* @__PURE__ */ createStyled(Menu, false ? {
    target: "e1wg7tti15"
  } : {
    target: "e1wg7tti15",
    label: "Menu"
  })(false ? {
    name: "1xd6ev0",
    styles: "position:relative;z-index:1000000;outline:2px solid transparent!important"
  } : {
    name: "1xd6ev0",
    styles: "position:relative;z-index:1000000;outline:2px solid transparent!important/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__36
  });
  var MenuSurface = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1wg7tti14"
  } : {
    target: "e1wg7tti14",
    label: "MenuSurface"
  })("display:grid;grid-template-columns:", GRID_TEMPLATE_COLS, ";grid-template-rows:auto;box-sizing:border-box;min-width:160px;max-width:320px;max-height:var( --popover-available-height );padding:", CONTENT_WRAPPER_PADDING, ";overscroll-behavior:contain;overflow:auto;background-color:", COLORS.ui.background, ";border-radius:", config_values_default.radiusMedium, ";", (props) => /* @__PURE__ */ css("box-shadow:", props.variant === "toolbar" ? TOOLBAR_VARIANT_BOX_SHADOW : DEFAULT_BOX_SHADOW, ";" + (false ? "" : ";label:MenuSurface;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var MenuMotionRoot = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1wg7tti13"
  } : {
    target: "e1wg7tti13",
    label: "MenuMotionRoot"
  })("@media not ( prefers-reduced-motion ){transition-property:transform,opacity;transition-duration:", DROPDOWN_MOTION_CSS.SLIDE_DURATION, ",", DROPDOWN_MOTION_CSS.FADE_DURATION, ";transition-timing-function:", DROPDOWN_MOTION_CSS.SLIDE_EASING, ",", DROPDOWN_MOTION_CSS.FADE_EASING, ";will-change:transform,opacity;&:not( :has( > ", MenuSurface, "[data-submenu] ) ){opacity:0;&:has( > ", MenuSurface, "[data-enter] ){opacity:1;}&:has( > ", MenuSurface, "[data-side='bottom'] ){transform:translateY(\n					-", DROPDOWN_MOTION_CSS.SLIDE_DISTANCE, "\n				);}&:has( > ", MenuSurface, "[data-side='top'] ){transform:translateY(\n					", DROPDOWN_MOTION_CSS.SLIDE_DISTANCE, "\n				);}&:has( > ", MenuSurface, "[data-side='left'] ){transform:translateX(\n					", DROPDOWN_MOTION_CSS.SLIDE_DISTANCE, "\n				);}&:has( > ", MenuSurface, "[data-side='right'] ){transform:translateX(\n					-", DROPDOWN_MOTION_CSS.SLIDE_DISTANCE, "\n				);}&:has( > ", MenuSurface, "[data-enter][data-side='bottom'] ),&:has( > ", MenuSurface, "[data-enter][data-side='top'] ){transform:translateY( 0 );}&:has( > ", MenuSurface, "[data-enter][data-side='left'] ),&:has( > ", MenuSurface, "[data-enter][data-side='right'] ){transform:translateX( 0 );}}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var baseItem = /* @__PURE__ */ css("all:unset;cursor:pointer;position:relative;min-height:", space(8), ";box-sizing:border-box;grid-column:1/-1;display:grid;grid-template-columns:", GRID_TEMPLATE_COLS, ";align-items:center;@supports ( grid-template-columns: subgrid ){grid-template-columns:subgrid;}font-size:", font("default.fontSize"), ";font-family:inherit;font-weight:normal;line-height:20px;color:", COLORS.theme.foreground, ";border-radius:", config_values_default.radiusSmall, ";padding-block:", ITEM_PADDING_BLOCK, ";padding-inline:", ITEM_PADDING_INLINE, ";scroll-margin:", CONTENT_WRAPPER_PADDING, ";user-select:none;outline:none;&[aria-disabled='true']{color:", COLORS.ui.textDisabled, ";}&[data-active-item]:not( [data-focus-visible] ):not(\n			[aria-disabled='true']\n		){background-color:", COLORS.theme.accent, ";color:", COLORS.theme.accentInverted, ";}&[data-focus-visible]{box-shadow:0 0 0 1.5px ", COLORS.theme.accent, ";outline:2px solid transparent;}&:active,&[data-active]{}", Menu22, ':not(:focus) &:not(:focus)[aria-expanded="true"]{background-color:', LIGHT_BACKGROUND_COLOR, ";color:", COLORS.theme.foreground, ";}svg{fill:currentColor;}" + (false ? "" : ";label:baseItem;"), false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */");
  var Item2 = /* @__PURE__ */ createStyled(MenuItem, false ? {
    target: "e1wg7tti12"
  } : {
    target: "e1wg7tti12",
    label: "Item"
  })(baseItem, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var CheckboxItem = /* @__PURE__ */ createStyled(MenuItemCheckbox, false ? {
    target: "e1wg7tti11"
  } : {
    target: "e1wg7tti11",
    label: "CheckboxItem"
  })(baseItem, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var RadioItem = /* @__PURE__ */ createStyled(MenuItemRadio, false ? {
    target: "e1wg7tti10"
  } : {
    target: "e1wg7tti10",
    label: "RadioItem"
  })(baseItem, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ItemPrefixWrapper = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1wg7tti9"
  } : {
    target: "e1wg7tti9",
    label: "ItemPrefixWrapper"
  })("grid-column:1;", CheckboxItem, ">&,", RadioItem, ">&{min-width:", space(6), ";}", CheckboxItem, ">&,", RadioItem, ">&,&:not( :empty ){margin-inline-end:", space(2), ";}display:flex;align-items:center;justify-content:center;color:", LIGHTER_TEXT_COLOR, ";[data-active-item]:not( [data-focus-visible] )>&,[aria-disabled='true']>&{color:inherit;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ItemContentWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1wg7tti8"
  } : {
    target: "e1wg7tti8",
    label: "ItemContentWrapper"
  })("grid-column:2;display:flex;align-items:center;justify-content:space-between;gap:", space(3), ";pointer-events:none;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ItemChildrenWrapper = /* @__PURE__ */ createStyled("div", false ? {
    target: "e1wg7tti7"
  } : {
    target: "e1wg7tti7",
    label: "ItemChildrenWrapper"
  })("flex:1;display:inline-flex;flex-direction:column;gap:", space(1), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ItemSuffixWrapper = /* @__PURE__ */ createStyled("span", false ? {
    target: "e1wg7tti6"
  } : {
    target: "e1wg7tti6",
    label: "ItemSuffixWrapper"
  })("flex:0 1 fit-content;min-width:0;width:fit-content;display:flex;align-items:center;justify-content:center;gap:", space(3), ";color:", LIGHTER_TEXT_COLOR, ";[data-active-item]:not( [data-focus-visible] ) *:not(", Menu22, ") &,[aria-disabled='true'] *:not(", Menu22, ") &{color:inherit;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var Group3 = /* @__PURE__ */ createStyled(MenuGroup, false ? {
    target: "e1wg7tti5"
  } : {
    target: "e1wg7tti5",
    label: "Group"
  })(false ? {
    name: "49aokf",
    styles: "display:contents"
  } : {
    name: "49aokf",
    styles: "display:contents/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__36
  });
  var GroupLabel3 = /* @__PURE__ */ createStyled(MenuGroupLabel, false ? {
    target: "e1wg7tti4"
  } : {
    target: "e1wg7tti4",
    label: "GroupLabel"
  })("grid-column:1/-1;padding-block-start:", space(3), ";padding-block-end:", space(2), ";padding-inline:", ITEM_PADDING_INLINE, ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var Separator3 = /* @__PURE__ */ createStyled(MenuSeparator, false ? {
    target: "e1wg7tti3"
  } : {
    target: "e1wg7tti3",
    label: "Separator"
  })("grid-column:1/-1;border:none;height:", config_values_default.borderWidth, ";background-color:", (props) => props.variant === "toolbar" ? TOOLBAR_VARIANT_BORDER_COLOR : DIVIDER_COLOR, ";margin-block:", space(2), ";margin-inline:", ITEM_PADDING_INLINE, ";outline:2px solid transparent;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var SubmenuChevronIcon = /* @__PURE__ */ createStyled(icon_default3, false ? {
    target: "e1wg7tti2"
  } : {
    target: "e1wg7tti2",
    label: "SubmenuChevronIcon"
  })("width:", space(1.5), ";", rtl({
    transform: `scaleX(1)`
  }, {
    transform: `scaleX(-1)`
  }), ";" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ItemLabel = /* @__PURE__ */ createStyled(component_default7, false ? {
    target: "e1wg7tti1"
  } : {
    target: "e1wg7tti1",
    label: "ItemLabel"
  })("font-size:", font("default.fontSize"), ";line-height:20px;color:inherit;" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var ItemHelpText = /* @__PURE__ */ createStyled(component_default7, false ? {
    target: "e1wg7tti0"
  } : {
    target: "e1wg7tti0",
    label: "ItemHelpText"
  })("font-size:", font("helpText.fontSize"), ";line-height:16px;color:", LIGHTER_TEXT_COLOR, ";overflow-wrap:anywhere;[data-active-item]:not( [data-focus-visible] ) *:not( ", Menu22, " ) &,[aria-disabled='true'] *:not( ", Menu22, " ) &{color:inherit;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // packages/components/build-module/menu/use-menu-item-hide-on-click.mjs
  var import_element207 = __toESM(require_element(), 1);
  function focusDisclosureElement(disclosureElement) {
    disclosureElement.focus();
    if (disclosureElement.ownerDocument.activeElement === disclosureElement) {
      return;
    }
    const inertAncestor = disclosureElement.closest("[inert]");
    if (inertAncestor) {
      inertAncestor.inert = false;
    }
    disclosureElement.ownerDocument.defaultView?.HTMLElement.prototype.focus.call(disclosureElement);
  }
  function useMenuItemHideOnClick(store, hideOnClick) {
    return (0, import_element207.useCallback)((event) => {
      const shouldHide = typeof hideOnClick === "function" ? hideOnClick(event) : hideOnClick;
      if (!shouldHide) {
        return false;
      }
      if (!store || !("hideAll" in store)) {
        return true;
      }
      const menuElement = store.getState().contentElement;
      const activeElement = menuElement?.ownerDocument.activeElement;
      if (menuElement?.contains(activeElement ?? null)) {
        let rootStore = store;
        while (rootStore.parent) {
          rootStore = rootStore.parent;
        }
        const disclosureElement = rootStore.getState().disclosureElement;
        if (disclosureElement) {
          focusDisclosureElement(disclosureElement);
        }
      }
      return true;
    }, [hideOnClick, store]);
  }

  // packages/components/build-module/menu/item.mjs
  var import_jsx_runtime290 = __toESM(require_jsx_runtime(), 1);
  var Item22 = (0, import_element208.forwardRef)(function Item3({
    prefix: prefix2,
    suffix,
    children,
    disabled = false,
    hideOnClick = true,
    store,
    ...props
  }, ref) {
    const menuContext = (0, import_element208.useContext)(Context2);
    const computedStore = store ?? menuContext?.store;
    const computedHideOnClick = useMenuItemHideOnClick(computedStore, hideOnClick);
    if (!menuContext?.store || !computedStore) {
      throw new Error("Menu.Item can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime290.jsxs)(Item2, {
      ref,
      ...props,
      accessibleWhenDisabled: true,
      disabled,
      store: computedStore,
      hideOnClick: computedHideOnClick,
      children: [/* @__PURE__ */ (0, import_jsx_runtime290.jsx)(ItemPrefixWrapper, {
        children: prefix2
      }), /* @__PURE__ */ (0, import_jsx_runtime290.jsxs)(ItemContentWrapper, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime290.jsx)(ItemChildrenWrapper, {
          children
        }), suffix && /* @__PURE__ */ (0, import_jsx_runtime290.jsx)(ItemSuffixWrapper, {
          children: suffix
        })]
      })]
    });
  });

  // packages/components/build-module/menu/checkbox-item.mjs
  var import_element209 = __toESM(require_element(), 1);
  var import_jsx_runtime291 = __toESM(require_jsx_runtime(), 1);
  var CheckboxItem2 = (0, import_element209.forwardRef)(function CheckboxItem3({
    suffix,
    children,
    disabled = false,
    hideOnClick = false,
    ...props
  }, ref) {
    const menuContext = (0, import_element209.useContext)(Context2);
    const store = menuContext?.store;
    const computedHideOnClick = useMenuItemHideOnClick(store, hideOnClick);
    if (!store) {
      throw new Error("Menu.CheckboxItem can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime291.jsxs)(CheckboxItem, {
      ref,
      ...props,
      accessibleWhenDisabled: true,
      disabled,
      store,
      hideOnClick: computedHideOnClick,
      children: [/* @__PURE__ */ (0, import_jsx_runtime291.jsx)(MenuItemCheck, {
        store,
        render: /* @__PURE__ */ (0, import_jsx_runtime291.jsx)(ItemPrefixWrapper, {}),
        style: {
          width: "auto",
          height: "auto"
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime291.jsx)(icon_default2, {
          icon: check_default,
          size: 24
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime291.jsxs)(ItemContentWrapper, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime291.jsx)(ItemChildrenWrapper, {
          children
        }), suffix && /* @__PURE__ */ (0, import_jsx_runtime291.jsx)(ItemSuffixWrapper, {
          children: suffix
        })]
      })]
    });
  });

  // packages/components/build-module/menu/radio-item.mjs
  var import_element210 = __toESM(require_element(), 1);
  var import_primitives34 = __toESM(require_primitives(), 1);
  var import_jsx_runtime292 = __toESM(require_jsx_runtime(), 1);
  var radioCheck = /* @__PURE__ */ (0, import_jsx_runtime292.jsx)(import_primitives34.SVG, {
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 24 24",
    children: /* @__PURE__ */ (0, import_jsx_runtime292.jsx)(import_primitives34.Circle, {
      cx: 12,
      cy: 12,
      r: 3
    })
  });
  var RadioItem2 = (0, import_element210.forwardRef)(function RadioItem3({
    suffix,
    children,
    disabled = false,
    hideOnClick = false,
    ...props
  }, ref) {
    const menuContext = (0, import_element210.useContext)(Context2);
    const store = menuContext?.store;
    const computedHideOnClick = useMenuItemHideOnClick(store, hideOnClick);
    if (!store) {
      throw new Error("Menu.RadioItem can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime292.jsxs)(RadioItem, {
      ref,
      ...props,
      accessibleWhenDisabled: true,
      disabled,
      store,
      hideOnClick: computedHideOnClick,
      children: [/* @__PURE__ */ (0, import_jsx_runtime292.jsx)(MenuItemCheck, {
        store,
        render: /* @__PURE__ */ (0, import_jsx_runtime292.jsx)(ItemPrefixWrapper, {}),
        style: {
          width: "auto",
          height: "auto"
        },
        children: /* @__PURE__ */ (0, import_jsx_runtime292.jsx)(icon_default2, {
          icon: radioCheck,
          size: 24
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime292.jsxs)(ItemContentWrapper, {
        children: [/* @__PURE__ */ (0, import_jsx_runtime292.jsx)(ItemChildrenWrapper, {
          children
        }), suffix && /* @__PURE__ */ (0, import_jsx_runtime292.jsx)(ItemSuffixWrapper, {
          children: suffix
        })]
      })]
    });
  });

  // packages/components/build-module/menu/group.mjs
  var import_element211 = __toESM(require_element(), 1);
  var import_jsx_runtime293 = __toESM(require_jsx_runtime(), 1);
  var Group22 = (0, import_element211.forwardRef)(function Group32(props, ref) {
    const menuContext = (0, import_element211.useContext)(Context2);
    if (!menuContext?.store) {
      throw new Error("Menu.Group can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime293.jsx)(Group3, {
      ref,
      ...props,
      store: menuContext.store
    });
  });

  // packages/components/build-module/menu/group-label.mjs
  var import_element212 = __toESM(require_element(), 1);
  var import_jsx_runtime294 = __toESM(require_jsx_runtime(), 1);
  var GroupLabel22 = (0, import_element212.forwardRef)(function Group4(props, ref) {
    const menuContext = (0, import_element212.useContext)(Context2);
    if (!menuContext?.store) {
      throw new Error("Menu.GroupLabel can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime294.jsx)(GroupLabel3, {
      ref,
      render: (
        // @ts-expect-error The `children` prop is passed
        /* @__PURE__ */ (0, import_jsx_runtime294.jsx)(component_default8, {
          upperCase: true,
          variant: "muted",
          size: "11px",
          weight: config_values_default.fontWeightEmphasis,
          lineHeight: "16px"
        })
      ),
      ...props,
      store: menuContext.store
    });
  });

  // packages/components/build-module/menu/separator.mjs
  var import_element213 = __toESM(require_element(), 1);
  var import_jsx_runtime295 = __toESM(require_jsx_runtime(), 1);
  var Separator22 = (0, import_element213.forwardRef)(function Separator32(props, ref) {
    const menuContext = (0, import_element213.useContext)(Context2);
    if (!menuContext?.store) {
      throw new Error("Menu.Separator can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime295.jsx)(Separator3, {
      ref,
      ...props,
      store: menuContext.store,
      variant: menuContext.variant
    });
  });

  // packages/components/build-module/menu/item-label.mjs
  var import_element214 = __toESM(require_element(), 1);
  var import_jsx_runtime296 = __toESM(require_jsx_runtime(), 1);
  var ItemLabel2 = (0, import_element214.forwardRef)(function ItemLabel3(props, ref) {
    const menuContext = (0, import_element214.useContext)(Context2);
    if (!menuContext?.store) {
      throw new Error("Menu.ItemLabel can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime296.jsx)(ItemLabel, {
      numberOfLines: 1,
      ref,
      ...props
    });
  });

  // packages/components/build-module/menu/item-help-text.mjs
  var import_element215 = __toESM(require_element(), 1);
  var import_jsx_runtime297 = __toESM(require_jsx_runtime(), 1);
  var ItemHelpText2 = (0, import_element215.forwardRef)(function ItemHelpText3(props, ref) {
    const menuContext = (0, import_element215.useContext)(Context2);
    if (!menuContext?.store) {
      throw new Error("Menu.ItemHelpText can only be rendered inside a Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime297.jsx)(ItemHelpText, {
      numberOfLines: 2,
      ref,
      ...props
    });
  });

  // packages/components/build-module/menu/trigger-button.mjs
  var import_element216 = __toESM(require_element(), 1);
  var import_jsx_runtime298 = __toESM(require_jsx_runtime(), 1);
  var TriggerButton = (0, import_element216.forwardRef)(function TriggerButton2({
    children,
    disabled = false,
    ...props
  }, ref) {
    const menuContext = (0, import_element216.useContext)(Context2);
    if (!menuContext?.store) {
      throw new Error("Menu.TriggerButton can only be rendered inside a Menu component");
    }
    if (menuContext.store.parent) {
      throw new Error("Menu.TriggerButton should not be rendered inside a nested Menu component. Use Menu.SubmenuTriggerItem instead.");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime298.jsx)(MenuButton, {
      ref,
      ...props,
      disabled,
      store: menuContext.store,
      children
    });
  });

  // packages/components/build-module/menu/submenu-trigger-item.mjs
  var import_element217 = __toESM(require_element(), 1);
  var import_jsx_runtime299 = __toESM(require_jsx_runtime(), 1);
  var SubmenuTriggerItem = (0, import_element217.forwardRef)(function SubmenuTriggerItem2({
    suffix,
    ...otherProps
  }, ref) {
    const menuContext = (0, import_element217.useContext)(Context2);
    if (!menuContext?.store.parent) {
      throw new Error("Menu.SubmenuTriggerItem can only be rendered inside a nested Menu component");
    }
    return /* @__PURE__ */ (0, import_jsx_runtime299.jsx)(MenuButton, {
      ref,
      accessibleWhenDisabled: true,
      store: menuContext.store,
      render: /* @__PURE__ */ (0, import_jsx_runtime299.jsx)(Item22, {
        ...otherProps,
        // The menu item needs to register and be part of the parent menu.
        // Without specifying the store explicitly, the `Item` component
        // would otherwise read the store via context and pick up the one from
        // the sub-menu `Menu` component.
        store: menuContext.store.parent,
        suffix: /* @__PURE__ */ (0, import_jsx_runtime299.jsxs)(import_jsx_runtime299.Fragment, {
          children: [suffix, /* @__PURE__ */ (0, import_jsx_runtime299.jsx)(SubmenuChevronIcon, {
            "aria-hidden": "true",
            icon: chevron_right_small_default,
            size: 24,
            preserveAspectRatio: "xMidYMid slice"
          })]
        })
      })
    });
  });

  // packages/components/build-module/menu/popover.mjs
  var import_element218 = __toESM(require_element(), 1);
  var import_jsx_runtime300 = __toESM(require_jsx_runtime(), 1);
  var Popover4 = (0, import_element218.forwardRef)(function Popover22({
    gutter,
    shift: shift4,
    modal = true,
    ...otherProps
  }, ref) {
    const menuContext = (0, import_element218.useContext)(Context2);
    const appliedPlacementSide = useStoreState(menuContext?.store, "currentPlacement")?.split("-")[0];
    const hideOnEscape = (0, import_element218.useCallback)((event) => {
      event.preventDefault();
      return true;
    }, []);
    const computedDirection = useStoreState(menuContext?.store, "rtl") ? "rtl" : "ltr";
    const wrapperProps = (0, import_element218.useMemo)(() => ({
      dir: computedDirection,
      style: {
        direction: computedDirection
      }
    }), [computedDirection]);
    if (!menuContext?.store) {
      throw new Error("Menu.Popover can only be rendered inside a Menu component");
    }
    const renderMenu = (0, import_element218.useCallback)((htmlProps) => /* @__PURE__ */ (0, import_jsx_runtime300.jsx)(MenuMotionRoot, {
      children: /* @__PURE__ */ (0, import_jsx_runtime300.jsx)(MenuSurface, {
        ...htmlProps,
        variant: menuContext.variant
      })
    }), [menuContext.variant]);
    return /* @__PURE__ */ (0, import_jsx_runtime300.jsx)(Menu22, {
      ...otherProps,
      ref,
      modal,
      store: menuContext.store,
      gutter: gutter ?? (menuContext.store.parent ? 0 : 8),
      shift: shift4 ?? (menuContext.store.parent ? -4 : 0),
      hideOnHoverOutside: false,
      "data-side": appliedPlacementSide,
      "data-submenu": !!menuContext.store.parent || void 0,
      wrapperProps,
      hideOnEscape,
      unmountOnHide: true,
      render: renderMenu
    });
  });

  // packages/components/build-module/menu/index.mjs
  var import_jsx_runtime301 = __toESM(require_jsx_runtime(), 1);
  var UnconnectedMenu = (props) => {
    const {
      children,
      defaultOpen = false,
      open,
      onOpenChange,
      placement,
      // From internal components context
      variant
    } = useContextSystem(props, "Menu");
    const parentContext = (0, import_element219.useContext)(Context2);
    const rtl2 = (0, import_i18n72.isRTL)();
    let computedPlacement = placement ?? (parentContext?.store ? "right-start" : "bottom-start");
    if (rtl2) {
      if (/right/.test(computedPlacement)) {
        computedPlacement = computedPlacement.replace("right", "left");
      } else if (/left/.test(computedPlacement)) {
        computedPlacement = computedPlacement.replace("left", "right");
      }
    }
    const menuStore = useMenuStore({
      parent: parentContext?.store,
      open,
      defaultOpen,
      placement: computedPlacement,
      focusLoop: true,
      setOpen(willBeOpen) {
        onOpenChange?.(willBeOpen);
      },
      rtl: rtl2
    });
    const contextValue = (0, import_element219.useMemo)(() => ({
      store: menuStore,
      variant
    }), [menuStore, variant]);
    return /* @__PURE__ */ (0, import_jsx_runtime301.jsx)(Context2.Provider, {
      value: contextValue,
      children
    });
  };
  var Menu3 = Object.assign(contextConnectWithoutRef(UnconnectedMenu, "Menu"), {
    Context: Object.assign(Context2, {
      displayName: "Menu.Context"
    }),
    /**
     * Renders a menu item inside the `Menu.Popover` or `Menu.Group` components.
     *
     * It can optionally contain one instance of the `Menu.ItemLabel` component
     * and one instance of the `Menu.ItemHelpText` component.
     */
    Item: Object.assign(Item22, {
      displayName: "Menu.Item"
    }),
    /**
     * Renders a radio menu item inside the `Menu.Popover` or `Menu.Group`
     * components.
     *
     * It can optionally contain one instance of the `Menu.ItemLabel` component
     * and one instance of the `Menu.ItemHelpText` component.
     */
    RadioItem: Object.assign(RadioItem2, {
      displayName: "Menu.RadioItem"
    }),
    /**
     * Renders a checkbox menu item inside the `Menu.Popover` or `Menu.Group`
     * components.
     *
     * It can optionally contain one instance of the `Menu.ItemLabel` component
     * and one instance of the `Menu.ItemHelpText` component.
     */
    CheckboxItem: Object.assign(CheckboxItem2, {
      displayName: "Menu.CheckboxItem"
    }),
    /**
     * Renders a group for menu items.
     *
     * It should contain one instance of `Menu.GroupLabel` and one or more
     * instances of `Menu.Item`, `Menu.RadioItem`, or `Menu.CheckboxItem`.
     */
    Group: Object.assign(Group22, {
      displayName: "Menu.Group"
    }),
    /**
     * Renders a label in a menu group.
     *
     * This component should be wrapped with `Menu.Group` so the
     * `aria-labelledby` is correctly set on the group element.
     */
    GroupLabel: Object.assign(GroupLabel22, {
      displayName: "Menu.GroupLabel"
    }),
    /**
     * Renders a divider between menu items or menu groups.
     */
    Separator: Object.assign(Separator22, {
      displayName: "Menu.Separator"
    }),
    /**
     * Renders a menu item's label text. It should be wrapped with `Menu.Item`,
     * `Menu.RadioItem`, or `Menu.CheckboxItem`.
     */
    ItemLabel: Object.assign(ItemLabel2, {
      displayName: "Menu.ItemLabel"
    }),
    /**
     * Renders a menu item's help text. It should be wrapped with `Menu.Item`,
     * `Menu.RadioItem`, or `Menu.CheckboxItem`.
     */
    ItemHelpText: Object.assign(ItemHelpText2, {
      displayName: "Menu.ItemHelpText"
    }),
    /**
     * Renders a dropdown menu element that's controlled by a sibling
     * `Menu.TriggerButton` component. It renders a popover and automatically
     * focuses on items when the menu is shown.
     *
     * The only valid children of `Menu.Popover` are `Menu.Item`,
     * `Menu.RadioItem`, `Menu.CheckboxItem`, `Menu.Group`, `Menu.Separator`,
     * and `Menu` (for nested dropdown menus).
     */
    Popover: Object.assign(Popover4, {
      displayName: "Menu.Popover"
    }),
    /**
     * Renders a menu button that toggles the visibility of a sibling
     * `Menu.Popover` component when clicked or when using arrow keys.
     */
    TriggerButton: Object.assign(TriggerButton, {
      displayName: "Menu.TriggerButton"
    }),
    /**
     * Renders a menu item that toggles the visibility of a sibling
     * `Menu.Popover` component when clicked or when using arrow keys.
     *
     * This component is used to create a nested dropdown menu.
     */
    SubmenuTriggerItem: Object.assign(SubmenuTriggerItem, {
      displayName: "Menu.SubmenuTriggerItem"
    })
  });

  // packages/components/build-module/theme/index.mjs
  var import_element220 = __toESM(require_element(), 1);

  // packages/components/build-module/theme/color-algorithms.mjs
  var import_warning11 = __toESM(require_warning(), 1);
  k([names_default, a11y_default]);
  function generateThemeVariables(inputs) {
    validateInputs(inputs);
    const generatedColors = {
      ...generateAccentDependentColors(inputs.accent),
      ...generateBackgroundDependentColors(inputs.background)
    };
    warnContrastIssues(checkContrasts(inputs, generatedColors));
    return {
      colors: generatedColors
    };
  }
  function validateInputs(inputs) {
    for (const [key, value] of Object.entries(inputs)) {
      if (typeof value !== "undefined" && !w(value).isValid()) {
        true ? (0, import_warning11.default)(`wp.components.Theme: "${value}" is not a valid color value for the '${key}' prop.`) : void 0;
      }
    }
  }
  function checkContrasts(inputs, outputs) {
    const background = inputs.background || COLORS.white;
    const accent = inputs.accent || "#3858e9";
    const foreground = outputs.foreground || COLORS.gray[900];
    const gray = outputs.gray || COLORS.gray;
    return {
      accent: w(background).isReadable(accent) ? void 0 : `The background color ("${background}") does not have sufficient contrast against the accent color ("${accent}").`,
      foreground: w(background).isReadable(foreground) ? void 0 : `The background color provided ("${background}") does not have sufficient contrast against the standard foreground colors.`,
      grays: w(background).contrast(gray[600]) >= 3 && w(background).contrast(gray[700]) >= 4.5 ? void 0 : `The background color provided ("${background}") cannot generate a set of grayscale foreground colors with sufficient contrast. Try adjusting the color to be lighter or darker.`
    };
  }
  function warnContrastIssues(issues) {
    for (const error of Object.values(issues)) {
      if (error) {
        true ? (0, import_warning11.default)("wp.components.Theme: " + error) : void 0;
      }
    }
  }
  function generateAccentDependentColors(accent) {
    if (!accent) {
      return {};
    }
    return {
      accent,
      accentDarker10: w(accent).darken(0.1).toHex(),
      accentDarker20: w(accent).darken(0.2).toHex(),
      accentInverted: getForegroundForColor(accent)
    };
  }
  function generateBackgroundDependentColors(background) {
    if (!background) {
      return {};
    }
    const foreground = getForegroundForColor(background);
    return {
      background,
      foreground,
      foregroundInverted: getForegroundForColor(foreground),
      gray: generateShades(background, foreground)
    };
  }
  function getForegroundForColor(color2) {
    return w(color2).isDark() ? COLORS.white : COLORS.gray[900];
  }
  function generateShades(background, foreground) {
    const SHADES = {
      100: 0.06,
      200: 0.121,
      300: 0.132,
      400: 0.2,
      600: 0.42,
      700: 0.543,
      800: 0.821
    };
    const limit = 0.884;
    const direction = w(background).isDark() ? "lighten" : "darken";
    const range = Math.abs(w(background).toHsl().l - w(foreground).toHsl().l) / 100;
    const result = {};
    Object.entries(SHADES).forEach(([key, value]) => {
      result[parseInt(key)] = w(background)[direction](value / limit * range).toHex();
    });
    return result;
  }

  // packages/components/build-module/theme/index.mjs
  var import_jsx_runtime302 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE17 = "data-wp-hash";
  function getRuntime17() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument17(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash17(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE17}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE17) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle17(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime17();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash17(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE17, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument17(targetDocument) {
    const runtime = getRuntime17();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle17(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle16(hash2, css3) {
    const runtime = getRuntime17();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle17(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle16("cd3164b4a3", ".ca605c9335af4c37__wrapper{color:var(--wp-components-color-foreground,currentColor)}");
  }
  var style_module_default15 = { "wrapper": "ca605c9335af4c37__wrapper" };
  var getColorVariables = ({
    colors
  }) => ({
    "--wp-components-color-accent": colors.accent,
    "--wp-components-color-accent-darker-10": colors.accentDarker10,
    "--wp-components-color-accent-darker-20": colors.accentDarker20,
    "--wp-components-color-accent-inverted": colors.accentInverted,
    "--wp-components-color-background": colors.background,
    "--wp-components-color-foreground": colors.foreground,
    "--wp-components-color-foreground-inverted": colors.foregroundInverted,
    ...Object.fromEntries(Object.entries(colors.gray ?? {}).map(([key, value]) => [`--wp-components-color-gray-${key}`, value]))
  });
  function Theme({
    accent,
    background,
    className: className2,
    style: style2,
    ...props
  }) {
    const themeVariables = (0, import_element220.useMemo)(() => getColorVariables(generateThemeVariables({
      accent,
      background
    })), [accent, background]);
    const wrapperStyle = (0, import_element220.useMemo)(() => ({
      ...themeVariables,
      ...style2
    }), [style2, themeVariables]);
    return /* @__PURE__ */ (0, import_jsx_runtime302.jsx)(PolymorphicElement, {
      className: clsx_default(style_module_default15.wrapper, className2),
      style: wrapperStyle,
      ...props
    });
  }
  var theme_default = Theme;

  // packages/components/build-module/tabs/index.mjs
  var import_compose85 = __toESM(require_compose(), 1);
  var import_element226 = __toESM(require_element(), 1);
  var import_i18n73 = __toESM(require_i18n(), 1);

  // packages/components/build-module/tabs/context.mjs
  var import_element221 = __toESM(require_element(), 1);
  var TabsContext = (0, import_element221.createContext)(void 0);
  TabsContext.displayName = "TabsContext";
  var useTabsContext = () => (0, import_element221.useContext)(TabsContext);

  // packages/components/build-module/tabs/tab.mjs
  var import_element222 = __toESM(require_element(), 1);
  var import_warning12 = __toESM(require_warning(), 1);

  // packages/components/build-module/tabs/styles.mjs
  function _EMOTION_STRINGIFIED_CSS_ERROR__37() {
    return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
  }
  var StyledTabList = /* @__PURE__ */ createStyled(TabList, false ? {
    target: "enfox0g4"
  } : {
    target: "enfox0g4",
    label: "StyledTabList"
  })("display:flex;align-items:stretch;overflow-x:auto;&[aria-orientation='vertical']{flex-direction:column;}:where( [aria-orientation='horizontal'] ){width:fit-content;}--direction-factor:1;--direction-start:left;--direction-end:right;--selected-start:var( --selected-left, 0 );&:dir( rtl ){--direction-factor:-1;--direction-start:right;--direction-end:left;--selected-start:var( --selected-right, 0 );}@media not ( prefers-reduced-motion ){&[data-indicator-animated]::before{transition-property:transform,border-radius,border-block;transition-duration:0.2s;transition-timing-function:ease-out;}}position:relative;&::before{content:'';position:absolute;pointer-events:none;transform-origin:var( --direction-start ) top;outline:2px solid transparent;outline-offset:-1px;}--antialiasing-factor:100;&[aria-orientation='horizontal']{--fade-width:64px;--fade-gradient-base:transparent 0%,black var( --fade-width );--fade-gradient-composed:var( --fade-gradient-base ),black 60%,transparent 50%;&.is-overflowing-first{mask-image:linear-gradient(\n				to var( --direction-end ),\n				var( --fade-gradient-base )\n			);}&.is-overflowing-last{mask-image:linear-gradient(\n				to var( --direction-start ),\n				var( --fade-gradient-base )\n			);}&.is-overflowing-first.is-overflowing-last{mask-image:linear-gradient(\n					to right,\n					var( --fade-gradient-composed )\n				),linear-gradient( to left, var( --fade-gradient-composed ) );}&::before{bottom:0;height:0;width:calc( var( --antialiasing-factor ) * 1px );transform:translateX(\n					calc(\n						var( --selected-start ) * var( --direction-factor ) *\n							1px\n					)\n				) scaleX(\n					calc(\n						var( --selected-width, 0 ) /\n							var( --antialiasing-factor )\n					)\n				);border-bottom:var( --wp-admin-border-width-focus ) solid ", COLORS.theme.gray[700], ";}}&[aria-orientation='vertical']{&::before{border-radius:", config_values_default.radiusSmall, "/calc(\n					", config_values_default.radiusSmall, " /\n						(\n							var( --selected-height, 0 ) /\n								var( --antialiasing-factor )\n						)\n				);top:0;left:0;width:100%;height:calc( var( --antialiasing-factor ) * 1px );transform:translateY( calc( var( --selected-top, 0 ) * 1px ) ) scaleY(\n					calc(\n						var( --selected-height, 0 ) /\n							var( --antialiasing-factor )\n					)\n				);background-color:", COLORS.theme.gray[100], ";}&[data-select-on-move='true']:has(\n				:is( :focus-visible, [data-focus-visible] )\n			)::before{box-sizing:border-box;border:var( --wp-admin-border-width-focus ) solid ", COLORS.theme.accent, ";border-block-width:calc(\n				var( --wp-admin-border-width-focus, 1px ) /\n					(\n						var( --selected-height, 0 ) /\n							var( --antialiasing-factor )\n					)\n			);}}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var Tab22 = /* @__PURE__ */ createStyled(Tab, false ? {
    target: "enfox0g3"
  } : {
    target: "enfox0g3",
    label: "Tab"
  })("&{border-radius:0;background:transparent;border:none;box-shadow:none;flex:1 0 auto;white-space:nowrap;display:flex;align-items:center;cursor:pointer;line-height:1.2;font-family:", font("default.fontFamily"), ";font-weight:400;font-size:", font("default.fontSize"), ";color:", COLORS.theme.foreground, ";position:relative;&[aria-disabled='true']{cursor:default;color:", COLORS.ui.textDisabled, ";}&:not( [aria-disabled='true'] ):is( :hover, [data-focus-visible] ){color:", COLORS.theme.foreground, ";}&:focus:not( :disabled ){box-shadow:none;outline:none;}&::after{position:absolute;pointer-events:none;outline:var( --wp-admin-border-width-focus ) solid ", COLORS.theme.accent, ";border-radius:", config_values_default.radiusSmall, ";opacity:0;@media not ( prefers-reduced-motion ){transition:opacity 0.1s linear;}}&[data-focus-visible]::after{opacity:1;}}[aria-orientation='horizontal'] &{padding-inline:", space(4), ";height:", space(12), ";scroll-margin:24px;&::after{content:'';inset:", space(3), ";}}[aria-orientation='vertical'] &{padding:", space(2), " ", space(3), ";min-height:", space(10), ";&[aria-selected='true']{fill:currentColor;}}[aria-orientation='vertical'][data-select-on-move='false'] &::after{content:'';inset:var( --wp-admin-border-width-focus );}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var TabChildren = /* @__PURE__ */ createStyled("span", false ? {
    target: "enfox0g2"
  } : {
    target: "enfox0g2",
    label: "TabChildren"
  })(false ? {
    name: "9at4z3",
    styles: "flex-grow:1;display:flex;align-items:center;[aria-orientation='horizontal'] &{justify-content:center;}[aria-orientation='vertical'] &{justify-content:start;}"
  } : {
    name: "9at4z3",
    styles: "flex-grow:1;display:flex;align-items:center;[aria-orientation='horizontal'] &{justify-content:center;}[aria-orientation='vertical'] &{justify-content:start;}/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */",
    toString: _EMOTION_STRINGIFIED_CSS_ERROR__37
  });
  var TabChevron = /* @__PURE__ */ createStyled(icon_default3, false ? {
    target: "enfox0g1"
  } : {
    target: "enfox0g1",
    label: "TabChevron"
  })("flex-shrink:0;margin-inline-end:", space(-1), ";[aria-orientation='horizontal'] &{display:none;}opacity:0;[role='tab']:is( [aria-selected='true'], [data-focus-visible], :hover ) &{opacity:1;}@media not ( prefers-reduced-motion ){[data-select-on-move='true'] [role='tab']:is( [aria-selected='true'],  ) &{transition:opacity 0.15s 0.15s linear;}}&:dir( rtl ){rotate:180deg;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));
  var TabPanel23 = /* @__PURE__ */ createStyled(TabPanel, false ? {
    target: "enfox0g0"
  } : {
    target: "enfox0g0",
    label: "TabPanel"
  })("&:focus{box-shadow:none;outline:none;}&[data-focus-visible]{box-shadow:0 0 0 var( --wp-admin-border-width-focus ) ", COLORS.theme.accent, ";outline:2px solid transparent;outline-offset:0;}" + (false ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,  */"));

  // packages/components/build-module/tabs/tab.mjs
  var import_jsx_runtime303 = __toESM(require_jsx_runtime(), 1);
  var Tab3 = (0, import_element222.forwardRef)(function Tab23({
    children,
    tabId,
    disabled,
    render,
    ...otherProps
  }, ref) {
    const {
      store,
      instanceId
    } = useTabsContext() ?? {};
    if (!store) {
      true ? (0, import_warning12.default)("`Tabs.Tab` must be wrapped in a `Tabs` component.") : void 0;
      return null;
    }
    const instancedTabId = `${instanceId}-${tabId}`;
    return /* @__PURE__ */ (0, import_jsx_runtime303.jsxs)(Tab22, {
      ref,
      store,
      id: instancedTabId,
      disabled,
      render,
      ...otherProps,
      children: [/* @__PURE__ */ (0, import_jsx_runtime303.jsx)(TabChildren, {
        children
      }), /* @__PURE__ */ (0, import_jsx_runtime303.jsx)(TabChevron, {
        icon: chevron_right_default
      })]
    });
  });

  // packages/components/build-module/tabs/tablist.mjs
  var import_warning13 = __toESM(require_warning(), 1);
  var import_element224 = __toESM(require_element(), 1);
  var import_compose84 = __toESM(require_compose(), 1);

  // packages/components/build-module/tabs/use-track-overflow.mjs
  var import_element223 = __toESM(require_element(), 1);
  var import_compose83 = __toESM(require_compose(), 1);
  function useTrackOverflow(parent, children) {
    const [first, setFirst] = (0, import_element223.useState)(false);
    const [last, setLast] = (0, import_element223.useState)(false);
    const [observer, setObserver] = (0, import_element223.useState)();
    const callback = (0, import_compose83.useEvent)((entries) => {
      for (const entry of entries) {
        if (entry.target === children.first) {
          setFirst(!entry.isIntersecting);
        }
        if (entry.target === children.last) {
          setLast(!entry.isIntersecting);
        }
      }
    });
    (0, import_element223.useEffect)(() => {
      if (!parent || !window.IntersectionObserver) {
        return;
      }
      const newObserver = new IntersectionObserver(callback, {
        root: parent,
        threshold: 0.9
      });
      setObserver(newObserver);
      return () => newObserver.disconnect();
    }, [callback, parent]);
    (0, import_element223.useEffect)(() => {
      if (!observer) {
        return;
      }
      if (children.first) {
        observer.observe(children.first);
      }
      if (children.last) {
        observer.observe(children.last);
      }
      return () => {
        if (children.first) {
          observer.unobserve(children.first);
        }
        if (children.last) {
          observer.unobserve(children.last);
        }
      };
    }, [children.first, children.last, observer]);
    return {
      first,
      last
    };
  }

  // packages/components/build-module/tabs/tablist.mjs
  var import_jsx_runtime304 = __toESM(require_jsx_runtime(), 1);
  var DEFAULT_SCROLL_MARGIN = 24;
  function useScrollRectIntoView(parent, rect, {
    margin = DEFAULT_SCROLL_MARGIN
  } = {}) {
    (0, import_element224.useLayoutEffect)(() => {
      if (!parent || !rect) {
        return;
      }
      const {
        scrollLeft: parentScroll
      } = parent;
      const parentWidth = parent.getBoundingClientRect().width;
      const {
        left: childLeft,
        width: childWidth
      } = rect;
      const parentRightEdge = parentScroll + parentWidth;
      const childRightEdge = childLeft + childWidth;
      const rightOverflow = childRightEdge + margin - parentRightEdge;
      const leftOverflow = parentScroll - (childLeft - margin);
      let scrollLeft = null;
      if (leftOverflow > 0) {
        scrollLeft = parentScroll - leftOverflow;
      } else if (rightOverflow > 0) {
        scrollLeft = parentScroll + rightOverflow;
      }
      if (scrollLeft !== null) {
        parent.scroll?.({
          left: scrollLeft
        });
      }
    }, [margin, parent, rect]);
  }
  var TabList3 = (0, import_element224.forwardRef)(function TabList22({
    children,
    ...otherProps
  }, ref) {
    const {
      store
    } = useTabsContext() ?? {};
    const selectedId = useStoreState(store, "selectedId");
    const selectOnMove = useStoreState(store, "selectOnMove");
    const items = useStoreState(store, "items");
    const [parent, setParent] = (0, import_element224.useState)();
    const refs = (0, import_compose84.useMergeRefs)([ref, setParent]);
    const selectedItem = store?.item(selectedId);
    const renderedItems = useStoreState(store, "renderedItems");
    const selectedItemIndex = renderedItems && selectedItem ? renderedItems.indexOf(selectedItem) : -1;
    const selectedRect = useTrackElementOffsetRect(selectedItem?.element, [selectedItemIndex]);
    const overflow = useTrackOverflow(parent, {
      first: items?.at(0)?.element,
      last: items?.at(-1)?.element
    });
    useAnimatedOffsetRect(parent, selectedRect, {
      prefix: "selected",
      dataAttribute: "indicator-animated",
      transitionEndFilter: (event) => event.pseudoElement === "::before",
      roundRect: true
    });
    useScrollRectIntoView(parent, selectedRect);
    if (!store) {
      true ? (0, import_warning13.default)("`Tabs.TabList` must be wrapped in a `Tabs` component.") : void 0;
      return null;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime304.jsx)(StyledTabList, {
      ref: refs,
      store,
      render: (props) => /* @__PURE__ */ (0, import_jsx_runtime304.jsx)("div", {
        ...props,
        // Fallback to -1 to prevent browsers from making the tablist
        // tabbable when it is a scrolling container.
        tabIndex: props.tabIndex ?? -1
      }),
      "data-select-on-move": selectOnMove ? "true" : "false",
      ...otherProps,
      className: clsx_default(overflow.first && "is-overflowing-first", overflow.last && "is-overflowing-last", otherProps.className),
      children
    });
  });

  // packages/components/build-module/tabs/tabpanel.mjs
  var import_element225 = __toESM(require_element(), 1);
  var import_warning14 = __toESM(require_warning(), 1);
  var import_jsx_runtime305 = __toESM(require_jsx_runtime(), 1);
  var TabPanel3 = (0, import_element225.forwardRef)(function TabPanel24({
    children,
    tabId,
    focusable = true,
    ...otherProps
  }, ref) {
    const context = useTabsContext();
    const selectedId = useStoreState(context?.store, "selectedId");
    if (!context) {
      true ? (0, import_warning14.default)("`Tabs.TabPanel` must be wrapped in a `Tabs` component.") : void 0;
      return null;
    }
    const {
      store,
      instanceId
    } = context;
    const instancedTabId = `${instanceId}-${tabId}`;
    return /* @__PURE__ */ (0, import_jsx_runtime305.jsx)(TabPanel23, {
      ref,
      store,
      id: `${instancedTabId}-view`,
      tabId: instancedTabId,
      focusable,
      ...otherProps,
      children: selectedId === instancedTabId && children
    });
  });

  // packages/components/build-module/tabs/index.mjs
  var import_jsx_runtime306 = __toESM(require_jsx_runtime(), 1);
  function externalToInternalTabId(externalId, instanceId) {
    return externalId && `${instanceId}-${externalId}`;
  }
  function internalToExternalTabId(internalId, instanceId) {
    return typeof internalId === "string" ? internalId.replace(`${instanceId}-`, "") : internalId;
  }
  var Tabs = Object.assign(function Tabs2({
    selectOnMove = true,
    defaultTabId,
    orientation = "horizontal",
    onSelect,
    children,
    selectedTabId,
    activeTabId,
    defaultActiveTabId,
    onActiveTabIdChange
  }) {
    const instanceId = (0, import_compose85.useInstanceId)(Tabs2, "tabs");
    const store = useTabStore({
      selectOnMove,
      orientation,
      defaultSelectedId: externalToInternalTabId(defaultTabId, instanceId),
      setSelectedId: (newSelectedId) => {
        onSelect?.(internalToExternalTabId(newSelectedId, instanceId));
      },
      selectedId: externalToInternalTabId(selectedTabId, instanceId),
      defaultActiveId: externalToInternalTabId(defaultActiveTabId, instanceId),
      setActiveId: (newActiveId) => {
        onActiveTabIdChange?.(internalToExternalTabId(newActiveId, instanceId));
      },
      activeId: externalToInternalTabId(activeTabId, instanceId),
      rtl: (0, import_i18n73.isRTL)()
    });
    const contextValue = (0, import_element226.useMemo)(() => ({
      store,
      instanceId
    }), [store, instanceId]);
    return /* @__PURE__ */ (0, import_jsx_runtime306.jsx)(TabsContext.Provider, {
      value: contextValue,
      children
    });
  }, {
    /**
     * Renders a single tab.
     *
     * The currently active tab receives default styling that can be
     * overridden with CSS targeting `[aria-selected="true"]`.
     */
    Tab: Object.assign(Tab3, {
      displayName: "Tabs.Tab"
    }),
    /**
     * A wrapper component for the `Tab` components.
     *
     * It is responsible for rendering the list of tabs.
     */
    TabList: Object.assign(TabList3, {
      displayName: "Tabs.TabList"
    }),
    /**
     * Renders the content to display for a single tab once that tab is selected.
     */
    TabPanel: Object.assign(TabPanel3, {
      displayName: "Tabs.TabPanel"
    }),
    Context: Object.assign(TabsContext, {
      displayName: "Tabs.Context"
    })
  });

  // packages/components/build-module/badge/index.mjs
  var import_jsx_runtime307 = __toESM(require_jsx_runtime(), 1);
  function contextBasedIcon(intent = "default") {
    switch (intent) {
      case "info":
        return info_default;
      case "success":
        return published_default;
      case "warning":
        return caution_default;
      case "error":
        return error_default;
      default:
        return null;
    }
  }
  function Badge({
    className: className2,
    intent = "default",
    children,
    ...props
  }) {
    const icon = contextBasedIcon(intent);
    const hasIcon = !!icon;
    return /* @__PURE__ */ (0, import_jsx_runtime307.jsx)("span", {
      className: clsx_default("components-badge", className2, {
        [`is-${intent}`]: intent,
        "has-icon": hasIcon
      }),
      ...props,
      children: /* @__PURE__ */ (0, import_jsx_runtime307.jsxs)("span", {
        className: "components-badge__flex-wrapper",
        children: [hasIcon && /* @__PURE__ */ (0, import_jsx_runtime307.jsx)(icon_default3, {
          icon,
          size: 16,
          fill: "currentColor",
          className: "components-badge__icon"
        }), /* @__PURE__ */ (0, import_jsx_runtime307.jsx)("span", {
          className: "components-badge__content",
          children
        })]
      })
    });
  }
  var badge_default = Badge;

  // node_modules/react-day-picker/dist/esm/DayPicker.js
  var import_react152 = __toESM(require_react(), 1);

  // node_modules/@date-fns/tz/tzOffset/index.js
  var offsetFormatCache = {};
  var offsetCache = {};
  function tzOffset(timeZone, date) {
    try {
      const format2 = offsetFormatCache[timeZone] ||= new Intl.DateTimeFormat("en-GB", {
        timeZone,
        hour: "numeric",
        timeZoneName: "longOffset"
      }).format;
      const offsetStr = format2(date).split("GMT")[1] || "";
      if (offsetStr in offsetCache) return offsetCache[offsetStr];
      return calcOffset(offsetStr, offsetStr.split(":"));
    } catch {
      if (timeZone in offsetCache) return offsetCache[timeZone];
      const captures = timeZone?.match(offsetRe);
      if (captures) return calcOffset(timeZone, captures.slice(1));
      return NaN;
    }
  }
  var offsetRe = /([+-]\d\d):?(\d\d)?/;
  function calcOffset(cacheStr, values) {
    const hours = +values[0];
    const minutes = +(values[1] || 0);
    return offsetCache[cacheStr] = hours > 0 ? hours * 60 + minutes : hours * 60 - minutes;
  }

  // node_modules/@date-fns/tz/date/mini.js
  var TZDateMini = class _TZDateMini extends Date {
    //#region static
    constructor(...args) {
      super();
      if (args.length > 1 && typeof args[args.length - 1] === "string") {
        this.timeZone = args.pop();
      }
      this.internal = /* @__PURE__ */ new Date();
      if (isNaN(tzOffset(this.timeZone, this))) {
        this.setTime(NaN);
      } else {
        if (!args.length) {
          this.setTime(Date.now());
        } else if (typeof args[0] === "number" && (args.length === 1 || args.length === 2 && typeof args[1] !== "number")) {
          this.setTime(args[0]);
        } else if (typeof args[0] === "string") {
          this.setTime(+new Date(args[0]));
        } else if (args[0] instanceof Date) {
          this.setTime(+args[0]);
        } else {
          this.setTime(+new Date(...args));
          adjustToSystemTZ(this, NaN);
          syncToInternal(this);
        }
      }
    }
    static tz(tz, ...args) {
      return args.length ? new _TZDateMini(...args, tz) : new _TZDateMini(Date.now(), tz);
    }
    //#endregion
    //#region time zone
    withTimeZone(timeZone) {
      return new _TZDateMini(+this, timeZone);
    }
    getTimezoneOffset() {
      return -tzOffset(this.timeZone, this);
    }
    //#endregion
    //#region time
    setTime(time2) {
      Date.prototype.setTime.apply(this, arguments);
      syncToInternal(this);
      return +this;
    }
    //#endregion
    //#region date-fns integration
    [/* @__PURE__ */ Symbol.for("constructDateFrom")](date) {
      return new _TZDateMini(+new Date(date), this.timeZone);
    }
    //#endregion
  };
  var re3 = /^(get|set)(?!UTC)/;
  Object.getOwnPropertyNames(Date.prototype).forEach((method) => {
    if (!re3.test(method)) return;
    const utcMethod = method.replace(re3, "$1UTC");
    if (!TZDateMini.prototype[utcMethod]) return;
    if (method.startsWith("get")) {
      TZDateMini.prototype[method] = function() {
        return this.internal[utcMethod]();
      };
    } else {
      TZDateMini.prototype[method] = function() {
        Date.prototype[utcMethod].apply(this.internal, arguments);
        syncFromInternal(this);
        return +this;
      };
      TZDateMini.prototype[utcMethod] = function() {
        Date.prototype[utcMethod].apply(this, arguments);
        syncToInternal(this);
        return +this;
      };
    }
  });
  function syncToInternal(date) {
    date.internal.setTime(+date);
    date.internal.setUTCMinutes(date.internal.getUTCMinutes() - date.getTimezoneOffset());
  }
  function syncFromInternal(date) {
    Date.prototype.setFullYear.call(date, date.internal.getUTCFullYear(), date.internal.getUTCMonth(), date.internal.getUTCDate());
    Date.prototype.setHours.call(date, date.internal.getUTCHours(), date.internal.getUTCMinutes(), date.internal.getUTCSeconds(), date.internal.getUTCMilliseconds());
    adjustToSystemTZ(date);
  }
  function adjustToSystemTZ(date) {
    const offset4 = tzOffset(date.timeZone, date);
    const prevHour = /* @__PURE__ */ new Date(+date);
    prevHour.setUTCHours(prevHour.getUTCHours() - 1);
    const systemOffset = -(/* @__PURE__ */ new Date(+date)).getTimezoneOffset();
    const prevHourSystemOffset = -(/* @__PURE__ */ new Date(+prevHour)).getTimezoneOffset();
    const systemDSTChange = systemOffset - prevHourSystemOffset;
    const dstShift = Date.prototype.getHours.apply(date) !== date.internal.getUTCHours();
    if (systemDSTChange && dstShift) date.internal.setUTCMinutes(date.internal.getUTCMinutes() + systemDSTChange);
    const offsetDiff = systemOffset - offset4;
    if (offsetDiff) Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetDiff);
    const postOffset = tzOffset(date.timeZone, date);
    const postSystemOffset = -(/* @__PURE__ */ new Date(+date)).getTimezoneOffset();
    const postOffsetDiff = postSystemOffset - postOffset;
    const offsetChanged = postOffset !== offset4;
    const postDiff = postOffsetDiff - offsetDiff;
    if (offsetChanged && postDiff) {
      Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + postDiff);
      const newOffset = tzOffset(date.timeZone, date);
      const offsetChange = postOffset - newOffset;
      if (offsetChange) {
        date.internal.setUTCMinutes(date.internal.getUTCMinutes() + offsetChange);
        Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetChange);
      }
    }
  }

  // node_modules/@date-fns/tz/date/index.js
  var TZDate = class _TZDate extends TZDateMini {
    //#region static
    static tz(tz, ...args) {
      return args.length ? new _TZDate(...args, tz) : new _TZDate(Date.now(), tz);
    }
    //#endregion
    //#region representation
    toISOString() {
      const [sign, hours, minutes] = this.tzComponents();
      const tz = `${sign}${hours}:${minutes}`;
      return this.internal.toISOString().slice(0, -1) + tz;
    }
    toString() {
      return `${this.toDateString()} ${this.toTimeString()}`;
    }
    toDateString() {
      const [day, date, month, year] = this.internal.toUTCString().split(" ");
      return `${day?.slice(0, -1)} ${month} ${date} ${year}`;
    }
    toTimeString() {
      const time2 = this.internal.toUTCString().split(" ")[4];
      const [sign, hours, minutes] = this.tzComponents();
      return `${time2} GMT${sign}${hours}${minutes} (${tzName(this.timeZone, this)})`;
    }
    toLocaleString(locales, options2) {
      return Date.prototype.toLocaleString.call(this, locales, {
        ...options2,
        timeZone: options2?.timeZone || this.timeZone
      });
    }
    toLocaleDateString(locales, options2) {
      return Date.prototype.toLocaleDateString.call(this, locales, {
        ...options2,
        timeZone: options2?.timeZone || this.timeZone
      });
    }
    toLocaleTimeString(locales, options2) {
      return Date.prototype.toLocaleTimeString.call(this, locales, {
        ...options2,
        timeZone: options2?.timeZone || this.timeZone
      });
    }
    //#endregion
    //#region private
    tzComponents() {
      const offset4 = this.getTimezoneOffset();
      const sign = offset4 > 0 ? "-" : "+";
      const hours = String(Math.floor(Math.abs(offset4) / 60)).padStart(2, "0");
      const minutes = String(Math.abs(offset4) % 60).padStart(2, "0");
      return [sign, hours, minutes];
    }
    //#endregion
    withTimeZone(timeZone) {
      return new _TZDate(+this, timeZone);
    }
    //#region date-fns integration
    [/* @__PURE__ */ Symbol.for("constructDateFrom")](date) {
      return new _TZDate(+new Date(date), this.timeZone);
    }
    //#endregion
  };
  function tzName(tz, date) {
    return new Intl.DateTimeFormat("en-GB", {
      timeZone: tz,
      timeZoneName: "long"
    }).format(date).slice(12);
  }

  // node_modules/react-day-picker/dist/esm/UI.js
  var UI2;
  (function(UI3) {
    UI3["Root"] = "root";
    UI3["Chevron"] = "chevron";
    UI3["Day"] = "day";
    UI3["DayButton"] = "day_button";
    UI3["CaptionLabel"] = "caption_label";
    UI3["Dropdowns"] = "dropdowns";
    UI3["Dropdown"] = "dropdown";
    UI3["DropdownRoot"] = "dropdown_root";
    UI3["Footer"] = "footer";
    UI3["MonthGrid"] = "month_grid";
    UI3["MonthCaption"] = "month_caption";
    UI3["MonthsDropdown"] = "months_dropdown";
    UI3["Month"] = "month";
    UI3["Months"] = "months";
    UI3["Nav"] = "nav";
    UI3["NextMonthButton"] = "button_next";
    UI3["PreviousMonthButton"] = "button_previous";
    UI3["Week"] = "week";
    UI3["Weeks"] = "weeks";
    UI3["Weekday"] = "weekday";
    UI3["Weekdays"] = "weekdays";
    UI3["WeekNumber"] = "week_number";
    UI3["WeekNumberHeader"] = "week_number_header";
    UI3["YearsDropdown"] = "years_dropdown";
  })(UI2 || (UI2 = {}));
  var DayFlag;
  (function(DayFlag2) {
    DayFlag2["disabled"] = "disabled";
    DayFlag2["hidden"] = "hidden";
    DayFlag2["outside"] = "outside";
    DayFlag2["focused"] = "focused";
    DayFlag2["today"] = "today";
  })(DayFlag || (DayFlag = {}));
  var SelectionState;
  (function(SelectionState2) {
    SelectionState2["range_end"] = "range_end";
    SelectionState2["range_middle"] = "range_middle";
    SelectionState2["range_start"] = "range_start";
    SelectionState2["selected"] = "selected";
  })(SelectionState || (SelectionState = {}));
  var Animation;
  (function(Animation2) {
    Animation2["weeks_before_enter"] = "weeks_before_enter";
    Animation2["weeks_before_exit"] = "weeks_before_exit";
    Animation2["weeks_after_enter"] = "weeks_after_enter";
    Animation2["weeks_after_exit"] = "weeks_after_exit";
    Animation2["caption_after_enter"] = "caption_after_enter";
    Animation2["caption_after_exit"] = "caption_after_exit";
    Animation2["caption_before_enter"] = "caption_before_enter";
    Animation2["caption_before_exit"] = "caption_before_exit";
  })(Animation || (Animation = {}));

  // node_modules/react-day-picker/dist/esm/helpers/getBroadcastWeeksInMonth.js
  var FIVE_WEEKS = 5;
  var FOUR_WEEKS = 4;
  function getBroadcastWeeksInMonth(month, dateLib) {
    const firstDayOfMonth = dateLib.startOfMonth(month);
    const firstDayOfWeek = firstDayOfMonth.getDay() > 0 ? firstDayOfMonth.getDay() : 7;
    const broadcastStartDate = dateLib.addDays(month, -firstDayOfWeek + 1);
    const lastDateOfLastWeek = dateLib.addDays(broadcastStartDate, FIVE_WEEKS * 7 - 1);
    const numberOfWeeks = dateLib.getMonth(month) === dateLib.getMonth(lastDateOfLastWeek) ? FIVE_WEEKS : FOUR_WEEKS;
    return numberOfWeeks;
  }

  // node_modules/react-day-picker/dist/esm/helpers/startOfBroadcastWeek.js
  function startOfBroadcastWeek(date, dateLib) {
    const firstOfMonth = dateLib.startOfMonth(date);
    const dayOfWeek = firstOfMonth.getDay();
    if (dayOfWeek === 1) {
      return firstOfMonth;
    } else if (dayOfWeek === 0) {
      return dateLib.addDays(firstOfMonth, -1 * 6);
    } else {
      return dateLib.addDays(firstOfMonth, -1 * (dayOfWeek - 1));
    }
  }

  // node_modules/react-day-picker/dist/esm/helpers/endOfBroadcastWeek.js
  function endOfBroadcastWeek(date, dateLib) {
    const startDate = startOfBroadcastWeek(date, dateLib);
    const numberOfWeeks = getBroadcastWeeksInMonth(date, dateLib);
    const endDate = dateLib.addDays(startDate, numberOfWeeks * 7 - 1);
    return endDate;
  }

  // node_modules/react-day-picker/dist/esm/classes/DateLib.js
  var DateLib = class {
    /**
     * Creates an instance of `DateLib`.
     *
     * @param options Configuration options for the date library.
     * @param overrides Custom overrides for the date library functions.
     */
    constructor(options2, overrides) {
      this.Date = Date;
      this.today = () => {
        if (this.overrides?.today) {
          return this.overrides.today();
        }
        if (this.options.timeZone) {
          return TZDate.tz(this.options.timeZone);
        }
        return new this.Date();
      };
      this.newDate = (year, monthIndex, date) => {
        if (this.overrides?.newDate) {
          return this.overrides.newDate(year, monthIndex, date);
        }
        if (this.options.timeZone) {
          return new TZDate(year, monthIndex, date, this.options.timeZone);
        }
        return new Date(year, monthIndex, date);
      };
      this.addDays = (date, amount) => {
        return this.overrides?.addDays ? this.overrides.addDays(date, amount) : addDays(date, amount);
      };
      this.addMonths = (date, amount) => {
        return this.overrides?.addMonths ? this.overrides.addMonths(date, amount) : addMonths(date, amount);
      };
      this.addWeeks = (date, amount) => {
        return this.overrides?.addWeeks ? this.overrides.addWeeks(date, amount) : addWeeks(date, amount);
      };
      this.addYears = (date, amount) => {
        return this.overrides?.addYears ? this.overrides.addYears(date, amount) : addYears(date, amount);
      };
      this.differenceInCalendarDays = (dateLeft, dateRight) => {
        return this.overrides?.differenceInCalendarDays ? this.overrides.differenceInCalendarDays(dateLeft, dateRight) : differenceInCalendarDays(dateLeft, dateRight);
      };
      this.differenceInCalendarMonths = (dateLeft, dateRight) => {
        return this.overrides?.differenceInCalendarMonths ? this.overrides.differenceInCalendarMonths(dateLeft, dateRight) : differenceInCalendarMonths(dateLeft, dateRight);
      };
      this.eachMonthOfInterval = (interval) => {
        return this.overrides?.eachMonthOfInterval ? this.overrides.eachMonthOfInterval(interval) : eachMonthOfInterval(interval);
      };
      this.endOfBroadcastWeek = (date) => {
        return this.overrides?.endOfBroadcastWeek ? this.overrides.endOfBroadcastWeek(date) : endOfBroadcastWeek(date, this);
      };
      this.endOfISOWeek = (date) => {
        return this.overrides?.endOfISOWeek ? this.overrides.endOfISOWeek(date) : endOfISOWeek(date);
      };
      this.endOfMonth = (date) => {
        return this.overrides?.endOfMonth ? this.overrides.endOfMonth(date) : endOfMonth(date);
      };
      this.endOfWeek = (date, options3) => {
        return this.overrides?.endOfWeek ? this.overrides.endOfWeek(date, options3) : endOfWeek(date, this.options);
      };
      this.endOfYear = (date) => {
        return this.overrides?.endOfYear ? this.overrides.endOfYear(date) : endOfYear(date);
      };
      this.format = (date, formatStr, options3) => {
        const formatted = this.overrides?.format ? this.overrides.format(date, formatStr, this.options) : format(date, formatStr, this.options);
        if (this.options.numerals && this.options.numerals !== "latn") {
          return this.replaceDigits(formatted);
        }
        return formatted;
      };
      this.getISOWeek = (date) => {
        return this.overrides?.getISOWeek ? this.overrides.getISOWeek(date) : getISOWeek(date);
      };
      this.getMonth = (date, options3) => {
        return this.overrides?.getMonth ? this.overrides.getMonth(date, this.options) : getMonth(date, this.options);
      };
      this.getYear = (date, options3) => {
        return this.overrides?.getYear ? this.overrides.getYear(date, this.options) : getYear(date, this.options);
      };
      this.getWeek = (date, options3) => {
        return this.overrides?.getWeek ? this.overrides.getWeek(date, this.options) : getWeek(date, this.options);
      };
      this.isAfter = (date, dateToCompare) => {
        return this.overrides?.isAfter ? this.overrides.isAfter(date, dateToCompare) : isAfter(date, dateToCompare);
      };
      this.isBefore = (date, dateToCompare) => {
        return this.overrides?.isBefore ? this.overrides.isBefore(date, dateToCompare) : isBefore(date, dateToCompare);
      };
      this.isDate = (value) => {
        return this.overrides?.isDate ? this.overrides.isDate(value) : isDate(value);
      };
      this.isSameDay = (dateLeft, dateRight) => {
        return this.overrides?.isSameDay ? this.overrides.isSameDay(dateLeft, dateRight) : isSameDay(dateLeft, dateRight);
      };
      this.isSameMonth = (dateLeft, dateRight) => {
        return this.overrides?.isSameMonth ? this.overrides.isSameMonth(dateLeft, dateRight) : isSameMonth(dateLeft, dateRight);
      };
      this.isSameYear = (dateLeft, dateRight) => {
        return this.overrides?.isSameYear ? this.overrides.isSameYear(dateLeft, dateRight) : isSameYear(dateLeft, dateRight);
      };
      this.max = (dates) => {
        return this.overrides?.max ? this.overrides.max(dates) : max2(dates);
      };
      this.min = (dates) => {
        return this.overrides?.min ? this.overrides.min(dates) : min2(dates);
      };
      this.setMonth = (date, month) => {
        return this.overrides?.setMonth ? this.overrides.setMonth(date, month) : setMonth(date, month);
      };
      this.setYear = (date, year) => {
        return this.overrides?.setYear ? this.overrides.setYear(date, year) : setYear(date, year);
      };
      this.startOfBroadcastWeek = (date, dateLib) => {
        return this.overrides?.startOfBroadcastWeek ? this.overrides.startOfBroadcastWeek(date, this) : startOfBroadcastWeek(date, this);
      };
      this.startOfDay = (date) => {
        return this.overrides?.startOfDay ? this.overrides.startOfDay(date) : startOfDay(date);
      };
      this.startOfISOWeek = (date) => {
        return this.overrides?.startOfISOWeek ? this.overrides.startOfISOWeek(date) : startOfISOWeek(date);
      };
      this.startOfMonth = (date) => {
        return this.overrides?.startOfMonth ? this.overrides.startOfMonth(date) : startOfMonth(date);
      };
      this.startOfWeek = (date, options3) => {
        return this.overrides?.startOfWeek ? this.overrides.startOfWeek(date, this.options) : startOfWeek(date, this.options);
      };
      this.startOfYear = (date) => {
        return this.overrides?.startOfYear ? this.overrides.startOfYear(date) : startOfYear(date);
      };
      this.options = { locale: enUS, ...options2 };
      this.overrides = overrides;
    }
    /**
     * Generates a mapping of Arabic digits (0-9) to the target numbering system
     * digits.
     *
     * @since 9.5.0
     * @returns A record mapping Arabic digits to the target numerals.
     */
    getDigitMap() {
      const { numerals = "latn" } = this.options;
      const formatter = new Intl.NumberFormat("en-US", {
        numberingSystem: numerals
      });
      const digitMap = {};
      for (let i3 = 0; i3 < 10; i3++) {
        digitMap[i3.toString()] = formatter.format(i3);
      }
      return digitMap;
    }
    /**
     * Replaces Arabic digits in a string with the target numbering system digits.
     *
     * @since 9.5.0
     * @param input The string containing Arabic digits.
     * @returns The string with digits replaced.
     */
    replaceDigits(input) {
      const digitMap = this.getDigitMap();
      return input.replace(/\d/g, (digit) => digitMap[digit] || digit);
    }
    /**
     * Formats a number using the configured numbering system.
     *
     * @since 9.5.0
     * @param value The number to format.
     * @returns The formatted number as a string.
     */
    formatNumber(value) {
      return this.replaceDigits(value.toString());
    }
  };
  var defaultDateLib = new DateLib();

  // node_modules/react-day-picker/dist/esm/classes/CalendarDay.js
  var CalendarDay = class {
    constructor(date, displayMonth, dateLib = defaultDateLib) {
      this.date = date;
      this.displayMonth = displayMonth;
      this.outside = Boolean(displayMonth && !dateLib.isSameMonth(date, displayMonth));
      this.dateLib = dateLib;
    }
    /**
     * Checks if this day is equal to another `CalendarDay`, considering both the
     * date and the displayed month.
     *
     * @param day The `CalendarDay` to compare with.
     * @returns `true` if the days are equal, otherwise `false`.
     */
    isEqualTo(day) {
      return this.dateLib.isSameDay(day.date, this.date) && this.dateLib.isSameMonth(day.displayMonth, this.displayMonth);
    }
  };

  // node_modules/react-day-picker/dist/esm/classes/CalendarMonth.js
  var CalendarMonth = class {
    constructor(month, weeks) {
      this.date = month;
      this.weeks = weeks;
    }
  };

  // node_modules/react-day-picker/dist/esm/classes/CalendarWeek.js
  var CalendarWeek = class {
    constructor(weekNumber, days) {
      this.days = days;
      this.weekNumber = weekNumber;
    }
  };

  // node_modules/react-day-picker/dist/esm/utils/rangeIncludesDate.js
  function rangeIncludesDate(range, date, excludeEnds = false, dateLib = defaultDateLib) {
    let { from: from2, to } = range;
    const { differenceInCalendarDays: differenceInCalendarDays2, isSameDay: isSameDay2 } = dateLib;
    if (from2 && to) {
      const isRangeInverted = differenceInCalendarDays2(to, from2) < 0;
      if (isRangeInverted) {
        [from2, to] = [to, from2];
      }
      const isInRange = differenceInCalendarDays2(date, from2) >= (excludeEnds ? 1 : 0) && differenceInCalendarDays2(to, date) >= (excludeEnds ? 1 : 0);
      return isInRange;
    }
    if (!excludeEnds && to) {
      return isSameDay2(to, date);
    }
    if (!excludeEnds && from2) {
      return isSameDay2(from2, date);
    }
    return false;
  }

  // node_modules/react-day-picker/dist/esm/utils/typeguards.js
  function isDateInterval(matcher) {
    return Boolean(matcher && typeof matcher === "object" && "before" in matcher && "after" in matcher);
  }
  function isDateRange(value) {
    return Boolean(value && typeof value === "object" && "from" in value);
  }
  function isDateAfterType(value) {
    return Boolean(value && typeof value === "object" && "after" in value);
  }
  function isDateBeforeType(value) {
    return Boolean(value && typeof value === "object" && "before" in value);
  }
  function isDayOfWeekType(value) {
    return Boolean(value && typeof value === "object" && "dayOfWeek" in value);
  }
  function isDatesArray(value, dateLib) {
    return Array.isArray(value) && value.every(dateLib.isDate);
  }

  // node_modules/react-day-picker/dist/esm/utils/dateMatchModifiers.js
  function dateMatchModifiers(date, matchers, dateLib = defaultDateLib) {
    const matchersArr = !Array.isArray(matchers) ? [matchers] : matchers;
    const { isSameDay: isSameDay2, differenceInCalendarDays: differenceInCalendarDays2, isAfter: isAfter2 } = dateLib;
    return matchersArr.some((matcher) => {
      if (typeof matcher === "boolean") {
        return matcher;
      }
      if (dateLib.isDate(matcher)) {
        return isSameDay2(date, matcher);
      }
      if (isDatesArray(matcher, dateLib)) {
        return matcher.includes(date);
      }
      if (isDateRange(matcher)) {
        return rangeIncludesDate(matcher, date, false, dateLib);
      }
      if (isDayOfWeekType(matcher)) {
        if (!Array.isArray(matcher.dayOfWeek)) {
          return matcher.dayOfWeek === date.getDay();
        }
        return matcher.dayOfWeek.includes(date.getDay());
      }
      if (isDateInterval(matcher)) {
        const diffBefore = differenceInCalendarDays2(matcher.before, date);
        const diffAfter = differenceInCalendarDays2(matcher.after, date);
        const isDayBefore = diffBefore > 0;
        const isDayAfter = diffAfter < 0;
        const isClosedInterval = isAfter2(matcher.before, matcher.after);
        if (isClosedInterval) {
          return isDayAfter && isDayBefore;
        } else {
          return isDayBefore || isDayAfter;
        }
      }
      if (isDateAfterType(matcher)) {
        return differenceInCalendarDays2(date, matcher.after) > 0;
      }
      if (isDateBeforeType(matcher)) {
        return differenceInCalendarDays2(matcher.before, date) > 0;
      }
      if (typeof matcher === "function") {
        return matcher(date);
      }
      return false;
    });
  }

  // node_modules/react-day-picker/dist/esm/helpers/createGetModifiers.js
  function createGetModifiers(days, props, dateLib) {
    const { disabled, hidden, modifiers, showOutsideDays, broadcastCalendar, today } = props;
    const { isSameDay: isSameDay2, isSameMonth: isSameMonth2, startOfMonth: startOfMonth2, isBefore: isBefore2, endOfMonth: endOfMonth2, isAfter: isAfter2 } = dateLib;
    const startMonth = props.startMonth && startOfMonth2(props.startMonth);
    const endMonth = props.endMonth && endOfMonth2(props.endMonth);
    const internalModifiersMap = {
      [DayFlag.focused]: [],
      [DayFlag.outside]: [],
      [DayFlag.disabled]: [],
      [DayFlag.hidden]: [],
      [DayFlag.today]: []
    };
    const customModifiersMap = {};
    for (const day of days) {
      const { date, displayMonth } = day;
      const isOutside = Boolean(displayMonth && !isSameMonth2(date, displayMonth));
      const isBeforeStartMonth = Boolean(startMonth && isBefore2(date, startMonth));
      const isAfterEndMonth = Boolean(endMonth && isAfter2(date, endMonth));
      const isDisabled = Boolean(disabled && dateMatchModifiers(date, disabled, dateLib));
      const isHidden2 = Boolean(hidden && dateMatchModifiers(date, hidden, dateLib)) || isBeforeStartMonth || isAfterEndMonth || // Broadcast calendar will show outside days as default
      !broadcastCalendar && !showOutsideDays && isOutside || broadcastCalendar && showOutsideDays === false && isOutside;
      const isToday = isSameDay2(date, today ?? dateLib.today());
      if (isOutside)
        internalModifiersMap.outside.push(day);
      if (isDisabled)
        internalModifiersMap.disabled.push(day);
      if (isHidden2)
        internalModifiersMap.hidden.push(day);
      if (isToday)
        internalModifiersMap.today.push(day);
      if (modifiers) {
        Object.keys(modifiers).forEach((name) => {
          const modifierValue = modifiers?.[name];
          const isMatch = modifierValue ? dateMatchModifiers(date, modifierValue, dateLib) : false;
          if (!isMatch)
            return;
          if (customModifiersMap[name]) {
            customModifiersMap[name].push(day);
          } else {
            customModifiersMap[name] = [day];
          }
        });
      }
    }
    return (day) => {
      const dayFlags = {
        [DayFlag.focused]: false,
        [DayFlag.disabled]: false,
        [DayFlag.hidden]: false,
        [DayFlag.outside]: false,
        [DayFlag.today]: false
      };
      const customModifiers = {};
      for (const name in internalModifiersMap) {
        const days2 = internalModifiersMap[name];
        dayFlags[name] = days2.some((d3) => d3 === day);
      }
      for (const name in customModifiersMap) {
        customModifiers[name] = customModifiersMap[name].some((d3) => d3 === day);
      }
      return {
        ...dayFlags,
        // custom modifiers should override all the previous ones
        ...customModifiers
      };
    };
  }

  // node_modules/react-day-picker/dist/esm/helpers/getClassNamesForModifiers.js
  function getClassNamesForModifiers(modifiers, classNames, modifiersClassNames = {}) {
    const modifierClassNames = Object.entries(modifiers).filter(([, active]) => active === true).reduce((previousValue, [key]) => {
      if (modifiersClassNames[key]) {
        previousValue.push(modifiersClassNames[key]);
      } else if (classNames[DayFlag[key]]) {
        previousValue.push(classNames[DayFlag[key]]);
      } else if (classNames[SelectionState[key]]) {
        previousValue.push(classNames[SelectionState[key]]);
      }
      return previousValue;
    }, [classNames[UI2.Day]]);
    return modifierClassNames;
  }

  // node_modules/react-day-picker/dist/esm/components/custom-components.js
  var custom_components_exports = {};
  __export(custom_components_exports, {
    Button: () => Button4,
    CaptionLabel: () => CaptionLabel,
    Chevron: () => Chevron,
    Day: () => Day3,
    DayButton: () => DayButton2,
    Dropdown: () => Dropdown2,
    DropdownNav: () => DropdownNav,
    Footer: () => Footer2,
    Month: () => Month,
    MonthCaption: () => MonthCaption,
    MonthGrid: () => MonthGrid,
    Months: () => Months,
    MonthsDropdown: () => MonthsDropdown,
    Nav: () => Nav,
    NextMonthButton: () => NextMonthButton,
    Option: () => Option3,
    PreviousMonthButton: () => PreviousMonthButton,
    Root: () => Root5,
    Select: () => Select4,
    Week: () => Week,
    WeekNumber: () => WeekNumber,
    WeekNumberHeader: () => WeekNumberHeader,
    Weekday: () => Weekday,
    Weekdays: () => Weekdays,
    Weeks: () => Weeks,
    YearsDropdown: () => YearsDropdown
  });

  // node_modules/react-day-picker/dist/esm/components/Button.js
  var import_react121 = __toESM(require_react(), 1);
  function Button4(props) {
    return import_react121.default.createElement("button", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/CaptionLabel.js
  var import_react122 = __toESM(require_react(), 1);
  function CaptionLabel(props) {
    return import_react122.default.createElement("span", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Chevron.js
  var import_react123 = __toESM(require_react(), 1);
  function Chevron(props) {
    const { size: size4 = 24, orientation = "left", className: className2 } = props;
    return import_react123.default.createElement(
      "svg",
      { className: className2, width: size4, height: size4, viewBox: "0 0 24 24" },
      orientation === "up" && import_react123.default.createElement("polygon", { points: "6.77 17 12.5 11.43 18.24 17 20 15.28 12.5 8 5 15.28" }),
      orientation === "down" && import_react123.default.createElement("polygon", { points: "6.77 8 12.5 13.57 18.24 8 20 9.72 12.5 17 5 9.72" }),
      orientation === "left" && import_react123.default.createElement("polygon", { points: "16 18.112 9.81111111 12 16 5.87733333 14.0888889 4 6 12 14.0888889 20" }),
      orientation === "right" && import_react123.default.createElement("polygon", { points: "8 18.112 14.18888889 12 8 5.87733333 9.91111111 4 18 12 9.91111111 20" })
    );
  }

  // node_modules/react-day-picker/dist/esm/components/Day.js
  var import_react124 = __toESM(require_react(), 1);
  function Day3(props) {
    const { day, modifiers, ...tdProps } = props;
    return import_react124.default.createElement("td", { ...tdProps });
  }

  // node_modules/react-day-picker/dist/esm/components/DayButton.js
  var import_react125 = __toESM(require_react(), 1);
  function DayButton2(props) {
    const { day, modifiers, ...buttonProps } = props;
    const ref = import_react125.default.useRef(null);
    import_react125.default.useEffect(() => {
      if (modifiers.focused)
        ref.current?.focus();
    }, [modifiers.focused]);
    return import_react125.default.createElement("button", { ref, ...buttonProps });
  }

  // node_modules/react-day-picker/dist/esm/components/Dropdown.js
  var import_react126 = __toESM(require_react(), 1);
  function Dropdown2(props) {
    const { options: options2, className: className2, components, classNames, ...selectProps } = props;
    const cssClassSelect = [classNames[UI2.Dropdown], className2].join(" ");
    const selectedOption = options2?.find(({ value }) => value === selectProps.value);
    return import_react126.default.createElement(
      "span",
      { "data-disabled": selectProps.disabled, className: classNames[UI2.DropdownRoot] },
      import_react126.default.createElement(components.Select, { className: cssClassSelect, ...selectProps }, options2?.map(({ value, label, disabled }) => import_react126.default.createElement(components.Option, { key: value, value, disabled }, label))),
      import_react126.default.createElement(
        "span",
        { className: classNames[UI2.CaptionLabel], "aria-hidden": true },
        selectedOption?.label,
        import_react126.default.createElement(components.Chevron, { orientation: "down", size: 18, className: classNames[UI2.Chevron] })
      )
    );
  }

  // node_modules/react-day-picker/dist/esm/components/DropdownNav.js
  var import_react127 = __toESM(require_react(), 1);
  function DropdownNav(props) {
    return import_react127.default.createElement("div", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Footer.js
  var import_react128 = __toESM(require_react(), 1);
  function Footer2(props) {
    return import_react128.default.createElement("div", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Month.js
  var import_react129 = __toESM(require_react(), 1);
  function Month(props) {
    const { calendarMonth, displayIndex, ...divProps } = props;
    return import_react129.default.createElement("div", { ...divProps }, props.children);
  }

  // node_modules/react-day-picker/dist/esm/components/MonthCaption.js
  var import_react130 = __toESM(require_react(), 1);
  function MonthCaption(props) {
    const { calendarMonth, displayIndex, ...divProps } = props;
    return import_react130.default.createElement("div", { ...divProps });
  }

  // node_modules/react-day-picker/dist/esm/components/MonthGrid.js
  var import_react131 = __toESM(require_react(), 1);
  function MonthGrid(props) {
    return import_react131.default.createElement("table", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Months.js
  var import_react132 = __toESM(require_react(), 1);
  function Months(props) {
    return import_react132.default.createElement("div", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/MonthsDropdown.js
  var import_react134 = __toESM(require_react(), 1);

  // node_modules/react-day-picker/dist/esm/useDayPicker.js
  var import_react133 = __toESM(require_react(), 1);
  var dayPickerContext = (0, import_react133.createContext)(void 0);
  function useDayPicker() {
    const context = (0, import_react133.useContext)(dayPickerContext);
    if (context === void 0) {
      throw new Error("useDayPicker() must be used within a custom component.");
    }
    return context;
  }

  // node_modules/react-day-picker/dist/esm/components/MonthsDropdown.js
  function MonthsDropdown(props) {
    const { components } = useDayPicker();
    return import_react134.default.createElement(components.Dropdown, { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Nav.js
  var import_react135 = __toESM(require_react(), 1);
  function Nav(props) {
    const { onPreviousClick, onNextClick, previousMonth, nextMonth, ...navProps } = props;
    const { components, classNames, labels: { labelPrevious: labelPrevious2, labelNext: labelNext2 } } = useDayPicker();
    const handleNextClick = (0, import_react135.useCallback)((e3) => {
      if (nextMonth) {
        onNextClick?.(e3);
      }
    }, [nextMonth, onNextClick]);
    const handlePreviousClick = (0, import_react135.useCallback)((e3) => {
      if (previousMonth) {
        onPreviousClick?.(e3);
      }
    }, [previousMonth, onPreviousClick]);
    return import_react135.default.createElement(
      "nav",
      { ...navProps },
      import_react135.default.createElement(
        components.PreviousMonthButton,
        { type: "button", className: classNames[UI2.PreviousMonthButton], tabIndex: previousMonth ? void 0 : -1, "aria-disabled": previousMonth ? void 0 : true, "aria-label": labelPrevious2(previousMonth), onClick: handlePreviousClick },
        import_react135.default.createElement(components.Chevron, { disabled: previousMonth ? void 0 : true, className: classNames[UI2.Chevron], orientation: "left" })
      ),
      import_react135.default.createElement(
        components.NextMonthButton,
        { type: "button", className: classNames[UI2.NextMonthButton], tabIndex: nextMonth ? void 0 : -1, "aria-disabled": nextMonth ? void 0 : true, "aria-label": labelNext2(nextMonth), onClick: handleNextClick },
        import_react135.default.createElement(components.Chevron, { disabled: nextMonth ? void 0 : true, orientation: "right", className: classNames[UI2.Chevron] })
      )
    );
  }

  // node_modules/react-day-picker/dist/esm/components/NextMonthButton.js
  var import_react136 = __toESM(require_react(), 1);
  function NextMonthButton(props) {
    const { components } = useDayPicker();
    return import_react136.default.createElement(components.Button, { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Option.js
  var import_react137 = __toESM(require_react(), 1);
  function Option3(props) {
    return import_react137.default.createElement("option", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/PreviousMonthButton.js
  var import_react138 = __toESM(require_react(), 1);
  function PreviousMonthButton(props) {
    const { components } = useDayPicker();
    return import_react138.default.createElement(components.Button, { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Root.js
  var import_react139 = __toESM(require_react(), 1);
  function Root5(props) {
    const { rootRef, ...rest } = props;
    return import_react139.default.createElement("div", { ...rest, ref: rootRef });
  }

  // node_modules/react-day-picker/dist/esm/components/Select.js
  var import_react140 = __toESM(require_react(), 1);
  function Select4(props) {
    return import_react140.default.createElement("select", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Week.js
  var import_react141 = __toESM(require_react(), 1);
  function Week(props) {
    const { week, ...trProps } = props;
    return import_react141.default.createElement("tr", { ...trProps });
  }

  // node_modules/react-day-picker/dist/esm/components/Weekday.js
  var import_react142 = __toESM(require_react(), 1);
  function Weekday(props) {
    return import_react142.default.createElement("th", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Weekdays.js
  var import_react143 = __toESM(require_react(), 1);
  function Weekdays(props) {
    return import_react143.default.createElement(
      "thead",
      { "aria-hidden": true },
      import_react143.default.createElement("tr", { ...props })
    );
  }

  // node_modules/react-day-picker/dist/esm/components/WeekNumber.js
  var import_react144 = __toESM(require_react(), 1);
  function WeekNumber(props) {
    const { week, ...thProps } = props;
    return import_react144.default.createElement("th", { ...thProps });
  }

  // node_modules/react-day-picker/dist/esm/components/WeekNumberHeader.js
  var import_react145 = __toESM(require_react(), 1);
  function WeekNumberHeader(props) {
    return import_react145.default.createElement("th", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/Weeks.js
  var import_react146 = __toESM(require_react(), 1);
  function Weeks(props) {
    return import_react146.default.createElement("tbody", { ...props });
  }

  // node_modules/react-day-picker/dist/esm/components/YearsDropdown.js
  var import_react147 = __toESM(require_react(), 1);
  function YearsDropdown(props) {
    const { components } = useDayPicker();
    return import_react147.default.createElement(components.Dropdown, { ...props });
  }

  // node_modules/react-day-picker/dist/esm/helpers/getComponents.js
  function getComponents(customComponents) {
    return {
      ...custom_components_exports,
      ...customComponents
    };
  }

  // node_modules/react-day-picker/dist/esm/helpers/getDataAttributes.js
  function getDataAttributes(props) {
    const dataAttributes = {
      "data-mode": props.mode ?? void 0,
      "data-required": "required" in props ? props.required : void 0,
      "data-multiple-months": props.numberOfMonths && props.numberOfMonths > 1 || void 0,
      "data-week-numbers": props.showWeekNumber || void 0,
      "data-broadcast-calendar": props.broadcastCalendar || void 0,
      "data-nav-layout": props.navLayout || void 0
    };
    Object.entries(props).forEach(([key, val]) => {
      if (key.startsWith("data-")) {
        dataAttributes[key] = val;
      }
    });
    return dataAttributes;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getDefaultClassNames.js
  function getDefaultClassNames() {
    const classNames = {};
    for (const key in UI2) {
      classNames[UI2[key]] = `rdp-${UI2[key]}`;
    }
    for (const key in DayFlag) {
      classNames[DayFlag[key]] = `rdp-${DayFlag[key]}`;
    }
    for (const key in SelectionState) {
      classNames[SelectionState[key]] = `rdp-${SelectionState[key]}`;
    }
    for (const key in Animation) {
      classNames[Animation[key]] = `rdp-${Animation[key]}`;
    }
    return classNames;
  }

  // node_modules/react-day-picker/dist/esm/formatters/index.js
  var formatters_exports = {};
  __export(formatters_exports, {
    formatCaption: () => formatCaption,
    formatDay: () => formatDay,
    formatMonthCaption: () => formatMonthCaption,
    formatMonthDropdown: () => formatMonthDropdown,
    formatWeekNumber: () => formatWeekNumber,
    formatWeekNumberHeader: () => formatWeekNumberHeader,
    formatWeekdayName: () => formatWeekdayName,
    formatYearCaption: () => formatYearCaption,
    formatYearDropdown: () => formatYearDropdown
  });

  // node_modules/react-day-picker/dist/esm/formatters/formatCaption.js
  function formatCaption(month, options2, dateLib) {
    return (dateLib ?? new DateLib(options2)).format(month, "LLLL y");
  }
  var formatMonthCaption = formatCaption;

  // node_modules/react-day-picker/dist/esm/formatters/formatDay.js
  function formatDay(date, options2, dateLib) {
    return (dateLib ?? new DateLib(options2)).format(date, "d");
  }

  // node_modules/react-day-picker/dist/esm/formatters/formatMonthDropdown.js
  function formatMonthDropdown(month, dateLib = defaultDateLib) {
    return dateLib.format(month, "LLLL");
  }

  // node_modules/react-day-picker/dist/esm/formatters/formatWeekNumber.js
  function formatWeekNumber(weekNumber, dateLib = defaultDateLib) {
    if (weekNumber < 10) {
      return dateLib.formatNumber(`0${weekNumber.toLocaleString()}`);
    }
    return dateLib.formatNumber(`${weekNumber.toLocaleString()}`);
  }

  // node_modules/react-day-picker/dist/esm/formatters/formatWeekNumberHeader.js
  function formatWeekNumberHeader() {
    return ``;
  }

  // node_modules/react-day-picker/dist/esm/formatters/formatWeekdayName.js
  function formatWeekdayName(weekday, options2, dateLib) {
    return (dateLib ?? new DateLib(options2)).format(weekday, "cccccc");
  }

  // node_modules/react-day-picker/dist/esm/formatters/formatYearDropdown.js
  function formatYearDropdown(year, dateLib = defaultDateLib) {
    return dateLib.format(year, "yyyy");
  }
  var formatYearCaption = formatYearDropdown;

  // node_modules/react-day-picker/dist/esm/helpers/getFormatters.js
  function getFormatters(customFormatters) {
    if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) {
      customFormatters.formatCaption = customFormatters.formatMonthCaption;
    }
    if (customFormatters?.formatYearCaption && !customFormatters.formatYearDropdown) {
      customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
    }
    return {
      ...formatters_exports,
      ...customFormatters
    };
  }

  // node_modules/react-day-picker/dist/esm/helpers/getMonthOptions.js
  function getMonthOptions(displayMonth, navStart, navEnd, formatters2, dateLib) {
    const { startOfMonth: startOfMonth2, startOfYear: startOfYear2, endOfYear: endOfYear2, eachMonthOfInterval: eachMonthOfInterval2, getMonth: getMonth2 } = dateLib;
    const months = eachMonthOfInterval2({
      start: startOfYear2(displayMonth),
      end: endOfYear2(displayMonth)
    });
    const options2 = months.map((month) => {
      const label = formatters2.formatMonthDropdown(month, dateLib);
      const value = getMonth2(month);
      const disabled = navStart && month < startOfMonth2(navStart) || navEnd && month > startOfMonth2(navEnd) || false;
      return { value, label, disabled };
    });
    return options2;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getStyleForModifiers.js
  function getStyleForModifiers(dayModifiers, styles3 = {}, modifiersStyles = {}) {
    let style2 = { ...styles3?.[UI2.Day] };
    Object.entries(dayModifiers).filter(([, active]) => active === true).forEach(([modifier]) => {
      style2 = {
        ...style2,
        ...modifiersStyles?.[modifier]
      };
    });
    return style2;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getWeekdays.js
  function getWeekdays(dateLib, ISOWeek, broadcastCalendar) {
    const today = dateLib.today();
    const start = broadcastCalendar ? dateLib.startOfBroadcastWeek(today, dateLib) : ISOWeek ? dateLib.startOfISOWeek(today) : dateLib.startOfWeek(today);
    const days = [];
    for (let i3 = 0; i3 < 7; i3++) {
      const day = dateLib.addDays(start, i3);
      days.push(day);
    }
    return days;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getYearOptions.js
  function getYearOptions(navStart, navEnd, formatters2, dateLib) {
    if (!navStart)
      return void 0;
    if (!navEnd)
      return void 0;
    const { startOfYear: startOfYear2, endOfYear: endOfYear2, addYears: addYears2, getYear: getYear2, isBefore: isBefore2, isSameYear: isSameYear2 } = dateLib;
    const firstNavYear = startOfYear2(navStart);
    const lastNavYear = endOfYear2(navEnd);
    const years = [];
    let year = firstNavYear;
    while (isBefore2(year, lastNavYear) || isSameYear2(year, lastNavYear)) {
      years.push(year);
      year = addYears2(year, 1);
    }
    return years.map((year2) => {
      const label = formatters2.formatYearDropdown(year2, dateLib);
      return {
        value: getYear2(year2),
        label,
        disabled: false
      };
    });
  }

  // node_modules/react-day-picker/dist/esm/labels/index.js
  var labels_exports = {};
  __export(labels_exports, {
    labelCaption: () => labelCaption,
    labelDay: () => labelDay,
    labelDayButton: () => labelDayButton,
    labelGrid: () => labelGrid,
    labelGridcell: () => labelGridcell,
    labelMonthDropdown: () => labelMonthDropdown,
    labelNav: () => labelNav,
    labelNext: () => labelNext,
    labelPrevious: () => labelPrevious,
    labelWeekNumber: () => labelWeekNumber,
    labelWeekNumberHeader: () => labelWeekNumberHeader,
    labelWeekday: () => labelWeekday,
    labelYearDropdown: () => labelYearDropdown
  });

  // node_modules/react-day-picker/dist/esm/labels/labelGrid.js
  function labelGrid(date, options2, dateLib) {
    return (dateLib ?? new DateLib(options2)).format(date, "LLLL y");
  }
  var labelCaption = labelGrid;

  // node_modules/react-day-picker/dist/esm/labels/labelGridcell.js
  function labelGridcell(date, modifiers, options2, dateLib) {
    let label = (dateLib ?? new DateLib(options2)).format(date, "PPPP");
    if (modifiers?.today) {
      label = `Today, ${label}`;
    }
    return label;
  }

  // node_modules/react-day-picker/dist/esm/labels/labelDayButton.js
  function labelDayButton(date, modifiers, options2, dateLib) {
    let label = (dateLib ?? new DateLib(options2)).format(date, "PPPP");
    if (modifiers.today)
      label = `Today, ${label}`;
    if (modifiers.selected)
      label = `${label}, selected`;
    return label;
  }
  var labelDay = labelDayButton;

  // node_modules/react-day-picker/dist/esm/labels/labelNav.js
  function labelNav() {
    return "";
  }

  // node_modules/react-day-picker/dist/esm/labels/labelMonthDropdown.js
  function labelMonthDropdown(options2) {
    return "Choose the Month";
  }

  // node_modules/react-day-picker/dist/esm/labels/labelNext.js
  function labelNext(month) {
    return "Go to the Next Month";
  }

  // node_modules/react-day-picker/dist/esm/labels/labelPrevious.js
  function labelPrevious(month) {
    return "Go to the Previous Month";
  }

  // node_modules/react-day-picker/dist/esm/labels/labelWeekday.js
  function labelWeekday(date, options2, dateLib) {
    return (dateLib ?? new DateLib(options2)).format(date, "cccc");
  }

  // node_modules/react-day-picker/dist/esm/labels/labelWeekNumber.js
  function labelWeekNumber(weekNumber, options2) {
    return `Week ${weekNumber}`;
  }

  // node_modules/react-day-picker/dist/esm/labels/labelWeekNumberHeader.js
  function labelWeekNumberHeader(options2) {
    return "Week Number";
  }

  // node_modules/react-day-picker/dist/esm/labels/labelYearDropdown.js
  function labelYearDropdown(options2) {
    return "Choose the Year";
  }

  // node_modules/react-day-picker/dist/esm/useAnimation.js
  var import_react148 = __toESM(require_react(), 1);
  var asHtmlElement = (element) => {
    if (element instanceof HTMLElement)
      return element;
    return null;
  };
  var queryMonthEls = (element) => [
    ...element.querySelectorAll("[data-animated-month]") ?? []
  ];
  var queryMonthEl = (element) => asHtmlElement(element.querySelector("[data-animated-month]"));
  var queryCaptionEl = (element) => asHtmlElement(element.querySelector("[data-animated-caption]"));
  var queryWeeksEl = (element) => asHtmlElement(element.querySelector("[data-animated-weeks]"));
  var queryNavEl = (element) => asHtmlElement(element.querySelector("[data-animated-nav]"));
  var queryWeekdaysEl = (element) => asHtmlElement(element.querySelector("[data-animated-weekdays]"));
  function useAnimation(rootElRef, enabled, { classNames, months, focused, dateLib }) {
    const previousRootElSnapshotRef = (0, import_react148.useRef)(null);
    const previousMonthsRef = (0, import_react148.useRef)(months);
    const animatingRef = (0, import_react148.useRef)(false);
    (0, import_react148.useLayoutEffect)(() => {
      const previousMonths = previousMonthsRef.current;
      previousMonthsRef.current = months;
      if (!enabled || !rootElRef.current || // safety check because the ref can be set to anything by consumers
      !(rootElRef.current instanceof HTMLElement) || // validation required for the animation to work as expected
      months.length === 0 || previousMonths.length === 0 || months.length !== previousMonths.length) {
        return;
      }
      const isSameMonth2 = dateLib.isSameMonth(months[0].date, previousMonths[0].date);
      const isAfterPreviousMonth = dateLib.isAfter(months[0].date, previousMonths[0].date);
      const captionAnimationClass = isAfterPreviousMonth ? classNames[Animation.caption_after_enter] : classNames[Animation.caption_before_enter];
      const weeksAnimationClass = isAfterPreviousMonth ? classNames[Animation.weeks_after_enter] : classNames[Animation.weeks_before_enter];
      const previousRootElSnapshot = previousRootElSnapshotRef.current;
      const rootElSnapshot = rootElRef.current.cloneNode(true);
      if (rootElSnapshot instanceof HTMLElement) {
        const currentMonthElsSnapshot = queryMonthEls(rootElSnapshot);
        currentMonthElsSnapshot.forEach((currentMonthElSnapshot) => {
          if (!(currentMonthElSnapshot instanceof HTMLElement))
            return;
          const previousMonthElSnapshot = queryMonthEl(currentMonthElSnapshot);
          if (previousMonthElSnapshot && currentMonthElSnapshot.contains(previousMonthElSnapshot)) {
            currentMonthElSnapshot.removeChild(previousMonthElSnapshot);
          }
          const captionEl = queryCaptionEl(currentMonthElSnapshot);
          if (captionEl) {
            captionEl.classList.remove(captionAnimationClass);
          }
          const weeksEl = queryWeeksEl(currentMonthElSnapshot);
          if (weeksEl) {
            weeksEl.classList.remove(weeksAnimationClass);
          }
        });
        previousRootElSnapshotRef.current = rootElSnapshot;
      } else {
        previousRootElSnapshotRef.current = null;
      }
      if (animatingRef.current || isSameMonth2 || // skip animation if a day is focused because it can cause issues to the animation and is better for a11y
      focused) {
        return;
      }
      const previousMonthEls = previousRootElSnapshot instanceof HTMLElement ? queryMonthEls(previousRootElSnapshot) : [];
      const currentMonthEls = queryMonthEls(rootElRef.current);
      if (currentMonthEls && currentMonthEls.every((el) => el instanceof HTMLElement) && previousMonthEls && previousMonthEls.every((el) => el instanceof HTMLElement)) {
        animatingRef.current = true;
        const cleanUpFunctions = [];
        rootElRef.current.style.isolation = "isolate";
        const navEl = queryNavEl(rootElRef.current);
        if (navEl) {
          navEl.style.zIndex = "1";
        }
        currentMonthEls.forEach((currentMonthEl, index2) => {
          const previousMonthEl = previousMonthEls[index2];
          if (!previousMonthEl) {
            return;
          }
          currentMonthEl.style.position = "relative";
          currentMonthEl.style.overflow = "hidden";
          const captionEl = queryCaptionEl(currentMonthEl);
          if (captionEl) {
            captionEl.classList.add(captionAnimationClass);
          }
          const weeksEl = queryWeeksEl(currentMonthEl);
          if (weeksEl) {
            weeksEl.classList.add(weeksAnimationClass);
          }
          const cleanUp = () => {
            animatingRef.current = false;
            if (rootElRef.current) {
              rootElRef.current.style.isolation = "";
            }
            if (navEl) {
              navEl.style.zIndex = "";
            }
            if (captionEl) {
              captionEl.classList.remove(captionAnimationClass);
            }
            if (weeksEl) {
              weeksEl.classList.remove(weeksAnimationClass);
            }
            currentMonthEl.style.position = "";
            currentMonthEl.style.overflow = "";
            if (currentMonthEl.contains(previousMonthEl)) {
              currentMonthEl.removeChild(previousMonthEl);
            }
          };
          cleanUpFunctions.push(cleanUp);
          previousMonthEl.style.pointerEvents = "none";
          previousMonthEl.style.position = "absolute";
          previousMonthEl.style.overflow = "hidden";
          previousMonthEl.setAttribute("aria-hidden", "true");
          const previousWeekdaysEl = queryWeekdaysEl(previousMonthEl);
          if (previousWeekdaysEl) {
            previousWeekdaysEl.style.opacity = "0";
          }
          const previousCaptionEl = queryCaptionEl(previousMonthEl);
          if (previousCaptionEl) {
            previousCaptionEl.classList.add(isAfterPreviousMonth ? classNames[Animation.caption_before_exit] : classNames[Animation.caption_after_exit]);
            previousCaptionEl.addEventListener("animationend", cleanUp);
          }
          const previousWeeksEl = queryWeeksEl(previousMonthEl);
          if (previousWeeksEl) {
            previousWeeksEl.classList.add(isAfterPreviousMonth ? classNames[Animation.weeks_before_exit] : classNames[Animation.weeks_after_exit]);
          }
          currentMonthEl.insertBefore(previousMonthEl, currentMonthEl.firstChild);
        });
      }
    });
  }

  // node_modules/react-day-picker/dist/esm/useCalendar.js
  var import_react150 = __toESM(require_react(), 1);

  // node_modules/react-day-picker/dist/esm/helpers/getDates.js
  function getDates(displayMonths, maxDate, props, dateLib) {
    const firstMonth = displayMonths[0];
    const lastMonth = displayMonths[displayMonths.length - 1];
    const { ISOWeek, fixedWeeks, broadcastCalendar } = props ?? {};
    const { addDays: addDays2, differenceInCalendarDays: differenceInCalendarDays2, differenceInCalendarMonths: differenceInCalendarMonths2, endOfBroadcastWeek: endOfBroadcastWeek2, endOfISOWeek: endOfISOWeek2, endOfMonth: endOfMonth2, endOfWeek: endOfWeek2, isAfter: isAfter2, startOfBroadcastWeek: startOfBroadcastWeek2, startOfISOWeek: startOfISOWeek2, startOfWeek: startOfWeek2 } = dateLib;
    const startWeekFirstDate = broadcastCalendar ? startOfBroadcastWeek2(firstMonth, dateLib) : ISOWeek ? startOfISOWeek2(firstMonth) : startOfWeek2(firstMonth);
    const endWeekLastDate = broadcastCalendar ? endOfBroadcastWeek2(lastMonth) : ISOWeek ? endOfISOWeek2(endOfMonth2(lastMonth)) : endOfWeek2(endOfMonth2(lastMonth));
    const nOfDays = differenceInCalendarDays2(endWeekLastDate, startWeekFirstDate);
    const nOfMonths = differenceInCalendarMonths2(lastMonth, firstMonth) + 1;
    const dates = [];
    for (let i3 = 0; i3 <= nOfDays; i3++) {
      const date = addDays2(startWeekFirstDate, i3);
      if (maxDate && isAfter2(date, maxDate)) {
        break;
      }
      dates.push(date);
    }
    const nrOfDaysWithFixedWeeks = broadcastCalendar ? 35 : 42;
    const extraDates = nrOfDaysWithFixedWeeks * nOfMonths;
    if (fixedWeeks && dates.length < extraDates) {
      const daysToAdd = extraDates - dates.length;
      for (let i3 = 0; i3 < daysToAdd; i3++) {
        const date = addDays2(dates[dates.length - 1], 1);
        dates.push(date);
      }
    }
    return dates;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getDays.js
  function getDays(calendarMonths) {
    const initialDays = [];
    return calendarMonths.reduce((days, month) => {
      const weekDays = month.weeks.reduce((weekDays2, week) => {
        return [...weekDays2, ...week.days];
      }, initialDays);
      return [...days, ...weekDays];
    }, initialDays);
  }

  // node_modules/react-day-picker/dist/esm/helpers/getDisplayMonths.js
  function getDisplayMonths(firstDisplayedMonth, calendarEndMonth, props, dateLib) {
    const { numberOfMonths = 1 } = props;
    const months = [];
    for (let i3 = 0; i3 < numberOfMonths; i3++) {
      const month = dateLib.addMonths(firstDisplayedMonth, i3);
      if (calendarEndMonth && month > calendarEndMonth) {
        break;
      }
      months.push(month);
    }
    return months;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getInitialMonth.js
  function getInitialMonth(props, dateLib) {
    const { month, defaultMonth, today = dateLib.today(), numberOfMonths = 1, endMonth, startMonth } = props;
    let initialMonth = month || defaultMonth || today;
    const { differenceInCalendarMonths: differenceInCalendarMonths2, addMonths: addMonths2, startOfMonth: startOfMonth2 } = dateLib;
    if (endMonth && differenceInCalendarMonths2(endMonth, initialMonth) < 0) {
      const offset4 = -1 * (numberOfMonths - 1);
      initialMonth = addMonths2(endMonth, offset4);
    }
    if (startMonth && differenceInCalendarMonths2(initialMonth, startMonth) < 0) {
      initialMonth = startMonth;
    }
    return startOfMonth2(initialMonth);
  }

  // node_modules/react-day-picker/dist/esm/helpers/getMonths.js
  function getMonths(displayMonths, dates, props, dateLib) {
    const { addDays: addDays2, endOfBroadcastWeek: endOfBroadcastWeek2, endOfISOWeek: endOfISOWeek2, endOfMonth: endOfMonth2, endOfWeek: endOfWeek2, getISOWeek: getISOWeek2, getWeek: getWeek2, startOfBroadcastWeek: startOfBroadcastWeek2, startOfISOWeek: startOfISOWeek2, startOfWeek: startOfWeek2 } = dateLib;
    const dayPickerMonths = displayMonths.reduce((months, month) => {
      const firstDateOfFirstWeek = props.broadcastCalendar ? startOfBroadcastWeek2(month, dateLib) : props.ISOWeek ? startOfISOWeek2(month) : startOfWeek2(month);
      const lastDateOfLastWeek = props.broadcastCalendar ? endOfBroadcastWeek2(month) : props.ISOWeek ? endOfISOWeek2(endOfMonth2(month)) : endOfWeek2(endOfMonth2(month));
      const monthDates = dates.filter((date) => {
        return date >= firstDateOfFirstWeek && date <= lastDateOfLastWeek;
      });
      const nrOfDaysWithFixedWeeks = props.broadcastCalendar ? 35 : 42;
      if (props.fixedWeeks && monthDates.length < nrOfDaysWithFixedWeeks) {
        const extraDates = dates.filter((date) => {
          const daysToAdd = nrOfDaysWithFixedWeeks - monthDates.length;
          return date > lastDateOfLastWeek && date <= addDays2(lastDateOfLastWeek, daysToAdd);
        });
        monthDates.push(...extraDates);
      }
      const weeks = monthDates.reduce((weeks2, date) => {
        const weekNumber = props.ISOWeek ? getISOWeek2(date) : getWeek2(date);
        const week = weeks2.find((week2) => week2.weekNumber === weekNumber);
        const day = new CalendarDay(date, month, dateLib);
        if (!week) {
          weeks2.push(new CalendarWeek(weekNumber, [day]));
        } else {
          week.days.push(day);
        }
        return weeks2;
      }, []);
      const dayPickerMonth = new CalendarMonth(month, weeks);
      months.push(dayPickerMonth);
      return months;
    }, []);
    if (!props.reverseMonths) {
      return dayPickerMonths;
    } else {
      return dayPickerMonths.reverse();
    }
  }

  // node_modules/react-day-picker/dist/esm/helpers/getNavMonth.js
  function getNavMonths(props, dateLib) {
    let { startMonth, endMonth } = props;
    const { startOfYear: startOfYear2, startOfDay: startOfDay2, startOfMonth: startOfMonth2, endOfMonth: endOfMonth2, addYears: addYears2, endOfYear: endOfYear2, newDate, today } = dateLib;
    const { fromYear, toYear, fromMonth, toMonth } = props;
    if (!startMonth && fromMonth) {
      startMonth = fromMonth;
    }
    if (!startMonth && fromYear) {
      startMonth = dateLib.newDate(fromYear, 0, 1);
    }
    if (!endMonth && toMonth) {
      endMonth = toMonth;
    }
    if (!endMonth && toYear) {
      endMonth = newDate(toYear, 11, 31);
    }
    const hasYearDropdown = props.captionLayout === "dropdown" || props.captionLayout === "dropdown-years";
    if (startMonth) {
      startMonth = startOfMonth2(startMonth);
    } else if (fromYear) {
      startMonth = newDate(fromYear, 0, 1);
    } else if (!startMonth && hasYearDropdown) {
      startMonth = startOfYear2(addYears2(props.today ?? today(), -100));
    }
    if (endMonth) {
      endMonth = endOfMonth2(endMonth);
    } else if (toYear) {
      endMonth = newDate(toYear, 11, 31);
    } else if (!endMonth && hasYearDropdown) {
      endMonth = endOfYear2(props.today ?? today());
    }
    return [
      startMonth ? startOfDay2(startMonth) : startMonth,
      endMonth ? startOfDay2(endMonth) : endMonth
    ];
  }

  // node_modules/react-day-picker/dist/esm/helpers/getNextMonth.js
  function getNextMonth(firstDisplayedMonth, calendarEndMonth, options2, dateLib) {
    if (options2.disableNavigation) {
      return void 0;
    }
    const { pagedNavigation, numberOfMonths = 1 } = options2;
    const { startOfMonth: startOfMonth2, addMonths: addMonths2, differenceInCalendarMonths: differenceInCalendarMonths2 } = dateLib;
    const offset4 = pagedNavigation ? numberOfMonths : 1;
    const month = startOfMonth2(firstDisplayedMonth);
    if (!calendarEndMonth) {
      return addMonths2(month, offset4);
    }
    const monthsDiff = differenceInCalendarMonths2(calendarEndMonth, firstDisplayedMonth);
    if (monthsDiff < numberOfMonths) {
      return void 0;
    }
    return addMonths2(month, offset4);
  }

  // node_modules/react-day-picker/dist/esm/helpers/getPreviousMonth.js
  function getPreviousMonth(firstDisplayedMonth, calendarStartMonth, options2, dateLib) {
    if (options2.disableNavigation) {
      return void 0;
    }
    const { pagedNavigation, numberOfMonths } = options2;
    const { startOfMonth: startOfMonth2, addMonths: addMonths2, differenceInCalendarMonths: differenceInCalendarMonths2 } = dateLib;
    const offset4 = pagedNavigation ? numberOfMonths ?? 1 : 1;
    const month = startOfMonth2(firstDisplayedMonth);
    if (!calendarStartMonth) {
      return addMonths2(month, -offset4);
    }
    const monthsDiff = differenceInCalendarMonths2(month, calendarStartMonth);
    if (monthsDiff <= 0) {
      return void 0;
    }
    return addMonths2(month, -offset4);
  }

  // node_modules/react-day-picker/dist/esm/helpers/getWeeks.js
  function getWeeks(months) {
    const initialWeeks = [];
    return months.reduce((weeks, month) => {
      return [...weeks, ...month.weeks];
    }, initialWeeks);
  }

  // node_modules/react-day-picker/dist/esm/helpers/useControlledValue.js
  var import_react149 = __toESM(require_react(), 1);
  function useControlledValue2(defaultValue2, controlledValue) {
    const [uncontrolledValue, setValue] = (0, import_react149.useState)(defaultValue2);
    const value = controlledValue === void 0 ? uncontrolledValue : controlledValue;
    return [value, setValue];
  }

  // node_modules/react-day-picker/dist/esm/useCalendar.js
  function useCalendar(props, dateLib) {
    const [navStart, navEnd] = getNavMonths(props, dateLib);
    const { startOfMonth: startOfMonth2, endOfMonth: endOfMonth2 } = dateLib;
    const initialMonth = getInitialMonth(props, dateLib);
    const [firstMonth, setFirstMonth] = useControlledValue2(
      initialMonth,
      // initialMonth is always computed from props.month if provided
      props.month ? initialMonth : void 0
    );
    (0, import_react150.useEffect)(() => {
      const newInitialMonth = getInitialMonth(props, dateLib);
      setFirstMonth(newInitialMonth);
    }, [props.timeZone]);
    const displayMonths = getDisplayMonths(firstMonth, navEnd, props, dateLib);
    const dates = getDates(displayMonths, props.endMonth ? endOfMonth2(props.endMonth) : void 0, props, dateLib);
    const months = getMonths(displayMonths, dates, props, dateLib);
    const weeks = getWeeks(months);
    const days = getDays(months);
    const previousMonth = getPreviousMonth(firstMonth, navStart, props, dateLib);
    const nextMonth = getNextMonth(firstMonth, navEnd, props, dateLib);
    const { disableNavigation, onMonthChange } = props;
    const isDayInCalendar = (day) => weeks.some((week) => week.days.some((d3) => d3.isEqualTo(day)));
    const goToMonth = (date) => {
      if (disableNavigation) {
        return;
      }
      let newMonth = startOfMonth2(date);
      if (navStart && newMonth < startOfMonth2(navStart)) {
        newMonth = startOfMonth2(navStart);
      }
      if (navEnd && newMonth > startOfMonth2(navEnd)) {
        newMonth = startOfMonth2(navEnd);
      }
      setFirstMonth(newMonth);
      onMonthChange?.(newMonth);
    };
    const goToDay = (day) => {
      if (isDayInCalendar(day)) {
        return;
      }
      goToMonth(day.date);
    };
    const calendar = {
      months,
      weeks,
      days,
      navStart,
      navEnd,
      previousMonth,
      nextMonth,
      goToMonth,
      goToDay
    };
    return calendar;
  }

  // node_modules/react-day-picker/dist/esm/useFocus.js
  var import_react151 = __toESM(require_react(), 1);

  // node_modules/react-day-picker/dist/esm/helpers/calculateFocusTarget.js
  var FocusTargetPriority;
  (function(FocusTargetPriority2) {
    FocusTargetPriority2[FocusTargetPriority2["Today"] = 0] = "Today";
    FocusTargetPriority2[FocusTargetPriority2["Selected"] = 1] = "Selected";
    FocusTargetPriority2[FocusTargetPriority2["LastFocused"] = 2] = "LastFocused";
    FocusTargetPriority2[FocusTargetPriority2["FocusedModifier"] = 3] = "FocusedModifier";
  })(FocusTargetPriority || (FocusTargetPriority = {}));
  function isFocusableDay(modifiers) {
    return !modifiers[DayFlag.disabled] && !modifiers[DayFlag.hidden] && !modifiers[DayFlag.outside];
  }
  function calculateFocusTarget(days, getModifiers, isSelected2, lastFocused) {
    let focusTarget;
    let foundFocusTargetPriority = -1;
    for (const day of days) {
      const modifiers = getModifiers(day);
      if (isFocusableDay(modifiers)) {
        if (modifiers[DayFlag.focused] && foundFocusTargetPriority < FocusTargetPriority.FocusedModifier) {
          focusTarget = day;
          foundFocusTargetPriority = FocusTargetPriority.FocusedModifier;
        } else if (lastFocused?.isEqualTo(day) && foundFocusTargetPriority < FocusTargetPriority.LastFocused) {
          focusTarget = day;
          foundFocusTargetPriority = FocusTargetPriority.LastFocused;
        } else if (isSelected2(day.date) && foundFocusTargetPriority < FocusTargetPriority.Selected) {
          focusTarget = day;
          foundFocusTargetPriority = FocusTargetPriority.Selected;
        } else if (modifiers[DayFlag.today] && foundFocusTargetPriority < FocusTargetPriority.Today) {
          focusTarget = day;
          foundFocusTargetPriority = FocusTargetPriority.Today;
        }
      }
    }
    if (!focusTarget) {
      focusTarget = days.find((day) => isFocusableDay(getModifiers(day)));
    }
    return focusTarget;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getFocusableDate.js
  function getFocusableDate(moveBy, moveDir, refDate, navStart, navEnd, props, dateLib) {
    const { ISOWeek, broadcastCalendar } = props;
    const { addDays: addDays2, addMonths: addMonths2, addWeeks: addWeeks2, addYears: addYears2, endOfBroadcastWeek: endOfBroadcastWeek2, endOfISOWeek: endOfISOWeek2, endOfWeek: endOfWeek2, max: max3, min: min3, startOfBroadcastWeek: startOfBroadcastWeek2, startOfISOWeek: startOfISOWeek2, startOfWeek: startOfWeek2 } = dateLib;
    const moveFns = {
      day: addDays2,
      week: addWeeks2,
      month: addMonths2,
      year: addYears2,
      startOfWeek: (date) => broadcastCalendar ? startOfBroadcastWeek2(date, dateLib) : ISOWeek ? startOfISOWeek2(date) : startOfWeek2(date),
      endOfWeek: (date) => broadcastCalendar ? endOfBroadcastWeek2(date) : ISOWeek ? endOfISOWeek2(date) : endOfWeek2(date)
    };
    let focusableDate = moveFns[moveBy](refDate, moveDir === "after" ? 1 : -1);
    if (moveDir === "before" && navStart) {
      focusableDate = max3([navStart, focusableDate]);
    } else if (moveDir === "after" && navEnd) {
      focusableDate = min3([navEnd, focusableDate]);
    }
    return focusableDate;
  }

  // node_modules/react-day-picker/dist/esm/helpers/getNextFocus.js
  function getNextFocus(moveBy, moveDir, refDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt = 0) {
    if (attempt > 365) {
      return void 0;
    }
    const focusableDate = getFocusableDate(moveBy, moveDir, refDay.date, calendarStartMonth, calendarEndMonth, props, dateLib);
    const isDisabled = Boolean(props.disabled && dateMatchModifiers(focusableDate, props.disabled, dateLib));
    const isHidden2 = Boolean(props.hidden && dateMatchModifiers(focusableDate, props.hidden, dateLib));
    const targetMonth = focusableDate;
    const focusDay = new CalendarDay(focusableDate, targetMonth, dateLib);
    if (!isDisabled && !isHidden2) {
      return focusDay;
    }
    return getNextFocus(moveBy, moveDir, focusDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt + 1);
  }

  // node_modules/react-day-picker/dist/esm/useFocus.js
  function useFocus(props, calendar, getModifiers, isSelected2, dateLib) {
    const { autoFocus } = props;
    const [lastFocused, setLastFocused] = (0, import_react151.useState)();
    const focusTarget = calculateFocusTarget(calendar.days, getModifiers, isSelected2 || (() => false), lastFocused);
    const [focusedDay, setFocused] = (0, import_react151.useState)(autoFocus ? focusTarget : void 0);
    const blur = () => {
      setLastFocused(focusedDay);
      setFocused(void 0);
    };
    const moveFocus = (moveBy, moveDir) => {
      if (!focusedDay)
        return;
      const nextFocus = getNextFocus(moveBy, moveDir, focusedDay, calendar.navStart, calendar.navEnd, props, dateLib);
      if (!nextFocus)
        return;
      calendar.goToDay(nextFocus);
      setFocused(nextFocus);
    };
    const isFocusTarget = (day) => {
      return Boolean(focusTarget?.isEqualTo(day));
    };
    const useFocus2 = {
      isFocusTarget,
      setFocused,
      focused: focusedDay,
      blur,
      moveFocus
    };
    return useFocus2;
  }

  // node_modules/react-day-picker/dist/esm/selection/useMulti.js
  function useMulti(props, dateLib) {
    const { selected: initiallySelected, required, onSelect } = props;
    const [internallySelected, setSelected] = useControlledValue2(initiallySelected, onSelect ? initiallySelected : void 0);
    const selected = !onSelect ? internallySelected : initiallySelected;
    const { isSameDay: isSameDay2 } = dateLib;
    const isSelected2 = (date) => {
      return selected?.some((d3) => isSameDay2(d3, date)) ?? false;
    };
    const { min: min3, max: max3 } = props;
    const select = (triggerDate, modifiers, e3) => {
      let newDates = [...selected ?? []];
      if (isSelected2(triggerDate)) {
        if (selected?.length === min3) {
          return;
        }
        if (required && selected?.length === 1) {
          return;
        }
        newDates = selected?.filter((d3) => !isSameDay2(d3, triggerDate));
      } else {
        if (selected?.length === max3) {
          newDates = [triggerDate];
        } else {
          newDates = [...newDates, triggerDate];
        }
      }
      if (!onSelect) {
        setSelected(newDates);
      }
      onSelect?.(newDates, triggerDate, modifiers, e3);
      return newDates;
    };
    return {
      selected,
      select,
      isSelected: isSelected2
    };
  }

  // node_modules/react-day-picker/dist/esm/utils/addToRange.js
  function addToRange(date, initialRange, min3 = 0, max3 = 0, required = false, dateLib = defaultDateLib) {
    const { from: from2, to } = initialRange || {};
    const { isSameDay: isSameDay2, isAfter: isAfter2, isBefore: isBefore2 } = dateLib;
    let range;
    if (!from2 && !to) {
      range = { from: date, to: min3 > 0 ? void 0 : date };
    } else if (from2 && !to) {
      if (isSameDay2(from2, date)) {
        if (required) {
          range = { from: from2, to: void 0 };
        } else {
          range = void 0;
        }
      } else if (isBefore2(date, from2)) {
        range = { from: date, to: from2 };
      } else {
        range = { from: from2, to: date };
      }
    } else if (from2 && to) {
      if (isSameDay2(from2, date) && isSameDay2(to, date)) {
        if (required) {
          range = { from: from2, to };
        } else {
          range = void 0;
        }
      } else if (isSameDay2(from2, date)) {
        range = { from: from2, to: min3 > 0 ? void 0 : date };
      } else if (isSameDay2(to, date)) {
        range = { from: date, to: min3 > 0 ? void 0 : date };
      } else if (isBefore2(date, from2)) {
        range = { from: date, to };
      } else if (isAfter2(date, from2)) {
        range = { from: from2, to: date };
      } else if (isAfter2(date, to)) {
        range = { from: from2, to: date };
      } else {
        throw new Error("Invalid range");
      }
    }
    if (range?.from && range?.to) {
      const diff = dateLib.differenceInCalendarDays(range.to, range.from);
      if (max3 > 0 && diff > max3) {
        range = { from: date, to: void 0 };
      } else if (min3 > 1 && diff < min3) {
        range = { from: date, to: void 0 };
      }
    }
    return range;
  }

  // node_modules/react-day-picker/dist/esm/utils/rangeContainsDayOfWeek.js
  function rangeContainsDayOfWeek(range, dayOfWeek, dateLib = defaultDateLib) {
    const dayOfWeekArr = !Array.isArray(dayOfWeek) ? [dayOfWeek] : dayOfWeek;
    let date = range.from;
    const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
    const totalDaysLimit = Math.min(totalDays, 6);
    for (let i3 = 0; i3 <= totalDaysLimit; i3++) {
      if (dayOfWeekArr.includes(date.getDay())) {
        return true;
      }
      date = dateLib.addDays(date, 1);
    }
    return false;
  }

  // node_modules/react-day-picker/dist/esm/utils/rangeOverlaps.js
  function rangeOverlaps(rangeLeft, rangeRight, dateLib = defaultDateLib) {
    return rangeIncludesDate(rangeLeft, rangeRight.from, false, dateLib) || rangeIncludesDate(rangeLeft, rangeRight.to, false, dateLib) || rangeIncludesDate(rangeRight, rangeLeft.from, false, dateLib) || rangeIncludesDate(rangeRight, rangeLeft.to, false, dateLib);
  }

  // node_modules/react-day-picker/dist/esm/utils/rangeContainsModifiers.js
  function rangeContainsModifiers(range, modifiers, dateLib = defaultDateLib) {
    const matchers = Array.isArray(modifiers) ? modifiers : [modifiers];
    const nonFunctionMatchers = matchers.filter((matcher) => typeof matcher !== "function");
    const nonFunctionMatchersResult = nonFunctionMatchers.some((matcher) => {
      if (typeof matcher === "boolean")
        return matcher;
      if (dateLib.isDate(matcher)) {
        return rangeIncludesDate(range, matcher, false, dateLib);
      }
      if (isDatesArray(matcher, dateLib)) {
        return matcher.some((date) => rangeIncludesDate(range, date, false, dateLib));
      }
      if (isDateRange(matcher)) {
        if (matcher.from && matcher.to) {
          return rangeOverlaps(range, { from: matcher.from, to: matcher.to }, dateLib);
        }
        return false;
      }
      if (isDayOfWeekType(matcher)) {
        return rangeContainsDayOfWeek(range, matcher.dayOfWeek, dateLib);
      }
      if (isDateInterval(matcher)) {
        const isClosedInterval = dateLib.isAfter(matcher.before, matcher.after);
        if (isClosedInterval) {
          return rangeOverlaps(range, {
            from: dateLib.addDays(matcher.after, 1),
            to: dateLib.addDays(matcher.before, -1)
          }, dateLib);
        }
        return dateMatchModifiers(range.from, matcher, dateLib) || dateMatchModifiers(range.to, matcher, dateLib);
      }
      if (isDateAfterType(matcher) || isDateBeforeType(matcher)) {
        return dateMatchModifiers(range.from, matcher, dateLib) || dateMatchModifiers(range.to, matcher, dateLib);
      }
      return false;
    });
    if (nonFunctionMatchersResult) {
      return true;
    }
    const functionMatchers = matchers.filter((matcher) => typeof matcher === "function");
    if (functionMatchers.length) {
      let date = range.from;
      const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
      for (let i3 = 0; i3 <= totalDays; i3++) {
        if (functionMatchers.some((matcher) => matcher(date))) {
          return true;
        }
        date = dateLib.addDays(date, 1);
      }
    }
    return false;
  }

  // node_modules/react-day-picker/dist/esm/selection/useRange.js
  function useRange(props, dateLib) {
    const { disabled, excludeDisabled, selected: initiallySelected, required, onSelect } = props;
    const [internallySelected, setSelected] = useControlledValue2(initiallySelected, onSelect ? initiallySelected : void 0);
    const selected = !onSelect ? internallySelected : initiallySelected;
    const isSelected2 = (date) => selected && rangeIncludesDate(selected, date, false, dateLib);
    const select = (triggerDate, modifiers, e3) => {
      const { min: min3, max: max3 } = props;
      const newRange = triggerDate ? addToRange(triggerDate, selected, min3, max3, required, dateLib) : void 0;
      if (excludeDisabled && disabled && newRange?.from && newRange.to) {
        if (rangeContainsModifiers({ from: newRange.from, to: newRange.to }, disabled, dateLib)) {
          newRange.from = triggerDate;
          newRange.to = void 0;
        }
      }
      if (!onSelect) {
        setSelected(newRange);
      }
      onSelect?.(newRange, triggerDate, modifiers, e3);
      return newRange;
    };
    return {
      selected,
      select,
      isSelected: isSelected2
    };
  }

  // node_modules/react-day-picker/dist/esm/selection/useSingle.js
  function useSingle(props, dateLib) {
    const { selected: initiallySelected, required, onSelect } = props;
    const [internallySelected, setSelected] = useControlledValue2(initiallySelected, onSelect ? initiallySelected : void 0);
    const selected = !onSelect ? internallySelected : initiallySelected;
    const { isSameDay: isSameDay2 } = dateLib;
    const isSelected2 = (compareDate) => {
      return selected ? isSameDay2(selected, compareDate) : false;
    };
    const select = (triggerDate, modifiers, e3) => {
      let newDate = triggerDate;
      if (!required && selected && selected && isSameDay2(triggerDate, selected)) {
        newDate = void 0;
      }
      if (!onSelect) {
        setSelected(newDate);
      }
      if (required) {
        onSelect?.(newDate, triggerDate, modifiers, e3);
      } else {
        onSelect?.(newDate, triggerDate, modifiers, e3);
      }
      return newDate;
    };
    return {
      selected,
      select,
      isSelected: isSelected2
    };
  }

  // node_modules/react-day-picker/dist/esm/useSelection.js
  function useSelection(props, dateLib) {
    const single = useSingle(props, dateLib);
    const multi = useMulti(props, dateLib);
    const range = useRange(props, dateLib);
    switch (props.mode) {
      case "single":
        return single;
      case "multiple":
        return multi;
      case "range":
        return range;
      default:
        return void 0;
    }
  }

  // node_modules/react-day-picker/dist/esm/DayPicker.js
  function DayPicker(initialProps) {
    let props = initialProps;
    if (props.timeZone) {
      props = {
        ...initialProps
      };
      if (props.today) {
        props.today = new TZDate(props.today, props.timeZone);
      }
      if (props.month) {
        props.month = new TZDate(props.month, props.timeZone);
      }
      if (props.defaultMonth) {
        props.defaultMonth = new TZDate(props.defaultMonth, props.timeZone);
      }
      if (props.startMonth) {
        props.startMonth = new TZDate(props.startMonth, props.timeZone);
      }
      if (props.endMonth) {
        props.endMonth = new TZDate(props.endMonth, props.timeZone);
      }
      if (props.mode === "single" && props.selected) {
        props.selected = new TZDate(props.selected, props.timeZone);
      } else if (props.mode === "multiple" && props.selected) {
        props.selected = props.selected?.map((date) => new TZDate(date, props.timeZone));
      } else if (props.mode === "range" && props.selected) {
        props.selected = {
          from: props.selected.from ? new TZDate(props.selected.from, props.timeZone) : void 0,
          to: props.selected.to ? new TZDate(props.selected.to, props.timeZone) : void 0
        };
      }
    }
    const { components, formatters: formatters2, labels, dateLib, locale, classNames } = (0, import_react152.useMemo)(() => {
      const locale2 = { ...enUS, ...props.locale };
      const dateLib2 = new DateLib({
        locale: locale2,
        weekStartsOn: props.broadcastCalendar ? 1 : props.weekStartsOn,
        firstWeekContainsDate: props.firstWeekContainsDate,
        useAdditionalWeekYearTokens: props.useAdditionalWeekYearTokens,
        useAdditionalDayOfYearTokens: props.useAdditionalDayOfYearTokens,
        timeZone: props.timeZone,
        numerals: props.numerals
      }, props.dateLib);
      return {
        dateLib: dateLib2,
        components: getComponents(props.components),
        formatters: getFormatters(props.formatters),
        labels: { ...labels_exports, ...props.labels },
        locale: locale2,
        classNames: { ...getDefaultClassNames(), ...props.classNames }
      };
    }, [
      props.locale,
      props.broadcastCalendar,
      props.weekStartsOn,
      props.firstWeekContainsDate,
      props.useAdditionalWeekYearTokens,
      props.useAdditionalDayOfYearTokens,
      props.timeZone,
      props.numerals,
      props.dateLib,
      props.components,
      props.formatters,
      props.labels,
      props.classNames
    ]);
    const { captionLayout, mode: mode2, navLayout, numberOfMonths = 1, onDayBlur, onDayClick, onDayFocus, onDayKeyDown, onDayMouseEnter, onDayMouseLeave, onNextClick, onPrevClick, showWeekNumber, styles: styles3 } = props;
    const { formatCaption: formatCaption2, formatDay: formatDay2, formatMonthDropdown: formatMonthDropdown2, formatWeekNumber: formatWeekNumber2, formatWeekNumberHeader: formatWeekNumberHeader2, formatWeekdayName: formatWeekdayName2, formatYearDropdown: formatYearDropdown2 } = formatters2;
    const calendar = useCalendar(props, dateLib);
    const { days, months, navStart, navEnd, previousMonth, nextMonth, goToMonth } = calendar;
    const getModifiers = createGetModifiers(days, props, dateLib);
    const { isSelected: isSelected2, select, selected: selectedValue } = useSelection(props, dateLib) ?? {};
    const { blur, focused, isFocusTarget, moveFocus, setFocused } = useFocus(props, calendar, getModifiers, isSelected2 ?? (() => false), dateLib);
    const { labelDayButton: labelDayButton2, labelGridcell: labelGridcell2, labelGrid: labelGrid2, labelMonthDropdown: labelMonthDropdown2, labelNav: labelNav2, labelPrevious: labelPrevious2, labelNext: labelNext2, labelWeekday: labelWeekday2, labelWeekNumber: labelWeekNumber2, labelWeekNumberHeader: labelWeekNumberHeader2, labelYearDropdown: labelYearDropdown2 } = labels;
    const weekdays = (0, import_react152.useMemo)(() => getWeekdays(dateLib, props.ISOWeek), [dateLib, props.ISOWeek]);
    const isInteractive = mode2 !== void 0 || onDayClick !== void 0;
    const handlePreviousClick = (0, import_react152.useCallback)(() => {
      if (!previousMonth)
        return;
      goToMonth(previousMonth);
      onPrevClick?.(previousMonth);
    }, [previousMonth, goToMonth, onPrevClick]);
    const handleNextClick = (0, import_react152.useCallback)(() => {
      if (!nextMonth)
        return;
      goToMonth(nextMonth);
      onNextClick?.(nextMonth);
    }, [goToMonth, nextMonth, onNextClick]);
    const handleDayClick = (0, import_react152.useCallback)((day, m3) => (e3) => {
      e3.preventDefault();
      e3.stopPropagation();
      setFocused(day);
      select?.(day.date, m3, e3);
      onDayClick?.(day.date, m3, e3);
    }, [select, onDayClick, setFocused]);
    const handleDayFocus = (0, import_react152.useCallback)((day, m3) => (e3) => {
      setFocused(day);
      onDayFocus?.(day.date, m3, e3);
    }, [onDayFocus, setFocused]);
    const handleDayBlur = (0, import_react152.useCallback)((day, m3) => (e3) => {
      blur();
      onDayBlur?.(day.date, m3, e3);
    }, [blur, onDayBlur]);
    const handleDayKeyDown = (0, import_react152.useCallback)((day, modifiers) => (e3) => {
      const keyMap = {
        ArrowLeft: ["day", props.dir === "rtl" ? "after" : "before"],
        ArrowRight: ["day", props.dir === "rtl" ? "before" : "after"],
        ArrowDown: ["week", "after"],
        ArrowUp: ["week", "before"],
        PageUp: [e3.shiftKey ? "year" : "month", "before"],
        PageDown: [e3.shiftKey ? "year" : "month", "after"],
        Home: ["startOfWeek", "before"],
        End: ["endOfWeek", "after"]
      };
      if (keyMap[e3.key]) {
        e3.preventDefault();
        e3.stopPropagation();
        const [moveBy, moveDir] = keyMap[e3.key];
        moveFocus(moveBy, moveDir);
      }
      onDayKeyDown?.(day.date, modifiers, e3);
    }, [moveFocus, onDayKeyDown, props.dir]);
    const handleDayMouseEnter = (0, import_react152.useCallback)((day, modifiers) => (e3) => {
      onDayMouseEnter?.(day.date, modifiers, e3);
    }, [onDayMouseEnter]);
    const handleDayMouseLeave = (0, import_react152.useCallback)((day, modifiers) => (e3) => {
      onDayMouseLeave?.(day.date, modifiers, e3);
    }, [onDayMouseLeave]);
    const handleMonthChange = (0, import_react152.useCallback)((date) => (e3) => {
      const selectedMonth = Number(e3.target.value);
      const month = dateLib.setMonth(dateLib.startOfMonth(date), selectedMonth);
      goToMonth(month);
    }, [dateLib, goToMonth]);
    const handleYearChange = (0, import_react152.useCallback)((date) => (e3) => {
      const selectedYear = Number(e3.target.value);
      const month = dateLib.setYear(dateLib.startOfMonth(date), selectedYear);
      goToMonth(month);
    }, [dateLib, goToMonth]);
    const { className: className2, style: style2 } = (0, import_react152.useMemo)(() => ({
      className: [classNames[UI2.Root], props.className].filter(Boolean).join(" "),
      style: { ...styles3?.[UI2.Root], ...props.style }
    }), [classNames, props.className, props.style, styles3]);
    const dataAttributes = getDataAttributes(props);
    const rootElRef = (0, import_react152.useRef)(null);
    useAnimation(rootElRef, Boolean(props.animate), {
      classNames,
      months,
      focused,
      dateLib
    });
    const contextValue = {
      dayPickerProps: props,
      selected: selectedValue,
      select,
      isSelected: isSelected2,
      months,
      nextMonth,
      previousMonth,
      goToMonth,
      getModifiers,
      components,
      classNames,
      styles: styles3,
      labels,
      formatters: formatters2
    };
    return import_react152.default.createElement(
      dayPickerContext.Provider,
      { value: contextValue },
      import_react152.default.createElement(
        components.Root,
        { rootRef: props.animate ? rootElRef : void 0, className: className2, style: style2, dir: props.dir, id: props.id, lang: props.lang, nonce: props.nonce, title: props.title, role: props.role, "aria-label": props["aria-label"], ...dataAttributes },
        import_react152.default.createElement(
          components.Months,
          { className: classNames[UI2.Months], style: styles3?.[UI2.Months] },
          !props.hideNavigation && !navLayout && import_react152.default.createElement(components.Nav, { "data-animated-nav": props.animate ? "true" : void 0, className: classNames[UI2.Nav], style: styles3?.[UI2.Nav], "aria-label": labelNav2(), onPreviousClick: handlePreviousClick, onNextClick: handleNextClick, previousMonth, nextMonth }),
          months.map((calendarMonth, displayIndex) => {
            const dropdownMonths = getMonthOptions(calendarMonth.date, navStart, navEnd, formatters2, dateLib);
            const dropdownYears = getYearOptions(navStart, navEnd, formatters2, dateLib);
            return import_react152.default.createElement(
              components.Month,
              { "data-animated-month": props.animate ? "true" : void 0, className: classNames[UI2.Month], style: styles3?.[UI2.Month], key: displayIndex, displayIndex, calendarMonth },
              navLayout === "around" && !props.hideNavigation && displayIndex === 0 && import_react152.default.createElement(
                components.PreviousMonthButton,
                { type: "button", className: classNames[UI2.PreviousMonthButton], tabIndex: previousMonth ? void 0 : -1, "aria-disabled": previousMonth ? void 0 : true, "aria-label": labelPrevious2(previousMonth), onClick: handlePreviousClick, "data-animated-button": props.animate ? "true" : void 0 },
                import_react152.default.createElement(components.Chevron, { disabled: previousMonth ? void 0 : true, className: classNames[UI2.Chevron], orientation: props.dir === "rtl" ? "right" : "left" })
              ),
              import_react152.default.createElement(components.MonthCaption, { "data-animated-caption": props.animate ? "true" : void 0, className: classNames[UI2.MonthCaption], style: styles3?.[UI2.MonthCaption], calendarMonth, displayIndex }, captionLayout?.startsWith("dropdown") ? import_react152.default.createElement(
                components.DropdownNav,
                { className: classNames[UI2.Dropdowns], style: styles3?.[UI2.Dropdowns] },
                captionLayout === "dropdown" || captionLayout === "dropdown-months" ? import_react152.default.createElement(components.MonthsDropdown, { className: classNames[UI2.MonthsDropdown], "aria-label": labelMonthDropdown2(), classNames, components, disabled: Boolean(props.disableNavigation), onChange: handleMonthChange(calendarMonth.date), options: dropdownMonths, style: styles3?.[UI2.Dropdown], value: dateLib.getMonth(calendarMonth.date) }) : import_react152.default.createElement("span", null, formatMonthDropdown2(calendarMonth.date, dateLib)),
                captionLayout === "dropdown" || captionLayout === "dropdown-years" ? import_react152.default.createElement(components.YearsDropdown, { className: classNames[UI2.YearsDropdown], "aria-label": labelYearDropdown2(dateLib.options), classNames, components, disabled: Boolean(props.disableNavigation), onChange: handleYearChange(calendarMonth.date), options: dropdownYears, style: styles3?.[UI2.Dropdown], value: dateLib.getYear(calendarMonth.date) }) : import_react152.default.createElement("span", null, formatYearDropdown2(calendarMonth.date, dateLib)),
                import_react152.default.createElement("span", { role: "status", "aria-live": "polite", style: {
                  border: 0,
                  clip: "rect(0 0 0 0)",
                  height: "1px",
                  margin: "-1px",
                  overflow: "hidden",
                  padding: 0,
                  position: "absolute",
                  width: "1px",
                  whiteSpace: "nowrap",
                  wordWrap: "normal"
                } }, formatCaption2(calendarMonth.date, dateLib.options, dateLib))
              ) : import_react152.default.createElement(components.CaptionLabel, { className: classNames[UI2.CaptionLabel], role: "status", "aria-live": "polite" }, formatCaption2(calendarMonth.date, dateLib.options, dateLib))),
              navLayout === "around" && !props.hideNavigation && displayIndex === numberOfMonths - 1 && import_react152.default.createElement(
                components.NextMonthButton,
                { type: "button", className: classNames[UI2.NextMonthButton], tabIndex: nextMonth ? void 0 : -1, "aria-disabled": nextMonth ? void 0 : true, "aria-label": labelNext2(nextMonth), onClick: handleNextClick, "data-animated-button": props.animate ? "true" : void 0 },
                import_react152.default.createElement(components.Chevron, { disabled: nextMonth ? void 0 : true, className: classNames[UI2.Chevron], orientation: props.dir === "rtl" ? "left" : "right" })
              ),
              displayIndex === numberOfMonths - 1 && navLayout === "after" && !props.hideNavigation && import_react152.default.createElement(components.Nav, { "data-animated-nav": props.animate ? "true" : void 0, className: classNames[UI2.Nav], style: styles3?.[UI2.Nav], "aria-label": labelNav2(), onPreviousClick: handlePreviousClick, onNextClick: handleNextClick, previousMonth, nextMonth }),
              import_react152.default.createElement(
                components.MonthGrid,
                { role: "grid", "aria-multiselectable": mode2 === "multiple" || mode2 === "range", "aria-label": labelGrid2(calendarMonth.date, dateLib.options, dateLib) || void 0, className: classNames[UI2.MonthGrid], style: styles3?.[UI2.MonthGrid] },
                !props.hideWeekdays && import_react152.default.createElement(
                  components.Weekdays,
                  { "data-animated-weekdays": props.animate ? "true" : void 0, className: classNames[UI2.Weekdays], style: styles3?.[UI2.Weekdays] },
                  showWeekNumber && import_react152.default.createElement(components.WeekNumberHeader, { "aria-label": labelWeekNumberHeader2(dateLib.options), className: classNames[UI2.WeekNumberHeader], style: styles3?.[UI2.WeekNumberHeader], scope: "col" }, formatWeekNumberHeader2()),
                  weekdays.map((weekday, i3) => import_react152.default.createElement(components.Weekday, { "aria-label": labelWeekday2(weekday, dateLib.options, dateLib), className: classNames[UI2.Weekday], key: i3, style: styles3?.[UI2.Weekday], scope: "col" }, formatWeekdayName2(weekday, dateLib.options, dateLib)))
                ),
                import_react152.default.createElement(components.Weeks, { "data-animated-weeks": props.animate ? "true" : void 0, className: classNames[UI2.Weeks], style: styles3?.[UI2.Weeks] }, calendarMonth.weeks.map((week, weekIndex) => {
                  return import_react152.default.createElement(
                    components.Week,
                    { className: classNames[UI2.Week], key: week.weekNumber, style: styles3?.[UI2.Week], week },
                    showWeekNumber && import_react152.default.createElement(components.WeekNumber, { week, style: styles3?.[UI2.WeekNumber], "aria-label": labelWeekNumber2(week.weekNumber, {
                      locale
                    }), className: classNames[UI2.WeekNumber], scope: "row", role: "rowheader" }, formatWeekNumber2(week.weekNumber, dateLib)),
                    week.days.map((day) => {
                      const { date } = day;
                      const modifiers = getModifiers(day);
                      modifiers[DayFlag.focused] = !modifiers.hidden && Boolean(focused?.isEqualTo(day));
                      modifiers[SelectionState.selected] = isSelected2?.(date) || modifiers.selected;
                      if (isDateRange(selectedValue)) {
                        const { from: from2, to } = selectedValue;
                        modifiers[SelectionState.range_start] = Boolean(from2 && to && dateLib.isSameDay(date, from2));
                        modifiers[SelectionState.range_end] = Boolean(from2 && to && dateLib.isSameDay(date, to));
                        modifiers[SelectionState.range_middle] = rangeIncludesDate(selectedValue, date, true, dateLib);
                      }
                      const style3 = getStyleForModifiers(modifiers, styles3, props.modifiersStyles);
                      const className3 = getClassNamesForModifiers(modifiers, classNames, props.modifiersClassNames);
                      const ariaLabel = !isInteractive && !modifiers.hidden ? labelGridcell2(date, modifiers, dateLib.options, dateLib) : void 0;
                      return import_react152.default.createElement(components.Day, { key: `${dateLib.format(date, "yyyy-MM-dd")}_${dateLib.format(day.displayMonth, "yyyy-MM")}`, day, modifiers, className: className3.join(" "), style: style3, role: "gridcell", "aria-selected": modifiers.selected || void 0, "aria-label": ariaLabel, "data-day": dateLib.format(date, "yyyy-MM-dd"), "data-month": day.outside ? dateLib.format(date, "yyyy-MM") : void 0, "data-selected": modifiers.selected || void 0, "data-disabled": modifiers.disabled || void 0, "data-hidden": modifiers.hidden || void 0, "data-outside": day.outside || void 0, "data-focused": modifiers.focused || void 0, "data-today": modifiers.today || void 0 }, !modifiers.hidden && isInteractive ? import_react152.default.createElement(components.DayButton, { className: classNames[UI2.DayButton], style: styles3?.[UI2.DayButton], type: "button", day, modifiers, disabled: modifiers.disabled || void 0, tabIndex: isFocusTarget(day) ? 0 : -1, "aria-label": labelDayButton2(date, modifiers, dateLib.options, dateLib), onClick: handleDayClick(day, modifiers), onBlur: handleDayBlur(day, modifiers), onFocus: handleDayFocus(day, modifiers), onKeyDown: handleDayKeyDown(day, modifiers), onMouseEnter: handleDayMouseEnter(day, modifiers), onMouseLeave: handleDayMouseLeave(day, modifiers) }, formatDay2(date, dateLib.options, dateLib)) : !modifiers.hidden && formatDay2(day.date, dateLib.options, dateLib));
                    })
                  );
                }))
              )
            );
          })
        ),
        props.footer && import_react152.default.createElement(components.Footer, { className: classNames[UI2.Footer], style: styles3?.[UI2.Footer], role: "status", "aria-live": "polite" }, props.footer)
      )
    );
  }

  // packages/components/build-module/calendar/date-calendar/index.mjs
  var import_element228 = __toESM(require_element(), 1);

  // packages/components/build-module/calendar/utils/day-cell.mjs
  var import_jsx_runtime308 = __toESM(require_jsx_runtime(), 1);
  var PreviewDashStartAndEnd = () => {
    return /* @__PURE__ */ (0, import_jsx_runtime308.jsx)("svg", {
      viewBox: "0 0 32 32",
      xmlns: "http://www.w3.org/2000/svg",
      fill: "none",
      stroke: "currentColor",
      strokeDasharray: "3.7677",
      strokeDashoffset: "3.2",
      strokeWidth: "1",
      children: /* @__PURE__ */ (0, import_jsx_runtime308.jsx)("path", {
        d: "M29.5,0.5 h-27 a2,2 0 0 0 -2,2 v27 a2,2 0 0 0 2,2 h27 a2,2 0 0 0 2,-2 v-27 a2,2 0 0 0 -2,-2"
      })
    });
  };
  var PreviewDashStart = () => {
    return /* @__PURE__ */ (0, import_jsx_runtime308.jsx)("svg", {
      viewBox: "0 0 32 32",
      xmlns: "http://www.w3.org/2000/svg",
      fill: "none",
      stroke: "currentColor",
      strokeDasharray: "3.84516",
      strokeDashoffset: "1.9226",
      strokeWidth: "1",
      children: /* @__PURE__ */ (0, import_jsx_runtime308.jsx)("path", {
        d: "M32,0.5 h-29.5 a2,2 0 0 0 -2,2 v27 a2,2 0 0 0 2,2 h30"
      })
    });
  };
  var PreviewDashMiddle = () => {
    return /* @__PURE__ */ (0, import_jsx_runtime308.jsxs)("svg", {
      viewBox: "0 0 32 32",
      xmlns: "http://www.w3.org/2000/svg",
      fill: "none",
      stroke: "currentColor",
      strokeDasharray: "3.9 4",
      strokeDashoffset: "2",
      strokeWidth: "1",
      children: [/* @__PURE__ */ (0, import_jsx_runtime308.jsx)("line", {
        x1: "0",
        y1: "0.5",
        x2: "100",
        y2: "0.5"
      }), /* @__PURE__ */ (0, import_jsx_runtime308.jsx)("line", {
        x1: "0",
        y1: "31.5",
        x2: "100",
        y2: "31.5"
      })]
    });
  };
  var PreviewDashEnd = () => {
    return /* @__PURE__ */ (0, import_jsx_runtime308.jsx)("svg", {
      viewBox: "0 0 32 32",
      xmlns: "http://www.w3.org/2000/svg",
      fill: "none",
      stroke: "currentColor",
      strokeDasharray: "3.84516",
      strokeDashoffset: "1.9226",
      strokeWidth: "1",
      children: /* @__PURE__ */ (0, import_jsx_runtime308.jsx)("path", {
        d: "M0,0.5 h29.5 a2,2 0 0 1 2,2 v27 a2,2 0 0 1 -2,2 h-29.5"
      })
    });
  };
  function Day4(props) {
    const {
      day,
      modifiers,
      children,
      ...tdProps
    } = props;
    let PreviewDash;
    if (modifiers.preview_start && modifiers.preview_end) {
      PreviewDash = PreviewDashStartAndEnd;
    } else if (modifiers.preview_start) {
      PreviewDash = PreviewDashStart;
    } else if (modifiers.preview_end) {
      PreviewDash = PreviewDashEnd;
    } else if (modifiers.preview) {
      PreviewDash = PreviewDashMiddle;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime308.jsxs)("td", {
      ...tdProps,
      children: [PreviewDash && /* @__PURE__ */ (0, import_jsx_runtime308.jsx)(PreviewDash, {}), children]
    });
  }

  // packages/components/build-module/calendar/utils/constants.mjs
  var CLASSNAMES = {
    root: "components-calendar",
    day: "components-calendar__day",
    day_button: "components-calendar__day-button",
    outside: "components-calendar__day--outside",
    caption_label: "components-calendar__caption-label",
    button_next: "components-calendar__button-next",
    button_previous: "components-calendar__button-previous",
    chevron: "components-calendar__chevron",
    nav: "components-calendar__nav",
    month_caption: "components-calendar__month-caption",
    months: "components-calendar__months",
    month_grid: "components-calendar__month-grid",
    weekday: "components-calendar__weekday",
    today: "components-calendar__day--today",
    selected: "components-calendar__day--selected",
    disabled: "components-calendar__day--disabled",
    hidden: "components-calendar__day--hidden",
    range_start: "components-calendar__range-start",
    range_end: "components-calendar__range-end",
    range_middle: "components-calendar__range-middle",
    weeks_before_enter: "components-calendar__weeks-before-enter",
    weeks_before_exit: "components-calendar__weeks-before-exit",
    weeks_after_enter: "components-calendar__weeks-after-enter",
    weeks_after_exit: "components-calendar__weeks-after-exit",
    caption_after_enter: "components-calendar__caption-after-enter",
    caption_after_exit: "components-calendar__caption-after-exit",
    caption_before_enter: "components-calendar__caption-before-enter",
    caption_before_exit: "components-calendar__caption-before-exit"
  };
  var MODIFIER_CLASSNAMES = {
    preview: "components-calendar__day--preview",
    preview_start: "components-calendar__day--preview-start",
    preview_end: "components-calendar__day--preview-end"
  };
  var COMMON_PROPS = {
    animate: true,
    // Only show days in the current month
    showOutsideDays: false,
    // Hide week number column
    showWeekNumber: false,
    // Show weekdays row
    hideWeekdays: false,
    // Month and year caption are not interactive
    captionLayout: "label",
    // Show a variable number of weeks depending on the month
    fixedWeeks: false,
    // Show navigation buttons
    hideNavigation: false,
    // Class names
    classNames: CLASSNAMES,
    // Default role
    role: "application",
    components: {
      Day: Day4
    }
  };

  // packages/components/build-module/calendar/utils/misc.mjs
  function clampNumberOfMonths(numberOfMonths) {
    return Math.min(3, Math.max(1, numberOfMonths));
  }

  // packages/components/build-module/calendar/utils/use-localization-props.mjs
  var import_i18n74 = __toESM(require_i18n(), 1);
  var import_element227 = __toESM(require_element(), 1);
  function isLocaleRTL(localeCode) {
    const localeObj = new Intl.Locale(localeCode);
    const direction = localeObj.getTextInfo?.().direction;
    if (direction) {
      return direction === "rtl";
    }
    return [
      "ar",
      // Arabic
      "he",
      // Hebrew
      "fa",
      // Persian (Farsi)
      "ur",
      // Urdu
      "ps",
      // Pashto
      "syr",
      // Syriac
      "dv",
      // Divehi
      "ku",
      // Kurdish (Sorani)
      "yi"
      // Yiddish
    ].includes(localeObj.language);
  }
  var useLocalizationProps = ({
    locale,
    timeZone,
    mode: mode2
  }) => {
    return (0, import_element227.useMemo)(() => {
      const monthNameFormatter = new Intl.DateTimeFormat(locale.code, {
        year: "numeric",
        month: "long",
        timeZone
      });
      const weekdayNarrowFormatter = new Intl.DateTimeFormat(locale.code, {
        weekday: "narrow",
        timeZone
      });
      const weekdayLongFormatter = new Intl.DateTimeFormat(locale.code, {
        weekday: "long",
        timeZone
      });
      const fullDateFormatter = new Intl.DateTimeFormat(locale.code, {
        weekday: "long",
        year: "numeric",
        month: "long",
        day: "numeric",
        timeZone
      });
      return {
        "aria-label": mode2 === "single" ? (0, import_i18n74.__)("Date calendar") : (0, import_i18n74.__)("Date range calendar"),
        labels: {
          /**
           * The label for the month grid.
           * @param date
           */
          labelGrid: (date) => monthNameFormatter.format(date),
          /**
           * The label for the gridcell, when the calendar is not interactive.
           * @param date
           * @param modifiers
           */
          labelGridcell: (date, modifiers) => {
            const formattedDate = fullDateFormatter.format(date);
            let label = formattedDate;
            if (modifiers?.today) {
              label = (0, import_i18n74.sprintf)(
                // translators: %s is the full date (e.g. "Monday, April 29, 2025")
                (0, import_i18n74.__)("Today, %s"),
                formattedDate
              );
            }
            return label;
          },
          /** The label for the "next month" button. */
          labelNext: () => (0, import_i18n74.__)("Go to the Next Month"),
          /** The label for the "previous month" button. */
          labelPrevious: () => (0, import_i18n74.__)("Go to the Previous Month"),
          /**
           * The label for the day button.
           * @param date
           * @param modifiers
           */
          labelDayButton: (date, modifiers) => {
            const formattedDate = fullDateFormatter.format(date);
            let label = formattedDate;
            if (modifiers?.today) {
              label = (0, import_i18n74.sprintf)(
                // translators: %s is the full date (e.g. "Monday, April 29, 2025")
                (0, import_i18n74.__)("Today, %s"),
                formattedDate
              );
            }
            if (modifiers?.selected) {
              label = (0, import_i18n74.sprintf)(
                // translators: %s is the full date (e.g. "Monday, April 29, 2025")
                (0, import_i18n74.__)("%s, selected"),
                formattedDate
              );
            }
            return label;
          },
          /**
           * The label for the weekday.
           * @param date
           */
          labelWeekday: (date) => weekdayLongFormatter.format(date)
        },
        locale,
        dir: isLocaleRTL(locale.code) ? "rtl" : "ltr",
        formatters: {
          formatWeekdayName: (date) => {
            return weekdayNarrowFormatter.format(date);
          },
          formatCaption: (date) => {
            return monthNameFormatter.format(date);
          }
        },
        timeZone
      };
    }, [locale, timeZone, mode2]);
  };

  // packages/components/build-module/calendar/date-calendar/index.mjs
  var import_jsx_runtime309 = __toESM(require_jsx_runtime(), 1);
  var DateCalendar = ({
    defaultSelected,
    selected: selectedProp,
    onSelect,
    numberOfMonths = 1,
    locale = enUS,
    timeZone,
    ...props
  }) => {
    const localizationProps = useLocalizationProps({
      locale,
      timeZone,
      mode: "single"
    });
    const onChange = (0, import_element228.useCallback)((selected2, triggerDate, modifiers, e3) => {
      onSelect?.(selected2 ?? void 0, triggerDate, modifiers, e3);
    }, [onSelect]);
    const [selected, setSelected] = useControlledValue({
      defaultValue: defaultSelected,
      value: selectedProp,
      onChange
    });
    return /* @__PURE__ */ (0, import_jsx_runtime309.jsx)(DayPicker, {
      ...COMMON_PROPS,
      ...localizationProps,
      ...props,
      mode: "single",
      numberOfMonths: clampNumberOfMonths(numberOfMonths),
      selected: selected ?? void 0,
      onSelect: setSelected
    });
  };

  // packages/components/build-module/calendar/date-range-calendar/index.mjs
  var import_element229 = __toESM(require_element(), 1);
  var import_jsx_runtime310 = __toESM(require_jsx_runtime(), 1);
  function usePreviewRange({
    selected,
    hoveredDate,
    excludeDisabled,
    min: min3,
    max: max3,
    disabled
  }) {
    return (0, import_element229.useMemo)(() => {
      if (!hoveredDate || !selected?.from) {
        return;
      }
      let previewHighlight;
      let potentialNewRange;
      if (hoveredDate < selected.from) {
        previewHighlight = {
          from: hoveredDate,
          to: selected.from
        };
        potentialNewRange = {
          from: hoveredDate,
          to: selected.to ?? selected.from
        };
      } else if (selected.to && hoveredDate > selected.from && hoveredDate < selected.to) {
        previewHighlight = {
          from: selected.from,
          to: hoveredDate
        };
        potentialNewRange = {
          from: selected.from,
          to: hoveredDate
        };
      } else if (hoveredDate > selected.from) {
        previewHighlight = {
          from: selected.to ?? selected.from,
          to: hoveredDate
        };
        potentialNewRange = {
          from: selected.from,
          to: hoveredDate
        };
      }
      if (min3 !== void 0 && min3 > 0 && potentialNewRange && differenceInCalendarDays(potentialNewRange.to, potentialNewRange.from) < min3) {
        previewHighlight = {
          from: hoveredDate,
          to: hoveredDate
        };
      }
      if (max3 !== void 0 && max3 > 0 && potentialNewRange && differenceInCalendarDays(potentialNewRange.to, potentialNewRange.from) > max3) {
        previewHighlight = {
          from: hoveredDate,
          to: hoveredDate
        };
      }
      if (excludeDisabled && disabled && potentialNewRange && rangeContainsModifiers(potentialNewRange, disabled)) {
        previewHighlight = {
          from: hoveredDate,
          to: hoveredDate
        };
      }
      return previewHighlight;
    }, [selected, hoveredDate, excludeDisabled, min3, max3, disabled]);
  }
  var DateRangeCalendar = ({
    defaultSelected,
    selected: selectedProp,
    onSelect,
    numberOfMonths = 1,
    excludeDisabled,
    min: min3,
    max: max3,
    disabled,
    locale = enUS,
    timeZone,
    ...props
  }) => {
    const localizationProps = useLocalizationProps({
      locale,
      timeZone,
      mode: "range"
    });
    const onChange = (0, import_element229.useCallback)((selected2, triggerDate, modifiers2, e3) => {
      onSelect?.(selected2 ?? void 0, triggerDate, modifiers2, e3);
    }, [onSelect]);
    const [selected, setSelected] = useControlledValue({
      defaultValue: defaultSelected,
      value: selectedProp,
      onChange
    });
    const [hoveredDate, setHoveredDate] = (0, import_element229.useState)(void 0);
    const previewRange = usePreviewRange({
      selected,
      hoveredDate,
      excludeDisabled,
      min: min3,
      max: max3,
      disabled
    });
    const modifiers = (0, import_element229.useMemo)(() => {
      return {
        preview: previewRange,
        preview_start: previewRange?.from,
        preview_end: previewRange?.to
      };
    }, [previewRange]);
    return /* @__PURE__ */ (0, import_jsx_runtime310.jsx)(DayPicker, {
      ...COMMON_PROPS,
      ...localizationProps,
      ...props,
      mode: "range",
      numberOfMonths: clampNumberOfMonths(numberOfMonths),
      disabled,
      excludeDisabled,
      min: min3,
      max: max3,
      selected: selected ?? void 0,
      onSelect: setSelected,
      onDayMouseEnter: (date) => setHoveredDate(date),
      onDayMouseLeave: () => setHoveredDate(void 0),
      modifiers,
      modifiersClassNames: MODIFIER_CLASSNAMES
    });
  };

  // packages/components/build-module/validated-form-controls/components/checkbox-control.mjs
  var import_compose86 = __toESM(require_compose(), 1);
  var import_element231 = __toESM(require_element(), 1);

  // packages/components/build-module/validated-form-controls/control-with-error.mjs
  var import_i18n75 = __toESM(require_i18n(), 1);
  var import_element230 = __toESM(require_element(), 1);

  // packages/components/build-module/validated-form-controls/validity-indicator.mjs
  var import_jsx_runtime311 = __toESM(require_jsx_runtime(), 1);
  function ValidityIndicator({
    id: id3,
    type,
    message: message2
  }) {
    const ICON = {
      valid: published_default,
      invalid: error_default
    };
    return /* @__PURE__ */ (0, import_jsx_runtime311.jsxs)("p", {
      id: id3,
      className: clsx_default("components-validated-control__indicator", `is-${type}`),
      children: [type === "validating" ? /* @__PURE__ */ (0, import_jsx_runtime311.jsx)(spinner_default, {
        className: "components-validated-control__indicator-spinner"
      }) : /* @__PURE__ */ (0, import_jsx_runtime311.jsx)(icon_default3, {
        className: "components-validated-control__indicator-icon",
        icon: ICON[type],
        size: 16,
        fill: "currentColor"
      }), message2]
    });
  }

  // packages/components/build-module/validated-form-controls/control-with-error.mjs
  var import_jsx_runtime312 = __toESM(require_jsx_runtime(), 1);
  function appendRequiredIndicator(label, required, markWhenOptional) {
    let suffix;
    if (required && !markWhenOptional) {
      suffix = `(${(0, import_i18n75.__)("Required")})`;
    } else if (!required && markWhenOptional) {
      suffix = `(${(0, import_i18n75.__)("Optional")})`;
    }
    if (!suffix) {
      return label;
    }
    if (typeof label === "string") {
      return `${label} ${suffix}`;
    }
    return /* @__PURE__ */ (0, import_jsx_runtime312.jsxs)(import_jsx_runtime312.Fragment, {
      children: [label, " ", suffix]
    });
  }
  var VALIDITY_VISIBLE_ATTRIBUTE = "data-validity-visible";
  var className = "components-validated-control";
  function UnforwardedControlWithError({
    required,
    markWhenOptional,
    customValidity,
    getValidityTarget,
    children
  }, forwardedRef) {
    const [errorMessage, setErrorMessage] = (0, import_element230.useState)();
    const [statusMessage, setStatusMessage] = (0, import_element230.useState)();
    const [showMessage, setShowMessage] = (0, import_element230.useState)(false);
    const [isTouched, setIsTouched] = (0, import_element230.useState)(false);
    (0, import_element230.useEffect)(() => {
      const validityTarget = getValidityTarget();
      const handler = () => {
        setShowMessage(true);
        validityTarget?.setAttribute(VALIDITY_VISIBLE_ATTRIBUTE, "");
      };
      validityTarget?.addEventListener("invalid", handler);
      return () => validityTarget?.removeEventListener("invalid", handler);
    }, [getValidityTarget]);
    (0, import_element230.useEffect)(() => {
      const validityTarget = getValidityTarget();
      const suppressNativePopover = (event) => {
        event.preventDefault();
        const target = event.target;
        const firstErrorInForm = Array.from(target.form?.elements ?? []).find((el) => !el.validity.valid);
        if (!target.form || firstErrorInForm === target) {
          target.focus();
        }
      };
      const radioSibilings = validityTarget?.type === "radio" && validityTarget?.name ? Array.from(validityTarget?.closest(`.${className}`)?.querySelectorAll(`input[type="radio"][name="${validityTarget?.name}"]`) ?? []).filter((sibling) => sibling !== validityTarget) : [];
      validityTarget?.addEventListener("invalid", suppressNativePopover);
      radioSibilings.forEach((sibling) => sibling.addEventListener("invalid", suppressNativePopover));
      return () => {
        validityTarget?.removeEventListener("invalid", suppressNativePopover);
        radioSibilings.forEach((sibling) => sibling.removeEventListener("invalid", suppressNativePopover));
      };
    }, [getValidityTarget]);
    (0, import_element230.useEffect)(() => {
      const validityTarget = getValidityTarget();
      if (!customValidity?.type) {
        validityTarget?.setCustomValidity("");
        setErrorMessage(validityTarget?.validationMessage);
        setStatusMessage(void 0);
        return;
      }
      switch (customValidity.type) {
        case "validating": {
          validityTarget?.setCustomValidity("");
          setErrorMessage(void 0);
          setStatusMessage({
            type: "validating",
            message: customValidity.message
          });
          break;
        }
        case "valid": {
          validityTarget?.setCustomValidity("");
          setErrorMessage(validityTarget?.validationMessage);
          setStatusMessage({
            type: "valid",
            message: customValidity.message
          });
          break;
        }
        case "invalid": {
          validityTarget?.setCustomValidity(customValidity.message ?? "");
          setErrorMessage(validityTarget?.validationMessage);
          setStatusMessage(void 0);
          break;
        }
      }
    }, [customValidity, getValidityTarget]);
    (0, import_element230.useEffect)(() => {
      if (!isTouched || showMessage) {
        return;
      }
      if (customValidity?.type === "validating") {
        const timer = setTimeout(() => {
          setShowMessage(true);
        }, 1e3);
        return () => clearTimeout(timer);
      }
      setShowMessage(true);
    }, [isTouched, customValidity?.type, showMessage]);
    const onBlur = (event) => {
      if (isTouched) {
        return;
      }
      if (!event.relatedTarget || !event.currentTarget.contains(event.relatedTarget)) {
        setIsTouched(true);
        getValidityTarget()?.setAttribute(VALIDITY_VISIBLE_ATTRIBUTE, "");
      }
    };
    const messageId = (0, import_element230.useId)();
    const message2 = (() => {
      if (errorMessage) {
        return /* @__PURE__ */ (0, import_jsx_runtime312.jsx)(ValidityIndicator, {
          id: messageId,
          type: "invalid",
          message: errorMessage
        });
      }
      if (statusMessage?.type) {
        return /* @__PURE__ */ (0, import_jsx_runtime312.jsx)(ValidityIndicator, {
          id: messageId,
          type: statusMessage.type,
          message: statusMessage.message
        });
      }
      return null;
    })();
    const visibleMessage = showMessage ? message2 : null;
    (0, import_element230.useEffect)(() => {
      const target = getValidityTarget();
      if (!target) {
        return;
      }
      function setDescribedBy(el, shouldAdd) {
        const ids = (el.getAttribute("aria-describedby") ?? "").split(" ").filter((id3) => id3 && id3 !== messageId);
        if (shouldAdd) {
          ids.push(messageId);
        }
        if (ids.length) {
          el.setAttribute("aria-describedby", ids.join(" "));
        } else {
          el.removeAttribute("aria-describedby");
        }
      }
      setDescribedBy(target, !!visibleMessage);
      return () => setDescribedBy(target, false);
    }, [visibleMessage, messageId, getValidityTarget]);
    return /* @__PURE__ */ (0, import_jsx_runtime312.jsxs)("div", {
      className,
      ref: forwardedRef,
      onBlur,
      children: [(0, import_element230.cloneElement)(children, {
        label: appendRequiredIndicator(children.props.label, required, markWhenOptional),
        required
      }), visibleMessage]
    });
  }
  var ControlWithError = (0, import_element230.forwardRef)(UnforwardedControlWithError);
  ControlWithError.displayName = "ControlWithError";

  // packages/components/build-module/validated-form-controls/components/checkbox-control.mjs
  var import_jsx_runtime313 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedCheckboxControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element231.useRef)(null);
    const mergedRefs = (0, import_compose86.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime313.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      ref: mergedRefs,
      customValidity,
      getValidityTarget: () => validityTargetRef.current?.querySelector('input[type="checkbox"]'),
      children: /* @__PURE__ */ (0, import_jsx_runtime313.jsx)(
        checkbox_control_default,
        {
          ...restProps
        }
      )
    });
  };
  var ValidatedCheckboxControl = (0, import_element231.forwardRef)(UnforwardedValidatedCheckboxControl);
  ValidatedCheckboxControl.displayName = "ValidatedCheckboxControl";

  // packages/components/build-module/validated-form-controls/components/combobox-control.mjs
  var import_compose87 = __toESM(require_compose(), 1);
  var import_element232 = __toESM(require_element(), 1);
  var import_jsx_runtime314 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedComboboxControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element232.useRef)(null);
    const mergedRefs = (0, import_compose87.useMergeRefs)([forwardedRef, validityTargetRef]);
    (0, import_element232.useEffect)(() => {
      const input = validityTargetRef.current?.querySelector('input[role="combobox"]');
      if (input) {
        input.required = required ?? false;
      }
    }, [required]);
    return (
      // TODO: Bug - Missing value error is not cleared immediately on change, waits for blur.
      /* @__PURE__ */ (0, import_jsx_runtime314.jsx)(ControlWithError, {
        required,
        markWhenOptional,
        ref: mergedRefs,
        customValidity,
        getValidityTarget: () => validityTargetRef.current?.querySelector('input[role="combobox"]'),
        children: /* @__PURE__ */ (0, import_jsx_runtime314.jsx)(combobox_control_default, {
          ...restProps
        })
      })
    );
  };
  var ValidatedComboboxControl = (0, import_element232.forwardRef)(UnforwardedValidatedComboboxControl);
  ValidatedComboboxControl.displayName = "ValidatedComboboxControl";

  // packages/components/build-module/validated-form-controls/components/form-token-field.mjs
  var import_element233 = __toESM(require_element(), 1);
  var import_jsx_runtime315 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedFormTokenField = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element233.useRef)(null);
    return /* @__PURE__ */ (0, import_jsx_runtime315.jsxs)("div", {
      className: "components-validated-control__wrapper-with-error-delegate",
      ref: forwardedRef,
      children: [/* @__PURE__ */ (0, import_jsx_runtime315.jsx)(ControlWithError, {
        required,
        markWhenOptional,
        customValidity,
        getValidityTarget: () => validityTargetRef.current,
        children: /* @__PURE__ */ (0, import_jsx_runtime315.jsx)(FormTokenField, {
          ...restProps
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime315.jsx)("input", {
        className: "components-validated-control__error-delegate",
        type: "text",
        ref: validityTargetRef,
        required,
        value: restProps.value && restProps.value.length > 0 ? "hasvalue" : "",
        tabIndex: -1,
        onChange: () => {
        },
        onFocus: (e3) => {
          e3.target.previousElementSibling?.querySelector('input[type="text"]')?.focus();
        }
      })]
    });
  };
  var ValidatedFormTokenField = (0, import_element233.forwardRef)(UnforwardedValidatedFormTokenField);
  ValidatedFormTokenField.displayName = "ValidatedFormTokenField";

  // packages/components/build-module/validated-form-controls/components/input-control.mjs
  var import_element234 = __toESM(require_element(), 1);
  var import_compose88 = __toESM(require_compose(), 1);
  var import_jsx_runtime316 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedInputControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element234.useRef)(null);
    const mergedRefs = (0, import_compose88.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime316.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      customValidity,
      getValidityTarget: () => validityTargetRef.current,
      children: /* @__PURE__ */ (0, import_jsx_runtime316.jsx)(input_control_default, {
        ref: mergedRefs,
        ...restProps
      })
    });
  };
  var ValidatedInputControl = (0, import_element234.forwardRef)(UnforwardedValidatedInputControl);
  ValidatedInputControl.displayName = "ValidatedInputControl";

  // packages/components/build-module/validated-form-controls/components/number-control.mjs
  var import_element235 = __toESM(require_element(), 1);
  var import_compose89 = __toESM(require_compose(), 1);
  var import_jsx_runtime317 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedNumberControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element235.useRef)(null);
    const mergedRefs = (0, import_compose89.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime317.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      customValidity,
      getValidityTarget: () => validityTargetRef.current,
      children: /* @__PURE__ */ (0, import_jsx_runtime317.jsx)(number_control_default, {
        ref: mergedRefs,
        ...restProps
      })
    });
  };
  var ValidatedNumberControl = (0, import_element235.forwardRef)(UnforwardedValidatedNumberControl);
  ValidatedNumberControl.displayName = "ValidatedNumberControl";

  // packages/components/build-module/validated-form-controls/components/radio-control.mjs
  var import_compose90 = __toESM(require_compose(), 1);
  var import_element236 = __toESM(require_element(), 1);
  var import_jsx_runtime318 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedRadioControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element236.useRef)(null);
    const mergedRefs = (0, import_compose90.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime318.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      ref: mergedRefs,
      customValidity,
      getValidityTarget: () => validityTargetRef.current?.querySelector('input[type="radio"]'),
      children: /* @__PURE__ */ (0, import_jsx_runtime318.jsx)(radio_control_default, {
        ...restProps
      })
    });
  };
  var ValidatedRadioControl = (0, import_element236.forwardRef)(UnforwardedValidatedRadioControl);
  ValidatedRadioControl.displayName = "ValidatedRadioControl";

  // packages/components/build-module/validated-form-controls/components/content-editable-control.mjs
  var import_element238 = __toESM(require_element(), 1);

  // packages/components/build-module/content-editable-control/index.mjs
  var import_compose91 = __toESM(require_compose(), 1);
  var import_element237 = __toESM(require_element(), 1);
  var import_jsx_runtime319 = __toESM(require_jsx_runtime(), 1);
  var STYLE_HASH_ATTRIBUTE18 = "data-wp-hash";
  function getRuntime18() {
    const globalScope = globalThis;
    if (globalScope.__wpStyleRuntime) {
      return globalScope.__wpStyleRuntime;
    }
    globalScope.__wpStyleRuntime = {
      documents: /* @__PURE__ */ new Map(),
      styles: /* @__PURE__ */ new Map(),
      injectedStyles: /* @__PURE__ */ new WeakMap()
    };
    if (typeof document !== "undefined") {
      registerDocument18(document);
    }
    return globalScope.__wpStyleRuntime;
  }
  function documentContainsStyleHash18(targetDocument, hash2) {
    if (!targetDocument.head) {
      return false;
    }
    for (const style2 of targetDocument.head.querySelectorAll(`style[${STYLE_HASH_ATTRIBUTE18}]`)) {
      if (style2.getAttribute(STYLE_HASH_ATTRIBUTE18) === hash2) {
        return true;
      }
    }
    return false;
  }
  function injectStyle18(targetDocument, hash2, css3) {
    if (!targetDocument.head) {
      return;
    }
    const runtime = getRuntime18();
    let injectedStyles = runtime.injectedStyles.get(targetDocument);
    if (!injectedStyles) {
      injectedStyles = /* @__PURE__ */ new Set();
      runtime.injectedStyles.set(targetDocument, injectedStyles);
    }
    if (injectedStyles.has(hash2)) {
      return;
    }
    if (documentContainsStyleHash18(targetDocument, hash2)) {
      injectedStyles.add(hash2);
      return;
    }
    const style2 = targetDocument.createElement("style");
    style2.setAttribute(STYLE_HASH_ATTRIBUTE18, hash2);
    style2.appendChild(targetDocument.createTextNode(css3));
    targetDocument.head.appendChild(style2);
    injectedStyles.add(hash2);
  }
  function registerDocument18(targetDocument) {
    const runtime = getRuntime18();
    runtime.documents.set(targetDocument, (runtime.documents.get(targetDocument) ?? 0) + 1);
    for (const [hash2, css3] of runtime.styles) {
      injectStyle18(targetDocument, hash2, css3);
    }
    return () => {
      const count = runtime.documents.get(targetDocument);
      if (count === void 0) {
        return;
      }
      if (count <= 1) {
        runtime.documents.delete(targetDocument);
        return;
      }
      runtime.documents.set(targetDocument, count - 1);
    };
  }
  function registerStyle17(hash2, css3) {
    const runtime = getRuntime18();
    runtime.styles.set(hash2, css3);
    for (const targetDocument of runtime.documents.keys()) {
      injectStyle18(targetDocument, hash2, css3);
    }
  }
  if (typeof process === "undefined" || true) {
    registerStyle17("88387972b5", "._0f130cee1a924516__editable{background:var(--wp-components-color-background,var(--wpds-color-background-surface-neutral-strong,#fff));border:1px solid #949494;border-radius:2px;box-shadow:0 0 0 transparent;color:var(--wp-components-color-foreground,var(--wpds-color-foreground-content-neutral,#1e1e1e));font-family:-apple-system,system-ui,Segoe UI,Roboto,Oxygen-Sans,Ubuntu,Cantarell,Helvetica Neue,sans-serif;font-size:16px;line-height:normal;padding:6px 8px;width:100%}@media not (prefers-reduced-motion){._0f130cee1a924516__editable{transition:box-shadow .1s linear}}@media (min-width:600px){._0f130cee1a924516__editable{font-size:13px;line-height:normal}}._0f130cee1a924516__editable:focus{border-color:var(--wp-components-color-accent,var(--wp-admin-theme-color,#3858e9));box-shadow:0 0 0 .5px var(--wp-components-color-accent,var(--wp-admin-theme-color,#3858e9));outline:2px solid transparent}._0f130cee1a924516__editable::placeholder{color:rgba(30,30,30,.62)}._0f130cee1a924516__editable{border-color:var(--wp-components-color-gray-600,var(--wpds-color-stroke-interactive-neutral,#8d8d8d))}._0f130cee1a924516__editable[aria-placeholder]:empty:before{color:color-mix(in srgb,var(--wp-components-color-foreground,var(--wpds-color-foreground-content-neutral,#1e1e1e)),transparent 38%);content:attr(aria-placeholder)}._0f130cee1a924516__editable{min-height:40px;padding:12px}._0f130cee1a924516__editable[aria-disabled=true]{background:var(--wp-components-color-gray-100,var(--wpds-color-background-surface-neutral,#fcfcfc));border-color:var(--wp-components-color-gray-300,var(--wpds-color-stroke-surface-neutral,#dbdbdb));color:var(--wp-components-color-gray-700,var(--wpds-color-foreground-content-neutral-weak,#707070));cursor:default}");
  }
  var style_module_default16 = { "editable": "_0f130cee1a924516__editable" };
  function UnforwardedContentEditableControl({
    label,
    id: id3,
    className: className2,
    help,
    hideLabelFromVision,
    disabled,
    required,
    placeholder,
    ...additionalProps
  }, forwardedRef) {
    const {
      baseControlProps,
      controlProps
    } = useBaseControlProps({
      id: id3,
      className: className2,
      help
    });
    const labelId = `${controlProps.id}__label`;
    const editableRef = (0, import_element237.useRef)(null);
    const mergedRefs = (0, import_compose91.useMergeRefs)([editableRef, forwardedRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime319.jsxs)(base_control_default, {
      ...baseControlProps,
      children: [hideLabelFromVision ? /* @__PURE__ */ (0, import_jsx_runtime319.jsx)(component_default2, {
        id: labelId,
        children: label
      }) : /* @__PURE__ */ (0, import_jsx_runtime319.jsx)(base_control_default.VisualLabel, {
        id: labelId,
        onClick: () => editableRef.current?.focus(),
        children: label
      }), /* @__PURE__ */ (0, import_jsx_runtime319.jsx)("div", {
        className: style_module_default16.editable,
        role: "textbox",
        "aria-multiline": true,
        "aria-labelledby": labelId,
        "aria-placeholder": placeholder || void 0,
        "aria-disabled": disabled || void 0,
        "aria-required": required || void 0,
        ref: mergedRefs,
        contentEditable: !disabled,
        suppressContentEditableWarning: true,
        ...additionalProps,
        ...controlProps
      })]
    });
  }
  var ContentEditableControl = (0, import_element237.forwardRef)(UnforwardedContentEditableControl);
  var content_editable_control_default = ContentEditableControl;

  // packages/components/build-module/validated-form-controls/components/content-editable-control.mjs
  var import_jsx_runtime320 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedContentEditableControl = ({
    required,
    customValidity,
    markWhenOptional,
    value,
    className: className2,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element238.useRef)(null);
    return /* @__PURE__ */ (0, import_jsx_runtime320.jsxs)("div", {
      className: "components-validated-control__wrapper-with-error-delegate",
      children: [/* @__PURE__ */ (0, import_jsx_runtime320.jsx)(ControlWithError, {
        required,
        markWhenOptional,
        customValidity,
        getValidityTarget: () => validityTargetRef.current,
        children: /* @__PURE__ */ (0, import_jsx_runtime320.jsx)(content_editable_control_default, {
          ref: forwardedRef,
          className: clsx_default("components-validated-control__content-editable", className2),
          "aria-invalid": customValidity?.type === "invalid" || void 0,
          ...restProps
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime320.jsx)("input", {
        className: "components-validated-control__error-delegate",
        type: "text",
        ref: validityTargetRef,
        required,
        value: value?.trim() ?? "",
        tabIndex: -1,
        onChange: () => {
        },
        onFocus: (e3) => {
          e3.target.previousElementSibling?.querySelector('[role="textbox"]')?.focus();
        }
      })]
    });
  };
  var ValidatedContentEditableControl = (0, import_element238.forwardRef)(UnforwardedValidatedContentEditableControl);
  ValidatedContentEditableControl.displayName = "ValidatedContentEditableControl";

  // packages/components/build-module/validated-form-controls/components/select-control.mjs
  var import_element239 = __toESM(require_element(), 1);
  var import_compose92 = __toESM(require_compose(), 1);
  var import_jsx_runtime321 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedSelectControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element239.useRef)(null);
    const mergedRefs = (0, import_compose92.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime321.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      customValidity,
      getValidityTarget: () => validityTargetRef.current,
      children: /* @__PURE__ */ (0, import_jsx_runtime321.jsx)(select_control_default, {
        ref: mergedRefs,
        ...restProps
      })
    });
  };
  var ValidatedSelectControl = (0, import_element239.forwardRef)(UnforwardedValidatedSelectControl);
  ValidatedSelectControl.displayName = "ValidatedSelectControl";

  // packages/components/build-module/validated-form-controls/components/text-control.mjs
  var import_compose93 = __toESM(require_compose(), 1);
  var import_element240 = __toESM(require_element(), 1);
  var import_jsx_runtime322 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedTextControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element240.useRef)(null);
    const mergedRefs = (0, import_compose93.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime322.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      customValidity,
      getValidityTarget: () => validityTargetRef.current,
      children: /* @__PURE__ */ (0, import_jsx_runtime322.jsx)(text_control_default, {
        ref: mergedRefs,
        ...restProps
      })
    });
  };
  var ValidatedTextControl = (0, import_element240.forwardRef)(UnforwardedValidatedTextControl);
  ValidatedTextControl.displayName = "ValidatedTextControl";

  // packages/components/build-module/validated-form-controls/components/textarea-control.mjs
  var import_element241 = __toESM(require_element(), 1);
  var import_compose94 = __toESM(require_compose(), 1);
  var import_jsx_runtime323 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedTextareaControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element241.useRef)(null);
    const mergedRefs = (0, import_compose94.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime323.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      customValidity,
      getValidityTarget: () => validityTargetRef.current,
      children: /* @__PURE__ */ (0, import_jsx_runtime323.jsx)(textarea_control_default, {
        ref: mergedRefs,
        ...restProps
      })
    });
  };
  var ValidatedTextareaControl = (0, import_element241.forwardRef)(UnforwardedValidatedTextareaControl);
  ValidatedTextareaControl.displayName = "ValidatedTextareaControl";

  // packages/components/build-module/validated-form-controls/components/toggle-control.mjs
  var import_element242 = __toESM(require_element(), 1);
  var import_compose95 = __toESM(require_compose(), 1);
  var import_jsx_runtime324 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedToggleControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element242.useRef)(null);
    const mergedRefs = (0, import_compose95.useMergeRefs)([forwardedRef, validityTargetRef]);
    return /* @__PURE__ */ (0, import_jsx_runtime324.jsx)(ControlWithError, {
      required,
      markWhenOptional,
      customValidity,
      getValidityTarget: () => validityTargetRef.current,
      children: /* @__PURE__ */ (0, import_jsx_runtime324.jsx)(toggle_control_default, {
        ref: mergedRefs,
        required,
        ...restProps
      })
    });
  };
  var ValidatedToggleControl = (0, import_element242.forwardRef)(UnforwardedValidatedToggleControl);
  ValidatedToggleControl.displayName = "ValidatedToggleControl";

  // packages/components/build-module/validated-form-controls/components/toggle-group-control.mjs
  var import_element243 = __toESM(require_element(), 1);
  var import_jsx_runtime325 = __toESM(require_jsx_runtime(), 1);
  var UnforwardedValidatedToggleGroupControl = ({
    required,
    customValidity,
    markWhenOptional,
    ...restProps
  }, forwardedRef) => {
    const validityTargetRef = (0, import_element243.useRef)(null);
    const nameAttr = (0, import_element243.useId)();
    return /* @__PURE__ */ (0, import_jsx_runtime325.jsxs)("div", {
      className: "components-validated-control__wrapper-with-error-delegate",
      children: [/* @__PURE__ */ (0, import_jsx_runtime325.jsx)(ControlWithError, {
        required,
        markWhenOptional,
        customValidity,
        getValidityTarget: () => validityTargetRef.current,
        children: /* @__PURE__ */ (0, import_jsx_runtime325.jsx)(component_default12, {
          ref: forwardedRef,
          ...restProps
        })
      }), /* @__PURE__ */ (0, import_jsx_runtime325.jsx)("input", {
        className: "components-validated-control__error-delegate",
        type: "radio",
        ref: validityTargetRef,
        required,
        checked: restProps.value !== void 0,
        tabIndex: -1,
        name: nameAttr,
        onChange: () => {
        },
        onFocus: (e3) => {
          e3.target.previousElementSibling?.querySelector('[data-active-item="true"]')?.focus();
        }
      })]
    });
  };
  var ValidatedToggleGroupControl = (0, import_element243.forwardRef)(UnforwardedValidatedToggleGroupControl);
  ValidatedToggleGroupControl.displayName = "ValidatedToggleGroupControl";

  // packages/components/build-module/private-apis.mjs
  var privateApis = {};
  lock(privateApis, {
    ContentEditableControl: content_editable_control_default,
    __experimentalPopoverLegacyPositionToPlacement: positionToPlacement,
    ComponentsContext,
    Tabs,
    Theme: theme_default,
    Menu: Menu3,
    kebabCase,
    withIgnoreIMEEvents,
    Badge: badge_default,
    normalizeTextString,
    DateCalendar,
    DateRangeCalendar,
    TZDate,
    useDrag,
    ValidatedInputControl,
    ValidatedCheckboxControl,
    ValidatedComboboxControl,
    ValidatedNumberControl,
    ValidatedSelectControl,
    ValidatedRadioControl,
    ValidatedContentEditableControl,
    ValidatedTextControl,
    ValidatedTextareaControl,
    ValidatedToggleControl,
    ValidatedToggleGroupControl,
    ValidatedFormTokenField
  });
  return __toCommonJS(index_exports);
})();
/*! Bundled license information:

use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
  (**
   * @license React
   * use-sync-external-store-shim.development.js
   *
   * Copyright (c) Meta Platforms, Inc. and affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)

react-is/cjs/react-is.development.js:
  (** @license React v16.13.1
   * react-is.development.js
   *
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *)

is-plain-object/dist/is-plain-object.mjs:
  (*!
   * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
   *
   * Copyright (c) 2014-2017, Jon Schlinkert.
   * Released under the MIT License.
   *)
*/
(window.wp ||= {}).components = wp.components;
})();
