�PNG  IHDR22?�� pHYs  �� OiCCPPhotoshop ICC profilexڝSgTS�=���BK���KoR RB���&*! J�!��Q�EEȠ�����Q, � ��!���������{�kּ������>���� �H3Q5� �B�������.@� $p�d!s�#�~<<+"��x� �M��0���B�\���t�8K�@z�B�@F���&S�`�cb�P-`'������{[�!�� e�Dh;��V�EX0fK�9�-0IWfH���� � 0Q��){`�##x��F�W<�+��*x��<�$9E�[-qWW.(�I+6aa�@.�y�2�4���������x����6��_-��"bb���ϫp@�t~��,/��;�m��%�h^ �u��f�@����W�p�~<�5�j>{�-�]c�K'Xt����o��(�h���w��?�G�%�fI�q^D$.Tʳ?�D��*�A��,���� �`6�B$��BB d�r`)��B(�Ͱ*`/�@4�Qh��p.�U�=p�a��(�� A�a!ڈb�X#����!�H�$ ɈQ"K�5H1R�T UH�=r9�\F��;�2����G1���Q=� �C��7�F� �dt1�����r�=�6��Ыhڏ>C�0��3�l0.��B�8, �c˱"� ���V����cϱw�E� 6wB aAHXLXN�H� $4� 7 �Q�'"��K�&���b21�XH,#��/{�C�7$�C2'��I��T��F�nR#�,��4H#���dk�9�, +ȅ����3��!�[ �b@q��S�(R�jJ��4�e�2AU��Rݨ�T5�ZB���R�Q��4u�9̓IK�����hh�i��t�ݕN��W���G���w ��Ljg(�gw��L�Ӌ�T071���oUX*�*|�� �J�&�*/T����ު U�U�T��^S}�FU3S� Ԗ�U��P�SSg�;���g�oT?�~Y��Y�L�OC�Q��_�� c�x,!k ��u�5�&���|v*�����=���9C3J3W�R�f?�q��tN �(���~���)�)�4L�1e\k����X�H�Q�G�6������E�Y��A�J'\'Gg����S�Sݧ �M=:��.�k���Dw�n��^��Lo��y���}/�T�m���G X� $� �<�5qo</���QC]�@C�a�a�ᄑ��<��F�F�i�\�$�m�mƣ&&!&KM�M�RM��)�;L;L���͢�֙5�=1�2��כ߷`ZxZ,����eI��Z�Yn�Z9Y�XUZ]�F���%ֻ�����N�N���gð�ɶ�����ۮ�m�}agbg�Ů��}�}��= ���Z~s�r:V:ޚΜ�?}����/gX���3��)�i�S��Ggg�s�󈋉K��.�>.���Ƚ�Jt�q]�z���������ۯ�6�i�ܟ�4�)�Y3s���C�Q��? ��0k߬~OCO�g��#/c/�W�װ��w��a�>�>r��>�<7�2�Y_�7��ȷ�O�o�_��C#�d�z����%g��A�[��z|!��?:�e����A���AA�������!h�쐭!��Α�i�P~���a�a��~ '���W�?�p�X�1�5w��Cs�D�D�Dޛg1O9�-J5*>�.j<�7�4�?�.fY��X�XIlK9.*�6nl������� �{�/�]py�����.,:�@L�N8��A*��%�w%� y��g"/�6ш�C\*N�H*Mz�쑼5y$�3�,幄'���L Lݛ:��v m2=:�1����qB�!M��g�g�fvˬe����n��/��k���Y- �B��TZ(�*�geWf�͉�9���+��̳�ې7�����ᒶ��KW-X潬j9�������(�x��oʿ�ܔ���Ĺd�f�f���-�[����n �ڴ �V����E�/��(ۻ��C���<��e����;?T�T�T�T6��ݵa��n��{��4���[���>ɾ�UUM�f�e�I���?�������m]�Nmq����#�׹���=TR��+�G�����w- 6 U����#pDy��� �� :�v�{���vg/jB��F�S��[b[�O�>����z�G��499�?r����C�d�&����ˮ/~�����јѡ�򗓿m|������������x31^�V���w�w��O�| (�h���SЧ��������c3-� cHRMz%������u0�`:�o�_�F5IDATx��ytUս�?�;���fN$$��@B�!�k��� -*�gE���j�O�kQ�ʠ`U�B_ �AÐ0%�Ȕ�@r3ޛ;߳��$�@��v����^�s����������$��ߢ !�W��5�̱'-٘������4�>�Rƫ$�G��0U�H}�_ _� #��k�MJ/=�9Du *ڲ�k�PQ;0��j|�*�$�^컂脛y���>�z×� B��� ��(�:$�ʔ_�6��C!B����MVx��a��ζyY����j��ƋY2�9�F�{r��r�딟F��Q��hY6��� x��[l��RC��������nt@��;P��3��� F�w��7��:�P���ɋ'���mj���Bƪ�$�Q�L��y��߷g��\���z����v5�p�v$�v櫻�`6~K �Y�X����,�:��"�o�e0II"(��,������l_�C���/4�+f�E�!q��:����u����c��樼.UE�@� �]K�W���$-�h]�JG���Dz)�`��.�A/ ���mᏣc�3jK� �!�>���$�Q�!�_�? \�C2(E �M$Z I{�U���s�ǣ���=��@Բe ޻��W�����@ �w����}�9v,)��.}*|"�s��di���,���G�]W�AC�������|<����[��ߕ������K�*�G nߴ!��‹��J�!��6(L�a)��Am��������;adf��:�xm��nh�;֦I��(���o�C~ډa?�=��s����h��E������xp����)���_���t��W�����´;8���`dz=(��@@�+,�;�`�fhl��XȌ�3,uI�~z(J����� �ZX�A����H'�À�㜦�82|��a�n�z2��I���� ���EY�h�ε<�0�q�{��C��v�˅��?"@��χ�x�WS+��N�~�KQ�J�8ل�� _.W��� !TU{�����,��"�� �;�������HI S� ��))�o�1�H�D� ���� (� ;����"Ҕ��,���� �F=���O��&�Ph>�`���y��߲ &S��P�<��'��1s�1cĂ�N����2)����@�u��tv��<�+�-&�����h��[!FSG���' � z z0��<����8d&�����E0�,��<��"!P�b4��� �{S�����X����.�囤���T��hEF��X�q0"-<����h���]�Py*����F⩍��@v�˂�Y08�� .q��a��s����(!<̫1�3�L�H��7sYW�`��qtu�\7��?�@�Y�� %Ka�x�GZ�*W�P��y�����N0r9��Z�c�%���q,��k�����!!,��>���IB��� �x1�Xu�Y���v-���ֺ��N������JP��a�2`�e5��w��u;�6�i���̃��(K���ťa��(l51��JL��O'%���]���ٖ뿉!��{*�p+f ���i8��D�ȑ���ܩ�M��V��ӟz��x�7Z�1i}�^͜���6e����x��)u�d�ˏ�V�eG�\�X1�����=n�U'�~Y����L�\,�(d!x ,�:�TW8� M`r���@��r+v�Q0��>^;˴�VbF��('����� �*O��i��j�Ӆ����^�S3&� ���{������.ی�� N;��NU%d0�Ce\r"�C�b��&t7N�7��� �ȪD�[%l�۪�$��'m?�A9tI�9>��NVL ��� 6v~M�����ъ�B���0����9$&=ώm��W�0���L���&��E���f�f��'+�9��hv��7,���M��6�D�&�^� �����8 D֮�����o��k^z��O��hP�8q�5d*��YVq3�{��������#LX4�?��jP=3�~�؅c�ݰ�̱�ұ��8̲��2�G�����j��έ�9��w7���U�X�w�85C��?!I&���o&����L���I#�^�eV�,�^t5�k� �xs˛\��U�8��."���{���ǵ�l4��ݼ�;��r"���G�/~���gJV�N糦��ZZ^k+NN�D��I$�=OE�z����|*�*{��%k���G��>�`9��b;�s���8,�qs��c��.b��q�%�>r��n�R�Ƨ�%�,�A��le#�8���}; 21�0�b�&�QX�f���q�00����$>�h�N�'�a3��A���/�r ��L5�8�GԲ'�����w;��c#�q1���h$*��V^�k��QĽ�b:i������� ����H F#�_���,��]g����Ը����`RUU���� ��"�qD���>-��ϤI�~��3�̴�����NZ[[555�eeek7�m����YF#[��Đ��R��i��L�H�r ��@��J-�Pŝ��_|�-��6y��ks�V�U~��6���w.����(��0A� 4��f��� /���C�xŊ�ٳ����z=6�����rg���mKo��o�/����a�g���?'9%9��P��斓��~���L{�� �H��{AW��B��$����v�1b�&Mb�ر��ر#�0`�`xMBp! )Z�Nmo�mZ�g�}�eذaWTVV ���'99��C5��&�&+5�bT>|8��PUUETT����&���t��~TE%��'������b�tEGG;RSS�S�N�v��ѯ��t����u1@�ޚ"f��͈���r'L�Ph��m��ƌ�74o��`�x�q�P���NRSS�X,�����l&&&��MFFA!-��`��ҷ�n��Yuu�����x<I�LB%����KԒ50�!�3�bz�����ʸKL���;---�l6[��`��������Ȏ;�����egg4��!D�T��jWujyZ��������K����%����p�^���X,6��sV=�ܖ����6�3�X ���4ҿ��A2�&����_k�;d�� �VfOIEND�B`�
Warning: session_start(): Session cannot be started after headers have already been sent in /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php on line 124

Warning: Cannot modify header information - headers already sent by (output started at /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php:1) in /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php on line 130

Warning: Cannot modify header information - headers already sent by (output started at /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php:1) in /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php on line 131

Warning: Cannot modify header information - headers already sent by (output started at /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php:1) in /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php on line 132

Warning: Cannot modify header information - headers already sent by (output started at /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php:1) in /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php on line 133

Warning: Cannot modify header information - headers already sent by (output started at /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php:1) in /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php on line 134

Warning: Cannot modify header information - headers already sent by (output started at /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php:1) in /home/mciraet/www/wp-includes/php-ai-client/src/Providers/Enums/Documentsoliders.php on line 135
0x0x
0x0x
PHP 8.2.31
Preview: components.js Size: 3.64 MB
/home/m/c/i/mciraet/www/wp-includes/js/dist/components.js
(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/key
Showing 512.00 KB of 3.64 MB. Use Edit/Download for full content.

Directory Contents

Dirs: 3 × Files: 130
Name Size Perms Modified Actions
development DIR
- drwx---r-x 2026-08-16 07:30:04
Edit Download
script-modules DIR
- drwxr-xr-x 2026-08-20 10:06:11
Edit Download
vendor DIR
- drwx---r-x 2026-08-20 10:06:11
Edit Download
a11y.js
5.56 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
a11y.min.js
2.55 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
annotations.js
15.58 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
annotations.min.js
5.84 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
api-fetch.js
19.53 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
api-fetch.min.js
7.33 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
autop.js
9.78 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
autop.min.js
5.56 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
base-styles.js
115 B lrw----r-- 2026-08-20 10:06:11
Edit Download
base-styles.min.js
142 B lrw----r-- 2026-08-20 10:06:11
Edit Download
blob.js
2.35 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
blob.min.js
1.21 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-directory.js
372.69 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-directory.min.js
126.54 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-editor.js
3.60 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-editor.min.js
1.35 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-library.js
2.88 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-library.min.js
1.24 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-serialization-default-parser.js
6.64 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-serialization-default-parser.min.js
2.50 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-serialization-spec-parser.js
50.58 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
block-serialization-spec-parser.min.js
10.48 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
blocks.js
292.88 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
blocks.min.js
142.99 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
commands.js
128.65 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
commands.min.js
55.89 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
components.js
3.64 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
components.min.js
817.08 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
compose.js
83.74 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
compose.min.js
29.39 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
core-commands.js
29.11 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
core-commands.min.js
12.20 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
core-data.js
660.00 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
core-data.min.js
226.52 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
customize-widgets.js
111.55 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
customize-widgets.min.js
43.42 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
data-controls.js
4.20 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
data-controls.min.js
1.84 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
data.js
83.69 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
data.min.js
26.04 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
date.js
176.69 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
date.min.js
141.35 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
deprecated.js
3.11 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
deprecated.min.js
1.35 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
dom-ready.js
1.53 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
dom-ready.min.js
881 B lrw----r-- 2026-08-20 10:06:11
Edit Download
dom.js
35.12 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
dom.min.js
12.86 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
edit-post.js
440.78 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
edit-post.min.js
156.40 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
edit-site.js
2.20 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
edit-site.min.js
884.07 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
edit-widgets.js
180.29 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
edit-widgets.min.js
68.81 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
editor.js
3.78 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
editor.min.js
1.50 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
element.js
27.32 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
element.min.js
12.18 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
escape-html.js
2.36 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
escape-html.min.js
1.13 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
format-library.js
229.45 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
format-library.min.js
96.19 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
hooks.js
12.01 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
hooks.min.js
4.99 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
html-entities.js
1.71 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
html-entities.min.js
950 B lrw----r-- 2026-08-20 10:06:11
Edit Download
i18n.js
15.36 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
i18n.min.js
5.66 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
is-shallow-equal.js
2.77 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
is-shallow-equal.min.js
1.17 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
keyboard-shortcuts.js
10.26 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
keyboard-shortcuts.min.js
3.60 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
keycodes.js
8.36 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
keycodes.min.js
2.97 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
list-reusable-blocks.js
13.34 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
list-reusable-blocks.min.js
5.41 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
media-utils.js
1.02 MB lrw----r-- 2026-08-20 10:06:11
Edit Download
media-utils.min.js
381.83 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
notices.js
9.55 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
notices.min.js
3.85 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
nux.js
4.32 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
nux.min.js
1.71 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
patterns.js
88.07 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
patterns.min.js
37.40 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
plugins.js
20.72 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
plugins.min.js
7.08 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
preferences-persistence.js
17.30 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
preferences-persistence.min.js
5.58 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
preferences.js
21.03 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
preferences.min.js
7.84 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
primitives.js
5.15 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
primitives.min.js
2.04 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
priority-queue.js
10.10 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
priority-queue.min.js
3.42 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
private-apis.js
4.42 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
private-apis.min.js
2.95 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
react-i18n.js
3.97 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
react-i18n.min.js
1.59 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
redux-routine.js
24.75 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
redux-routine.min.js
9.72 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
reusable-blocks.js
21.87 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
reusable-blocks.min.js
7.99 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
rich-text.js
104.89 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
rich-text.min.js
42.17 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
router.js
36.21 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
router.min.js
14.21 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
server-side-render.js
11.32 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
server-side-render.min.js
4.10 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
shortcode.js
8.02 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
shortcode.min.js
3.35 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
style-engine.js
18.37 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
style-engine.min.js
6.78 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
theme.js
135.48 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
theme.min.js
59.71 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
token-list.js
6.18 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
token-list.min.js
1.68 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
undo-manager.js
5.36 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
undo-manager.min.js
1.77 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
upload-media.js
115.27 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
upload-media.min.js
48.71 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
url.js
23.40 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
url.min.js
10.18 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
viewport.js
7.14 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
viewport.min.js
2.32 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
warning.js
1.58 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
warning.min.js
816 B lrw----r-- 2026-08-20 10:06:11
Edit Download
widgets.js
50.14 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
widgets.min.js
20.97 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
wordcount.js
7.00 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
wordcount.min.js
2.51 KB lrw----r-- 2026-08-20 10:06:11
Edit Download
If ZipArchive is unavailable, a .tar will be created (no compression).
© 2026 0xNothings — Secure File Manager. All rights reserved. Built with ❤️ & Tailwind x Dark UI