�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`� 0x0x
0x0x
PHP 8.1.34
Preview: components.js Size: 3.47 MB
/home2/astrociv/public_html/gurujii.in/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 __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
    get: (a2, b2) => (typeof require !== "undefined" ? require : a2)[b2]
  }) : x2)(function(x2) {
    if (typeof require !== "undefined") return require.apply(this, arguments);
    throw Error('Dynamic require of "' + x2 + '" is not supported');
  });
  var __commonJS = (cb, mod) => function __require2() {
    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, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, 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/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/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/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/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 === React152.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 = useState105({
            inst: { value, getSnapshot }
          });
          var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
          useLayoutEffect23(
            function() {
              inst.value = value;
              inst.getSnapshot = getSnapshot;
              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
            },
            [subscribe2, value, getSnapshot]
          );
          useEffect96(
            function() {
              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
              return subscribe2(function() {
                checkIfSnapshotChanged(inst) && forceUpdate({ inst });
              });
            },
            [subscribe2]
          );
          useDebugValue2(value);
          return value;
        }
        function checkIfSnapshotChanged(inst) {
          var latestGetSnapshot = inst.getSnapshot;
          inst = inst.value;
          try {
            var nextValue = latestGetSnapshot();
            return !objectIs(inst, nextValue);
          } catch (error2) {
            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 React152 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState105 = React152.useState, useEffect96 = React152.useEffect, useLayoutEffect23 = React152.useLayoutEffect, useDebugValue2 = React152.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 !== React152.useSyncExternalStore ? React152.useSyncExternalStore : shim;
        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
      })();
    }
  });

  // node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/shim/index.js
  var require_shim = __commonJS({
    "node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/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/warning
  var require_warning = __commonJS({
    "package-external:@wordpress/warning"(exports, module) {
      module.exports = window.wp.warning;
    }
  });

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

  // node_modules/.store/deepmerge@4.3.1-130J0Lhhc9LM1JWY-5q3ww/node_modules/deepmerge/dist/cjs.js
  var require_cjs = __commonJS({
    "node_modules/.store/deepmerge@4.3.1-130J0Lhhc9LM1JWY-5q3ww/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(prev, next) {
          return deepmerge2(prev, next, options2);
        }, {});
      };
      var deepmerge_1 = deepmerge2;
      module.exports = deepmerge_1;
    }
  });

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

  // node_modules/.store/highlight-words-core@1.2.2-V8mfhTd10PD1GySAOmFhHA/node_modules/highlight-words-core/dist/index.js
  var require_dist = __commonJS({
    "node_modules/.store/highlight-words-core@1.2.2-V8mfhTd10PD1GySAOmFhHA/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(_ref) {
            var autoEscape = _ref.autoEscape, _ref$caseSensitive = _ref.caseSensitive, caseSensitive = _ref$caseSensitive === void 0 ? false : _ref$caseSensitive, _ref$findChunks = _ref.findChunks, findChunks = _ref$findChunks === void 0 ? defaultFindChunks : _ref$findChunks, sanitize2 = _ref.sanitize, searchWords = _ref.searchWords, textToHighlight = _ref.textToHighlight;
            return fillInChunks({
              chunksToHighlight: combineChunks({
                chunks: findChunks({
                  autoEscape,
                  caseSensitive,
                  sanitize: sanitize2,
                  searchWords,
                  textToHighlight
                })
              }),
              totalLength: textToHighlight ? textToHighlight.length : 0
            });
          };
          var combineChunks = exports2.combineChunks = function combineChunks2(_ref2) {
            var chunks = _ref2.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(_ref3) {
            var autoEscape = _ref3.autoEscape, caseSensitive = _ref3.caseSensitive, _ref3$sanitize = _ref3.sanitize, sanitize2 = _ref3$sanitize === void 0 ? defaultSanitize : _ref3$sanitize, searchWords = _ref3.searchWords, textToHighlight = _ref3.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 match2 = void 0;
              while (match2 = regex.exec(textToHighlight)) {
                var _start = match2.index;
                var _end = regex.lastIndex;
                if (_end > _start) {
                  chunks.push({ highlight: false, start: _start, end: _end });
                }
                if (match2.index === regex.lastIndex) {
                  regex.lastIndex++;
                }
              }
              return chunks;
            }, []);
          };
          exports2.findChunks = defaultFindChunks;
          var fillInChunks = exports2.fillInChunks = function fillInChunks2(_ref4) {
            var chunksToHighlight = _ref4.chunksToHighlight, totalLength = _ref4.totalLength;
            var allChunks = [];
            var append = function append2(start, end, highlight) {
              if (end - start > 0) {
                allChunks.push({
                  start,
                  end,
                  highlight
                });
              }
            };
            if (chunksToHighlight.length === 0) {
              append(0, totalLength, false);
            } else {
              var lastIndex = 0;
              chunksToHighlight.forEach(function(chunk) {
                append(lastIndex, chunk.start, false);
                append(chunk.start, chunk.end, true);
                lastIndex = chunk.end;
              });
              append(lastIndex, totalLength, false);
            }
            return allChunks;
          };
          function defaultSanitize(string) {
            return string;
          }
          function escapeRegExpFn(string) {
            return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
          }
        })
        /******/
      ]);
    }
  });

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

  // 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;
    }
  });

  // node_modules/.store/remove-accents@0.5.0-S_lnImruWgc6kBSjIJlPgw/node_modules/remove-accents/index.js
  var require_remove_accents = __commonJS({
    "node_modules/.store/remove-accents@0.5.0-S_lnImruWgc6kBSjIJlPgw/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(match2) {
        return characterMap[match2];
      }
      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/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
  var require_with_selector_development = __commonJS({
    "node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js"(exports) {
      "use strict";
      (function() {
        function is(x2, y3) {
          return x2 === y3 && (0 !== x2 || 1 / x2 === 1 / y3) || x2 !== x2 && y3 !== y3;
        }
        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
        var React152 = require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore5 = shim.useSyncExternalStore, useRef145 = React152.useRef, useEffect96 = React152.useEffect, useMemo93 = React152.useMemo, useDebugValue2 = React152.useDebugValue;
        exports.useSyncExternalStoreWithSelector = function(subscribe2, getSnapshot, getServerSnapshot, selector2, isEqual2) {
          var instRef = useRef145(null);
          if (null === instRef.current) {
            var inst = { hasValue: false, value: null };
            instRef.current = inst;
          } else inst = instRef.current;
          instRef = useMemo93(
            function() {
              function memoizedSelector(nextSnapshot) {
                if (!hasMemo) {
                  hasMemo = true;
                  memoizedSnapshot = nextSnapshot;
                  nextSnapshot = selector2(nextSnapshot);
                  if (void 0 !== isEqual2 && inst.hasValue) {
                    var currentSelection = inst.value;
                    if (isEqual2(currentSelection, nextSnapshot))
                      return memoizedSelection = currentSelection;
                  }
                  return memoizedSelection = nextSnapshot;
                }
                currentSelection = memoizedSelection;
                if (objectIs(memoizedSnapshot, nextSnapshot))
                  return currentSelection;
                var nextSelection = selector2(nextSnapshot);
                if (void 0 !== isEqual2 && isEqual2(currentSelection, nextSelection))
                  return memoizedSnapshot = nextSnapshot, currentSelection;
                memoizedSnapshot = nextSnapshot;
                return memoizedSelection = nextSelection;
              }
              var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
              return [
                function() {
                  return memoizedSelector(getSnapshot());
                },
                null === maybeGetServerSnapshot ? void 0 : function() {
                  return memoizedSelector(maybeGetServerSnapshot());
                }
              ];
            },
            [getSnapshot, getServerSnapshot, selector2, isEqual2]
          );
          var value = useSyncExternalStore5(subscribe2, instRef[0], instRef[1]);
          useEffect96(
            function() {
              inst.hasValue = true;
              inst.value = value;
            },
            [value]
          );
          useDebugValue2(value);
          return value;
        };
        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
      })();
    }
  });

  // node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/shim/with-selector.js
  var require_with_selector = __commonJS({
    "node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) {
      "use strict";
      if (false) {
        module.exports = null;
      } else {
        module.exports = require_with_selector_development();
      }
    }
  });

  // 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;
    }
  });

  // 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_primitives36.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_primitives36.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_primitives36.G,
    GradientPicker: () => gradient_picker_default,
    Guide: () => guide_default,
    GuidePage: () => GuidePage,
    HorizontalRule: () => import_primitives36.HorizontalRule,
    Icon: () => icon_default3,
    IconButton: () => deprecated_default3,
    IsolatedEventContainer: () => isolated_event_container_default,
    KeyboardShortcuts: () => keyboard_shortcuts_default,
    Line: () => import_primitives36.Line,
    MenuGroup: () => menu_group_default,
    MenuItem: () => menu_item_default,
    MenuItemsChoice: () => menu_items_choice_default,
    Modal: () => modal_default,
    NavigableMenu: () => menu_default2,
    Navigator: () => Navigator2,
    Notice: () => notice_default,
    NoticeList: () => list_default,
    Panel: () => panel_default,
    PanelBody: () => body_default,
    PanelHeader: () => header_default,
    PanelRow: () => row_default,
    Path: () => import_primitives36.Path,
    Placeholder: () => placeholder_default,
    Polygon: () => import_primitives36.Polygon,
    Popover: () => popover_default,
    ProgressBar: () => progress_bar_default,
    QueryControls: () => query_controls_default,
    RadioControl: () => radio_control_default,
    RangeControl: () => range_control_default,
    Rect: () => import_primitives36.Rect,
    ResizableBox: () => resizable_box_default,
    ResponsiveWrapper: () => responsive_wrapper_default,
    SVG: () => import_primitives36.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: () => deprecated_default,
    __experimentalDropdownContentWrapper: () => dropdown_content_wrapper_default,
    __experimentalElevation: () => deprecated_default2,
    __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: () => deprecated_default4,
    __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: () => Composite3,
    __unstableCompositeGroup: () => CompositeGroup3,
    __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_primitives36 = __toESM(require_primitives(), 1);

  // node_modules/.store/clsx@2.1.1-XOLP1vUL9vEGfpiXm37fAw/node_modules/clsx/dist/clsx.mjs
  function r(e3) {
    var t3, f2, n2 = "";
    if ("string" == typeof e3 || "number" == typeof e3) n2 += e3;
    else if ("object" == typeof e3) if (Array.isArray(e3)) {
      var o3 = e3.length;
      for (t3 = 0; t3 < o3; t3++) e3[t3] && (f2 = r(e3[t3])) && (n2 && (n2 += " "), n2 += f2);
    } else for (f2 in e3) e3[f2] && (n2 && (n2 += " "), n2 += f2);
    return n2;
  }
  function clsx() {
    for (var e3, t3, f2 = 0, n2 = "", o3 = arguments.length; f2 < o3; f2++) (e3 = arguments[f2]) && (t3 = r(e3)) && (n2 && (n2 += " "), n2 += t3);
    return n2;
  }
  var clsx_default = clsx;

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/button/utils.js
  function withDefaultButtonType(props) {
    const { render, type } = props;
    if (render || type !== void 0) return props;
    return {
      ...props,
      type: "button"
    };
  }

  // node_modules/.store/@ariakit/utils@0.2.2-pGTZG_8OyOn9imlarPyF4g/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(a2, b2) {
    if (a2 === b2) return true;
    if (!a2) return false;
    if (!b2) return false;
    if (typeof a2 !== "object") return false;
    if (typeof b2 !== "object") return false;
    const aKeys = Object.keys(a2);
    const bKeys = Object.keys(b2);
    const { length } = aKeys;
    if (bKeys.length !== length) return false;
    for (const key of aKeys) if (a2[key] !== b2[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);
  }
  var defaultWarnOnceKey = {};
  var warningMessages = /* @__PURE__ */ new WeakMap();
  function warnOnce(message, key) {
    const warningKey = key || defaultWarnOnceKey;
    let messages = warningMessages.get(warningKey);
    if (!messages) {
      messages = /* @__PURE__ */ new Set();
      warningMessages.set(warningKey, messages);
    }
    if (messages.has(message)) return;
    messages.add(message);
    console.warn(message);
  }
  function invariant(condition, message) {
    if (condition) return;
    if (typeof message !== "string") throw new Error("Invariant failed");
    throw new Error(message);
  }
  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 (!hasOwnProperty(obj, key)) continue;
      if (key === "__proto__") continue;
      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 lookupGetter(prototype, name) {
    let target = prototype;
    while (target) {
      const descriptor = Object.getOwnPropertyDescriptor(target, name);
      if (descriptor?.get) return descriptor.get;
      target = Object.getPrototypeOf(target);
    }
  }
  var nodeTypeGetter = canUseDOM ? lookupGetter(Object.getPrototypeOf(window.document), "nodeType") : void 0;
  var activeElementGetter = canUseDOM ? lookupGetter(Object.getPrototypeOf(window.document), "activeElement") : void 0;
  function isWindow(value) {
    if (!value) return false;
    return value.window === value;
  }
  function isDocument(value) {
    if (!value) return false;
    if (!nodeTypeGetter) return value.nodeType === 9;
    try {
      return nodeTypeGetter.call(value) === 9;
    } catch {
      return false;
    }
  }
  function ownsDocument(view2, ownerDocument2) {
    try {
      return view2.document === ownerDocument2;
    } catch {
      return false;
    }
  }
  function getDocument(node) {
    if (!node) return document;
    if (isDocument(node)) return node;
    if (isWindow(node)) return node.document;
    const nodeDocument = node.ownerDocument;
    if (isDocument(nodeDocument)) return nodeDocument;
    return document;
  }
  function getWindow(node) {
    if (!node) return self;
    if (isWindow(node)) return node;
    const nodeDocument = getDocument(node);
    const { defaultView } = nodeDocument;
    if (isWindow(defaultView) && ownsDocument(defaultView, nodeDocument)) return defaultView;
    return window;
  }
  function getActiveElement(node, { frame: frame2 = true, activeDescendant = false } = {}) {
    const ownerDocument2 = getDocument(node);
    const activeElement2 = activeElementGetter ? activeElementGetter.call(ownerDocument2) : ownerDocument2.activeElement;
    if (!activeElement2?.nodeName) return null;
    if (frame2 && isFrame(activeElement2) && activeElement2.contentDocument?.body) return getActiveElement(activeElement2.contentDocument.body, {
      frame: frame2,
      activeDescendant
    });
    if (activeDescendant) {
      const id3 = activeElement2.getAttribute("aria-activedescendant");
      if (id3) {
        const element = getDocument(activeElement2).getElementById(id3);
        if (element) return element;
      }
    }
    return activeElement2;
  }
  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, options2 = {}) {
    if (!element) return null;
    const { axis, stopAt } = options2;
    if (element === stopAt) return element;
    const isScrollableOverflow = (overflow) => {
      if (overflow === "auto") return true;
      if (overflow === "scroll") return true;
      return false;
    };
    if (axis !== "x" && element.clientHeight && element.scrollHeight > element.clientHeight) {
      const { overflowY } = getComputedStyle(element);
      if (isScrollableOverflow(overflowY)) return element;
    }
    if (axis !== "y" && element.clientWidth && element.scrollWidth > element.clientWidth) {
      const { overflowX } = getComputedStyle(element);
      if (isScrollableOverflow(overflowX)) return element;
    }
    const doc = getDocument(element);
    return getScrollingElement(element.parentElement, options2) || doc.scrollingElement || doc.body;
  }
  function sortBasedOnDOMPosition(items, getElement) {
    const pairs = items.map((item, index2) => [index2, item]);
    let isOrderDifferent = false;
    pairs.sort(([indexA, a2], [indexB, b2]) => {
      const elementA = getElement(a2);
      const elementB = getElement(b2);
      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, item]) => item);
    return items;
  }
  function isElementPreceding(a2, b2) {
    return Boolean(b2.compareDocumentPosition(a2) & 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: Event2 } = getWindow(element);
    const event = new Event2(type, eventInit);
    return element.dispatchEvent(event);
  }
  function fireBlurEvent(element, eventInit) {
    const { FocusEvent } = getWindow(element);
    const event = new FocusEvent("blur", eventInit);
    const defaultAllowed = element.dispatchEvent(event);
    const bubbleInit = {
      ...eventInit,
      bubbles: true
    };
    element.dispatchEvent(new FocusEvent("focusout", bubbleInit));
    return defaultAllowed;
  }
  var resetAttributes = {
    width: true,
    height: true,
    pressure: true,
    tangentialPressure: true,
    tiltX: true,
    tiltY: true,
    twist: true,
    altitudeAngle: true,
    azimuthAngle: true,
    isPrimary: true,
    coalescedEvents: true,
    predictedEvents: true,
    persistentDeviceId: true
  };
  function getClickEventInit(view2, eventInit) {
    const init2 = eventInit ?? {};
    const WindowConstructor = view2.Window;
    const eventView = typeof WindowConstructor === "function" && view2 instanceof WindowConstructor ? view2 : null;
    return new Proxy({}, { get(_target, key) {
      if (key === "view") return eventView;
      if (key === "composed") return true;
      if (key === "pointerId") return init2.pointerId ?? -1;
      if (key === "pointerType") return init2.pointerType ?? "";
      if (hasOwnProperty(resetAttributes, key)) return void 0;
      return Reflect.get(init2, key);
    } });
  }
  function fireClickEvent(element, eventInit) {
    const view2 = getWindow(element);
    const event = new (view2.PointerEvent ?? view2.MouseEvent)("click", getClickEventInit(view2, 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 activeElement2 = getActiveElement(element);
    if (!activeElement2) return true;
    if (activeElement2 === element) return true;
    if (!("form" in activeElement2)) return true;
    if (activeElement2.form !== element.form) return true;
    if (!("name" in activeElement2)) return true;
    if (activeElement2.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, i2) => {
      if (!isFrame(element)) return;
      const frameBody = element.contentDocument?.body;
      if (!frameBody) return;
      focusableElements2.splice(i2, 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, i2) => {
      if (!isFrame(element)) return;
      const frameBody = element.contentDocument?.body;
      if (!frameBody) return;
      const allFrameTabbable = getAllTabbableIn(frameBody, false, fallbackToFocusable);
      tabbableElements.splice(i2, 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 activeElement2 = getActiveElement(container);
    const allFocusable = getAllFocusableIn(container, includeContainer);
    if (reverse) allFocusable.reverse();
    const activeIndex = allFocusable.indexOf(activeElement2);
    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 activeElement2 = getActiveElement(element);
    if (!activeElement2) return false;
    if (activeElement2 === element) return true;
    const activeDescendant = activeElement2.getAttribute("aria-activedescendant");
    if (!activeDescendant) return false;
    return activeDescendant === element.id;
  }
  function hasFocusWithin(element) {
    const activeElement2 = getActiveElement(element);
    if (!activeElement2) return false;
    if (contains(element, activeElement2)) return true;
    const activeDescendant = activeElement2.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 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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/C4_D9PgF.js
  var accessibleWhenDisabledSymbol = /* @__PURE__ */ Symbol("accessibleWhenDisabled");
  function accessibleWhenDisabledFromProps(props) {
    return props.accessibleWhenDisabled ?? props.onLoadedMetadataCapture?.[accessibleWhenDisabledSymbol];
  }
  var trulyDisabledAttribute = "data-truly-disabled";
  function trulyDisabledFromElement(element) {
    return element.getAttribute(trulyDisabledAttribute) === "true";
  }
  function resolvedTrulyDisabledFromElement(element) {
    const value = element.getAttribute(trulyDisabledAttribute);
    if (value === "true") return true;
    if (value === "false") return false;
  }
  function isCompositeMoveKey(key) {
    return key === "ArrowUp" || key === "ArrowRight" || key === "ArrowDown" || key === "ArrowLeft" || key === "Home" || key === "End" || key === "PageUp" || key === "PageDown";
  }
  function isShadowRoot(node) {
    return node.nodeType === node.DOCUMENT_FRAGMENT_NODE && "host" in node;
  }
  function getTreeActiveElement(node) {
    const root = node?.getRootNode();
    if (root && isShadowRoot(root) && root.activeElement) return root.activeElement;
    return getActiveElement(node);
  }
  function hasTreeFocus(element) {
    return hasFocus(element) || getTreeActiveElement(element) === element;
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-utils@0.2.8-duN40eWASGERw9i-DIMDVw/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 === "__proto__") 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 (overrideValue === void 0) continue;
      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 useEventUpdate = _React.useInsertionEffect ?? ((callback) => callback());
  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.");
    });
    useEventUpdate(() => {
      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((prev) => {
        prevState = prev;
        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 useIdPolyfill(defaultId) {
    const [id3, setId] = (0, import_react2.useState)(defaultId);
    useSafeLayoutEffect(() => {
      if (defaultId || id3) return;
      const random = Math.random().toString(36).slice(2, 8);
      setId(`id-${random}`);
    }, [defaultId, id3]);
    return defaultId || id3;
  }
  function useReactIdWithDefault(defaultId) {
    const id3 = useReactId();
    return defaultId || id3;
  }
  var useCompatibleId = useReactId ? useReactIdWithDefault : useIdPolyfill;
  function useId(defaultId) {
    return useCompatibleId(defaultId);
  }
  function useTagName(refOrElement, type) {
    const stringOrUndefined = (type2) => {
      if (typeof type2 !== "string") return;
      return type2;
    };
    const [tagName, setTagName] = (0, import_react2.useState)(() => stringOrUndefined(type));
    useSafeLayoutEffect(() => {
      const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
      setTagName(element?.tagName.toLowerCase() || stringOrUndefined(type));
    }, [refOrElement, type]);
    return tagName;
  }
  function useAttribute(refOrElement, attributeName, defaultValue2) {
    const initialValue2 = useInitialValue(defaultValue2);
    const [attribute, setAttribute2] = (0, import_react2.useState)(initialValue2);
    (0, import_react2.useEffect)(() => {
      const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
      if (!element) return;
      const callback = () => {
        const value = element.getAttribute(attributeName);
        setAttribute2(value == null ? initialValue2 : value);
      };
      const observer = new MutationObserver(callback);
      observer.observe(element, { attributeFilter: [attributeName] });
      callback();
      return () => observer.disconnect();
    }, [
      refOrElement,
      attributeName,
      initialValue2
    ]);
    return attribute;
  }
  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(noop.bind(null), 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(removeUndefinedValues({
      ...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 useContext95 = () => React.useContext(context);
    const useScopedContext = (onlyScoped = false) => {
      const scoped = React.useContext(scopedContext);
      const store = useContext95();
      if (onlyScoped) return scoped;
      return scoped || store;
    };
    const useProviderContext = () => {
      const scoped = React.useContext(scopedContext);
      const store = useContext95();
      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: useContext95,
      useScopedContext,
      useProviderContext,
      ContextProvider,
      ScopedContextProvider
    };
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/focusable/focusable.js
  var import_react3 = __toESM(require_react(), 1);
  var TagName = "div";
  var isSafariBrowser = isSafari();
  var nativeTabbableMask = 1;
  var supportsDisabledMask = 2;
  var defaultElementCapabilities = 3;
  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 getElementCapabilities(tagName) {
    let capabilities = 0;
    if (isNativeTabbable(tagName)) capabilities |= nativeTabbableMask;
    if (supportsDisabledAttribute(tagName)) capabilities |= supportsDisabledMask;
    return capabilities;
  }
  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: focusable2, trulyDisabled, nativeTabbable, supportsDisabled, safariTabIndex, tabIndexProp }) {
    if (!focusable2) 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, disabled2) {
    return useEvent((event) => {
      onEvent?.(event);
      if (event.defaultPrevented) return;
      if (disabled2) {
        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 (isCompositeMoveKey(event.key)) {
      isKeyboardModality = true;
      return;
    }
    if (event.metaKey) return;
    if (event.ctrlKey) return;
    if (event.altKey) {
      if (!isSafariBrowser) return;
      if (event.key !== "Tab") return;
    }
    isKeyboardModality = true;
  }
  var useFocusable = createHook(function useFocusable2({ focusable: focusable2 = 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 (!focusable2) return;
      if (hasInstalledGlobalEventListeners2) return;
      addGlobalEventListener("mousedown", onGlobalMouseDown, true);
      addGlobalEventListener("keydown", onGlobalKeyDown, true);
      hasInstalledGlobalEventListeners2 = true;
    }, [focusable2]);
    const disabled2 = focusable2 && disabledFromProps(props);
    const trulyDisabled = disabled2 && !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 (focusable2 && !trulyDisabled) return;
      cleanupFocusVisible(ref.current);
      if (focusVisible) setFocusVisible(false);
    }, [
      focusable2,
      trulyDisabled,
      focusVisible,
      cleanupFocusVisible
    ]);
    (0, import_react3.useEffect)(() => {
      if (!focusable2) 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();
    }, [focusable2, focusVisible]);
    (0, import_react3.useEffect)(() => {
      return () => nativeSubmitObserverCleanupRef.current?.();
    }, []);
    const onKeyPressCapture = useDisableEvent(props.onKeyPressCapture, disabled2);
    const onMouseDownCapture = useDisableEvent(props.onMouseDownCapture, disabled2);
    const onClickCapture = useDisableEvent(props.onClickCapture, disabled2);
    const onAuxClickCapture = useDisableEvent(props.onAuxClickCapture, disabled2);
    const handleFocusVisible = (event, currentTarget) => {
      if (currentTarget) event.currentTarget = currentTarget;
      if (!focusable2) return;
      const element = event.currentTarget;
      if (!element) return;
      if (!hasTreeFocus(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 (!focusable2) return;
      if (focusVisible) return;
      if (focusVisibleRef.current) return;
      if ((event.metaKey || event.altKey || event.ctrlKey) && !isCompositeMoveKey(event.key)) 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 (!focusable2) 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 (!focusable2) return;
      if (!isFocusEventOutside(event)) return;
      cleanupFocusVisible(event.currentTarget);
      setFocusVisible(false);
    });
    const autoFocusOnShow = (0, import_react3.useContext)(FocusableContext);
    const autoFocusRef = useEvent((element) => {
      if (!focusable2) return;
      if (!autoFocus) return;
      if (!element) return;
      if (!autoFocusOnShow) return;
      queueMicrotask(() => {
        if (hasFocus(element)) return;
        if (!isFocusable(element)) return;
        element.focus();
      });
    });
    const [elementCapabilities, setElementCapabilities] = (0, import_react3.useState)(defaultElementCapabilities);
    useSafeLayoutEffect(() => {
      const element = ref.current;
      if (!element) return;
      const nextCapabilities = getElementCapabilities(element.tagName.toLowerCase());
      if (nextCapabilities === defaultElementCapabilities) return;
      setElementCapabilities(nextCapabilities);
    }, []);
    const nativeTabbable = focusable2 && !!(elementCapabilities & nativeTabbableMask);
    const supportsDisabled = focusable2 && !!(elementCapabilities & supportsDisabledMask);
    const [safariTabIndex, setSafariTabIndex] = (0, import_react3.useState)(false);
    if (isSafariBrowser) (0, import_react3.useEffect)(() => {
      if (!focusable2) return;
      const element = ref.current;
      if (!element) return;
      const { type } = element;
      const isNativeCheckboxOrRadio = element.tagName === "INPUT" && (type === "checkbox" || type === "radio");
      setSafariTabIndex(isButton(element) || isNativeCheckboxOrRadio);
    }, [focusable2]);
    const styleProp = props.style;
    const style2 = (0, import_react3.useMemo)(() => {
      if (trulyDisabled) return {
        pointerEvents: "none",
        ...styleProp
      };
      return styleProp;
    }, [trulyDisabled, styleProp]);
    props = {
      "data-focus-visible": focusable2 && focusVisible || void 0,
      "data-autofocus": autoFocus || void 0,
      "aria-disabled": disabled2 || void 0,
      ...props,
      ...metadataProps,
      ref: useMergeRefs(ref, autoFocusRef, props.ref),
      style: style2,
      tabIndex: getTabIndex({
        focusable: focusable2,
        trulyDisabled,
        nativeTabbable,
        supportsDisabled,
        safariTabIndex,
        tabIndexProp: props.tabIndex
      }),
      disabled: supportsDisabled && trulyDisabled ? true : void 0,
      [trulyDisabledAttribute]: disabled2 ? trulyDisabled : void 0,
      contentEditable: disabled2 ? void 0 : props.contentEditable,
      onKeyPressCapture,
      onClickCapture,
      onAuxClickCapture,
      onMouseDownCapture,
      onKeyDownCapture,
      onFocusCapture,
      onBlur
    };
    return removeUndefinedValues(props);
  });
  var Focusable = forwardRef2(function Focusable2(props) {
    const htmlProps = useFocusable(props);
    return createElement(TagName, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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);
    const type = props.type;
    (0, import_react4.useEffect)(() => {
      const element = ref.current;
      if (!element) return;
      const nativeButton = isButton(element);
      if (type !== void 0 && nativeButton && element.type === "button") return;
      setIsNativeButton(nativeButton);
    }, [type]);
    const [active, setActive] = (0, import_react4.useState)(false);
    const activeRef = (0, import_react4.useRef)(false);
    const disabled2 = disabledFromProps(props);
    const [isDuplicate, metadataProps] = useMetadataProps(props, symbol, true);
    useSafeLayoutEffect(() => {
      if (!disabled2) return;
      activeRef.current = false;
      setActive(false);
    }, [disabled2]);
    const onKeyDownProp = props.onKeyDown;
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      const element = event.currentTarget;
      if (event.defaultPrevented) return;
      if (isDuplicate) return;
      if (disabled2) 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: view2, ...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 (disabled2) return;
      if (event.metaKey) return;
      if (nativeClick) return;
      event.preventDefault();
      const element = event.currentTarget;
      const { view: view2, ...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) {
    const htmlProps = useCommand(withDefaultButtonType(props));
    return createElement(TagName2, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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 item = getItem({
        id: id3,
        element: element2
      });
      return store?.renderItem(item);
    }, [
      id3,
      shouldRegisterItem,
      getItem,
      store
    ]);
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref)
    };
    return props;
  });
  var CollectionItem = forwardRef2(function CollectionItem2(props) {
    const htmlProps = useCollectionItem(props);
    return createElement(TagName3, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/DJQz4DCk.js
  var listeners = /* @__PURE__ */ new WeakMap();
  function prepareScrollIntoView(request) {
    const cleanups2 = [];
    let ancestor = request.element.parentElement;
    while (ancestor) {
      const cleanup = listeners.get(ancestor)?.(request);
      if (cleanup) cleanups2.push(cleanup);
      ancestor = ancestor.parentElement;
    }
    return () => {
      for (const cleanup of cleanups2) cleanup();
    };
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/composite/utils.js
  var import_react7 = __toESM(require_react(), 1);

  // node_modules/.store/@ariakit/store@0.1.11-R6p47bgYcFWqOHfW2C0v-A/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 (isSameValue(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 listeners2 = map.get(key);
      if (!listeners2) {
        listeners2 = /* @__PURE__ */ new Set();
        map.set(key, listeners2);
      }
      listeners2.add(listener);
    }
  }
  function deleteKeyedListener(map, keys, listener) {
    if (!map) return;
    if (!keys) return;
    for (const key of keys) {
      const listeners2 = map.get(key);
      if (!listeners2) continue;
      listeners2.delete(listener);
      if (!listeners2.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 = applyState(value, () => currentValue);
      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) {
          const listenerPrevState = state === nextState ? prevState : {
            ...state,
            [key]: prevState[key]
          };
          runListeners(syncListenerGroup, listenerPrevState, 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/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/node_modules/@ariakit/components/dist/collection/collection-store.js
  function getCommonParent(items) {
    const firstItem = items.find((item) => !!item.element);
    const lastElement = [...items].reverse().find((item) => !!item.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;
  }
  var itemIdCacheThreshold = 64;
  function getCachedItemIds(items, cache) {
    if (items.length < itemIdCacheThreshold) {
      if (cache.ids) {
        cache.items = void 0;
        cache.ids = void 0;
      }
      return;
    }
    if (cache.items === items) return cache.ids;
    const ids = /* @__PURE__ */ new Set();
    for (const item of items) ids.add(item.id);
    cache.items = items;
    cache.ids = ids;
    return ids;
  }
  function setCachedItemIds(items, cache, ids) {
    if (items.length < itemIdCacheThreshold) {
      if (cache.ids) {
        cache.items = void 0;
        cache.ids = void 0;
      }
      return;
    }
    if (!ids) {
      ids = /* @__PURE__ */ new Set();
      for (const item of items) ids.add(item.id);
    }
    cache.items = items;
    cache.ids = ids;
  }
  function createCollectionStore(props = {}) {
    throwOnConflictingProps(props, props.store);
    const syncState = props.store?.getState();
    const items = defaultValue(props.items, syncState?.items, props.defaultItems, []);
    const syncPrivateStore = getPrivateStore(props.store);
    const collectionLookup = syncPrivateStore?.__unstableCollectionLookup ?? {
      controlledItems: new Map(items.map((item) => [item.id, item])),
      registeredItems: /* @__PURE__ */ new Map(),
      controlledItemsSource: items,
      propagatedItems: items
    };
    const { controlledItems, registeredItems } = collectionLookup;
    const itemIdCache = {};
    const renderedItemIdCache = {};
    const initialState2 = {
      items,
      renderedItems: defaultValue(syncState?.renderedItems, [])
    };
    const collection = createStore(initialState2, props.store);
    const privateStore = Object.assign(createStore({
      items,
      renderedItems: initialState2.renderedItems
    }, syncPrivateStore), { __unstableCollectionLookup: collectionLookup });
    const sortItems = (renderedItems) => {
      const sortedItems = sortBasedOnDOMPosition(renderedItems, (i2) => i2.element);
      privateStore.setState("renderedItems", sortedItems);
      collection.setState("renderedItems", sortedItems);
    };
    const indexControlledItems = (items2) => {
      if (items2 === collectionLookup.controlledItemsSource) return;
      collectionLookup.controlledItemsSource = items2;
      controlledItems.clear();
      for (const item of items2) controlledItems.set(item.id, item);
    };
    const setState = (key, value) => {
      if (key !== "items") {
        collection.setState(key, value);
        return;
      }
      collection.setState("items", (items2) => {
        const nextItems = applyState(value, items2);
        if (nextItems === items2) return items2;
        collectionLookup.propagatedItems = nextItems;
        indexControlledItems(nextItems);
        return nextItems;
      });
    };
    setup(collection, () => init(privateStore));
    if (!syncPrivateStore) {
      subscribe(collection, ["items"], ({ items: items2 }) => {
        if (items2 === collectionLookup.propagatedItems) return;
        collectionLookup.propagatedItems = items2;
        indexControlledItems(items2);
      });
      setup(privateStore, () => {
        return batch(privateStore, ["items"], ({ items: items2 }) => {
          collectionLookup.propagatedItems = items2;
          collection.setState("items", items2);
        });
      });
    }
    setup(privateStore, () => {
      return batch(privateStore, ["renderedItems"], (state) => {
        if (state.renderedItems !== collection.getState().renderedItems) sortItems(state.renderedItems);
        if (typeof IntersectionObserver !== "function") return;
        let firstRun = true;
        let raf = 0;
        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 item of state.renderedItems) {
          if (!item.element) continue;
          observer.observe(item.element);
        }
        return () => {
          cancelAnimationFrame(raf);
          observer.disconnect();
        };
      });
    });
    const createMergeItem = (key, cache, lookup) => {
      const registeredItems2 = lookup?.registeredItems;
      const controlledItems2 = lookup?.controlledItems;
      return (item) => {
        const previousRegisteredItem = registeredItems2?.get(item.id);
        const wasKnown = !!previousRegisteredItem || !!controlledItems2?.has(item.id);
        let prevItem;
        privateStore.setState(key, (items2) => {
          const ids = !!cache.ids || items2.length >= itemIdCacheThreshold && !wasKnown ? getCachedItemIds(items2, cache) : void 0;
          const index2 = ids && !ids.has(item.id) ? -1 : items2.findIndex(({ id: id3 }) => id3 === item.id);
          const nextItems = items2.slice();
          if (index2 !== -1) {
            prevItem = items2[index2];
            const nextItem = {
              ...prevItem,
              ...item
            };
            nextItems[index2] = nextItem;
            registeredItems2?.set(item.id, nextItem);
          } else {
            nextItems.push(item);
            registeredItems2?.set(item.id, item);
            ids?.add(item.id);
          }
          if (cache.ids || index2 === -1 && nextItems.length >= itemIdCacheThreshold) setCachedItemIds(nextItems, cache, ids);
          return nextItems;
        });
        const unmergeItem = () => {
          if (registeredItems2) {
            if (previousRegisteredItem) registeredItems2.set(item.id, previousRegisteredItem);
            else registeredItems2.delete(item.id);
          }
          privateStore.setState(key, (items2) => {
            const ids = cache.ids ? getCachedItemIds(items2, cache) : void 0;
            if (!prevItem) {
              const nextItems2 = items2.filter(({ id: id3 }) => id3 !== item.id);
              ids?.delete(item.id);
              if (cache.ids) setCachedItemIds(nextItems2, cache, ids);
              return nextItems2;
            }
            const index2 = items2.findIndex(({ id: id3 }) => id3 === item.id);
            if (index2 === -1) return items2;
            const nextItems = items2.slice();
            nextItems[index2] = prevItem;
            if (cache.ids) setCachedItemIds(nextItems, cache, ids);
            return nextItems;
          });
        };
        return unmergeItem;
      };
    };
    const registerItem = createMergeItem("items", itemIdCache, collectionLookup);
    const mergeRenderedItem = createMergeItem("renderedItems", renderedItemIdCache);
    return {
      ...collection,
      setState,
      registerItem,
      renderItem: (item) => chain(registerItem(item), mergeRenderedItem(item)),
      item: (id3) => {
        if (!id3) return null;
        if (!registeredItems.size) return controlledItems.get(id3) ?? null;
        return registeredItems.get(id3) ?? controlledItems.get(id3) ?? null;
      },
      __unstablePrivateStore: privateStore
    };
  }

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/node_modules/@ariakit/components/dist/composite/composite-store.js
  var NULL_ITEM = { id: null };
  function findFirstEnabledItem(items, excludeId) {
    return items.find((item) => {
      if (excludeId) return !item.disabled && item.id !== excludeId;
      return !item.disabled;
    });
  }
  function findLastEnabledItem(items) {
    for (let i2 = items.length - 1; i2 >= 0; i2 -= 1) {
      const item = items[i2];
      if (!item) continue;
      if (item.disabled) continue;
      return item;
    }
  }
  function getEnabledItems(items, excludeId) {
    return items.filter((item) => {
      if (excludeId) return !item.disabled && item.id !== excludeId;
      return !item.disabled;
    });
  }
  function getItemsInRow(items, rowId) {
    return items.filter((item) => item.rowId === rowId);
  }
  function findEnabledItemId({ items, fromIndex, step, rowId, excludeId }) {
    for (let i2 = fromIndex; i2 >= 0 && i2 < items.length; i2 += step) {
      const item = items[i2];
      if (!item) continue;
      if (item.rowId !== rowId) continue;
      if (item.disabled) continue;
      const itemId = item.id;
      if (excludeId != null && itemId === excludeId) continue;
      return itemId;
    }
  }
  function flipItems(items, activeId, shouldInsertNullItem = false) {
    const index2 = items.findIndex((item) => item.id === activeId);
    return [
      ...items.slice(index2 + 1),
      ...shouldInsertNullItem ? [NULL_ITEM] : [],
      ...items.slice(0, index2)
    ];
  }
  var rowMapItemThreshold = 48;
  var rowMapRowThreshold = 4;
  function groupSmallItemsByRows(items) {
    const rows = [];
    let previousRow;
    let previousRowId;
    for (const item of items) {
      const rowId = item.rowId;
      if (previousRow && previousRowId === rowId) {
        previousRow.push(item);
        continue;
      }
      const row = rows.find((currentRow) => currentRow[0]?.rowId === rowId);
      if (row) {
        row.push(item);
        previousRow = row;
      } else {
        previousRow = [item];
        rows.push(previousRow);
      }
      previousRowId = rowId;
    }
    return rows;
  }
  function groupLargeItemsByRows(items) {
    const firstItem = items[0];
    if (!firstItem) return [];
    let itemIndex = 1;
    while (itemIndex < items.length && items[itemIndex]?.rowId === firstItem.rowId) itemIndex += 1;
    const firstRow = items.slice(0, itemIndex);
    if (itemIndex === items.length) return [firstRow];
    const rows = [firstRow];
    let rowsById;
    for (; itemIndex < items.length; itemIndex += 1) {
      const item = items[itemIndex];
      if (!item) continue;
      const row = rowsById ? rowsById.get(item.rowId) : rows.find((currentRow) => currentRow[0]?.rowId === item.rowId);
      if (row) {
        row.push(item);
        continue;
      }
      const newRow = [item];
      rows.push(newRow);
      if (rowsById) rowsById.set(item.rowId, newRow);
      else if (rows.length === rowMapRowThreshold) rowsById = new Map(rows.map((currentRow) => [currentRow[0]?.rowId, currentRow]));
    }
    return rows;
  }
  function groupItemsByRows(items) {
    if (items.length >= rowMapItemThreshold) return groupLargeItemsByRows(items);
    return groupSmallItemsByRows(items);
  }
  function getMaxRowLength(array) {
    let maxLength = 0;
    for (const { length } of array) if (length > maxLength) maxLength = length;
    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 i2 = 0; i2 < maxLength; i2 += 1) {
      const item = row[i2];
      if (!item || focusShift && item.disabled) {
        const previousItem = i2 === 0 && focusShift ? findFirstEnabledItem(row) : row[i2 - 1];
        row[i2] = 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 i2 = 0; i2 < maxLength; i2 += 1) for (const row of rows) {
      const item = row[i2];
      if (item) verticalized.push({
        ...item,
        rowId: item.rowId ? `${i2}` : 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 compositeElement = defaultValue(syncState?.compositeElement, syncState?.baseElement, null);
    const compositeElementInFocusOrder = defaultValue(props.compositeElementInFocusOrder, props.includesBaseElement, syncState?.compositeElementInFocusOrder, syncState?.includesBaseElement, activeId === null);
    const initialState2 = {
      ...collection.getState(),
      id: defaultValue(props.id, syncState?.id) ?? `id-${Math.random().toString(36).slice(2, 8)}`,
      activeId,
      compositeElement,
      baseElement: compositeElement,
      compositeElementInFocusOrder,
      includesBaseElement: compositeElementInFocusOrder,
      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)
    };
    const composite = createStore(initialState2, collection, props.store);
    setup(composite, () => chain(sync(composite, ["compositeElement"], (state) => {
      composite.setState("baseElement", state.compositeElement);
    }), sync(composite, ["baseElement"], (state) => {
      composite.setState("compositeElement", state.baseElement);
    }), sync(composite, ["compositeElementInFocusOrder"], (state) => {
      composite.setState("includesBaseElement", state.compositeElementInFocusOrder);
    }), sync(composite, ["includesBaseElement"], (state) => {
      composite.setState("compositeElementInFocusOrder", state.includesBaseElement);
    })));
    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 compositeElementInFocusOrder2 = defaultValue(options2.compositeElementInFocusOrder, options2.includesBaseElement, defaultState.compositeElementInFocusOrder);
      const { skip = 0, activeId: activeId2 = defaultState.activeId, focusShift = defaultState.focusShift, focusLoop = defaultState.focusLoop, focusWrap = defaultState.focusWrap, renderedItems = defaultState.renderedItems, rtl = defaultState.rtl } = options2;
      const isVerticalDirection = direction === "up" || direction === "down";
      const isNextDirection = direction === "next" || direction === "down";
      const canReverse = isNextDirection ? rtl && !isVerticalDirection : !rtl || isVerticalDirection;
      const canShift = focusShift && !skip;
      if (!skip && !focusWrap && !compositeElementInFocusOrder2 && activeId2 != null) {
        if (!isVerticalDirection ? true : !canShift && !renderedItems.some((item) => item.rowId != null)) {
          let activeIndex2 = -1;
          if (renderedItems === defaultState.renderedItems) {
            const firstItem = renderedItems[0];
            if (firstItem && collection.item(firstItem.id) === firstItem) {
              const registeredItem = collection.item(activeId2);
              if (registeredItem?.id === activeId2) activeIndex2 = renderedItems.indexOf(registeredItem);
            }
          }
          if (activeIndex2 === -1) activeIndex2 = renderedItems.findIndex((item) => item.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((item) => item.id === activeId2);
      if (!activeItem) return findFirstEnabledItem(items)?.id;
      const isGrid2 = items.some((item) => item.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 && compositeElementInFocusOrder2 : isVerticalDirection ? compositeElementInFocusOrder2 : 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,
      setCompositeElement: (element) => composite.setState("compositeElement", element),
      setBaseElement: (element) => composite.setState("compositeElement", 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: () => findLastEnabledItem(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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/composite/utils.js
  var flipItems2 = flipItems;
  var findFirstEnabledItem2 = findFirstEnabledItem;
  var groupItemsByRows2 = groupItemsByRows;
  var unmountingItems = /* @__PURE__ */ new WeakSet();
  function markItemUnmounting(element) {
    if (getActiveElement(element) !== element) return;
    unmountingItems.add(element);
    queueMicrotask(() => unmountingItems.delete(element));
  }
  function markItemMounted(element) {
    unmountingItems.delete(element);
  }
  function withCompositeScrollPreserved(store, callback) {
    const { virtualFocus, compositeElement } = store.getState();
    if (!virtualFocus || !compositeElement || !isTextField(compositeElement)) {
      callback();
      return;
    }
    const savedScrollLeft = compositeElement.scrollLeft;
    const savedScrollTop = compositeElement.scrollTop;
    callback();
    compositeElement.scrollLeft = savedScrollLeft;
    compositeElement.scrollTop = savedScrollTop;
  }
  function getPopupElement(store) {
    const state = store.getState();
    if (!("contentElement" in state)) return null;
    return state.contentElement;
  }
  function ownsFocus(store) {
    const { compositeElement } = store.getState();
    const activeElement2 = getTreeActiveElement(compositeElement);
    if (!activeElement2) return false;
    if (compositeElement?.contains(activeElement2)) return true;
    if (isItem(store, activeElement2)) return true;
    return !!getPopupElement(store)?.contains(activeElement2);
  }
  function presentItem({ store, id: id3, focus: focus5, markedOnly, requireFocus, focusOwner, scrollIntoView, onConsume }) {
    let element = null;
    let resolvedId;
    let focused = false;
    let focusLeftElement = false;
    let done = false;
    let wasMounted = false;
    let wasOpen = false;
    const compositeAtStart = store.getState().compositeElement;
    const activeAtStart = getTreeActiveElement(compositeAtStart);
    const owner = requireFocus ? focusOwner || activeAtStart : null;
    const startedOnComposite = !!compositeAtStart?.contains(activeAtStart);
    const stillOwnsFocus = (target) => {
      if (!owner) return true;
      const activeElement2 = getTreeActiveElement(owner);
      if (activeElement2 === owner) return true;
      if (activeElement2 === target) return true;
      return ownsFocus(store);
    };
    const abandonedByState = (state) => {
      if ("mounted" in state) {
        if (state.mounted) wasMounted = true;
        else if (wasMounted) return true;
      }
      if ("open" in state) {
        if (state.open) wasOpen = true;
        else if (wasOpen) return true;
      }
      return id3 != null && state.activeId != null && state.activeId !== id3;
    };
    const entersClosedPopup = (state, target) => {
      if (!("open" in state)) return false;
      if (state.open) return false;
      const popup = getPopupElement(store);
      if (!popup?.contains(target)) return false;
      const { compositeElement } = state;
      if (!compositeElement) return false;
      if (popup.contains(compositeElement)) return false;
      return isVisible(target);
    };
    const resolveElement = (state) => {
      const item = getEnabledItem(store, resolvedId ?? (id3 === void 0 ? state.activeId : id3));
      if (!item?.element?.isConnected) return null;
      resolvedId = item.id;
      return item.element;
    };
    let removeFocusListeners;
    let cancelScroll;
    let unsubscribe;
    const cancel = () => {
      done = true;
      removeFocusListeners?.();
      cancelScroll?.();
      unsubscribe?.();
    };
    let consumed = false;
    const consume = () => {
      if (consumed) return;
      consumed = true;
      onConsume?.();
    };
    const settle = () => {
      cancelScroll?.();
      if (done) return;
      consume();
      return cancel();
    };
    const present = () => {
      if (done) return;
      const state = store.getState();
      if (abandonedByState(state)) return settle();
      let restoreFocus = false;
      if (!element) {
        element = resolveElement(state);
        if (!element) return;
      } else if (!element.isConnected) {
        restoreFocus = focused && !focusLeftElement && getActiveElement(element) === getDocument(element).body;
        element = resolveElement(state);
        if (!element) return settle();
      }
      if (restoreFocus) focused = false;
      else if (!stillOwnsFocus(element)) return settle();
      const focusWithheld = focus5 && startedOnComposite && entersClosedPopup(state, element);
      if (focusWithheld) {
        const { activeId } = state;
        if (activeId != null && activeId !== resolvedId) return settle();
      }
      if (focus5 && !focused && !focusWithheld) {
        focused = true;
        consume();
        focusLeftElement = false;
        const itemElement = element;
        removeFocusListeners?.();
        const onBlur = () => {
          focusLeftElement = !unmountingItems.has(itemElement);
        };
        const onFocus = () => {
          focusLeftElement = false;
        };
        itemElement.addEventListener("blur", onBlur);
        itemElement.addEventListener("focus", onFocus);
        removeFocusListeners = () => {
          itemElement.removeEventListener("blur", onBlur);
          itemElement.removeEventListener("focus", onFocus);
        };
        withCompositeScrollPreserved(store, () => {
          itemElement.focus({ preventScroll: true });
        });
        if (done) return;
      }
      if (markedOnly && !element.hasAttribute("data-autofocus")) {
        if (focusWithheld) return;
        return settle();
      }
      if (!isVisible(element)) return;
      if ("unstable_placing" in state && state.unstable_placing) return;
      if (!focusWithheld) settle();
      const scrollTarget = element;
      cancelScroll?.();
      cancelScroll = prepareScrollIntoView({
        element: scrollTarget,
        isCurrent: () => {
          const state2 = store.getState();
          if (abandonedByState(state2)) return false;
          if (state2.activeId !== resolvedId) return false;
          return stillOwnsFocus(scrollTarget);
        }
      });
      if (scrollIntoView) {
        scrollIntoView(element);
        return;
      }
      element.scrollIntoView({
        block: "nearest",
        inline: "nearest"
      });
    };
    unsubscribe = subscribe(store, [
      "activeId",
      "items",
      "mounted",
      "open",
      "unstable_placing"
    ], present);
    present();
    return Object.assign(cancel, { settle });
  }
  function usePresentItem(store) {
    const cancelRef = (0, import_react7.useRef)(null);
    const ownerRef = (0, import_react7.useRef)(store);
    const cancel = (0, import_react7.useCallback)(() => {
      cancelRef.current?.();
      cancelRef.current = null;
    }, []);
    const present = (0, import_react7.useCallback)((params) => {
      if (!store) return;
      if (ownerRef.current !== store) return;
      cancelRef.current?.settle();
      cancelRef.current = null;
      const cancelCurrent = presentItem({
        store,
        ...params
      });
      cancelRef.current = cancelCurrent;
      return cancelCurrent;
    }, [store]);
    useSafeLayoutEffect(() => {
      ownerRef.current = store;
      return () => {
        ownerRef.current = void 0;
        cancel();
      };
    }, [store, cancel]);
    return present;
  }
  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 item = store.item(element.id);
    if (!item) return false;
    if (exclude && item.element === exclude) return false;
    return true;
  }

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

  // node_modules/.store/@ariakit/react-store@0.1.13-C6ZWls7CuvAmgvZYqqkd5Q/node_modules/@ariakit/react-store/dist/index.js
  var React2 = __toESM(require_react(), 1);
  var import_shim = __toESM(require_shim(), 1);
  var noopSubscribe = () => () => {
  };
  function isStoreKeyArray(value) {
    return Array.isArray(value);
  }
  function isSameValue2(value, other) {
    return value === other || value !== value && other !== other;
  }
  function hasSameStoreKeys(keys, otherKeys) {
    if (keys?.length !== otherKeys.length) return false;
    for (let index2 = 0; index2 < keys.length; index2 += 1) {
      const key = keys[index2];
      if (isSameValue2(key, otherKeys[index2])) continue;
      return false;
    }
    return true;
  }
  function useStableStoreKeys(keys) {
    const [stableKeys, setStableKeys] = React2.useState(() => keys === null ? null : [...keys]);
    if (keys === null) {
      if (stableKeys !== null) setStableKeys(null);
      return null;
    }
    if (hasSameStoreKeys(stableKeys, keys)) return stableKeys;
    const nextKeys = [...keys];
    setStableKeys(nextKeys);
    return nextKeys;
  }
  function useStoreState(store, keyOrKeysOrSelector = identity, selector2) {
    const subscriptionKeys = useStableStoreKeys(isStoreKeyArray(keyOrKeysOrSelector) ? keyOrKeysOrSelector : typeof keyOrKeysOrSelector === "function" ? null : [keyOrKeysOrSelector]);
    const storeSubscribe = React2.useCallback((callback) => {
      if (!store) return noopSubscribe();
      if (subscriptionKeys?.length === 0) return noopSubscribe();
      return subscribe(store, subscriptionKeys, callback);
    }, [store, subscriptionKeys]);
    const getSnapshot = () => {
      const state = store?.getState();
      if (isStoreKeyArray(keyOrKeysOrSelector)) return selector2?.(state);
      if (typeof keyOrKeysOrSelector === "function") return keyOrKeysOrSelector(state);
      if (!state) return;
      if (!hasOwnProperty(state, keyOrKeysOrSelector)) return;
      return state[keyOrKeysOrSelector];
    };
    return (0, import_shim.useSyncExternalStore)(storeSubscribe, getSnapshot, getSnapshot);
  }
  function getStoreStateObjectKeys(object, selectorKeys) {
    const keys = [];
    let hasSelector = false;
    for (const prop in object) {
      const keyOrSelector = object[prop];
      if (keyOrSelector === void 0) continue;
      if (typeof keyOrSelector === "function") {
        hasSelector = true;
        continue;
      }
      if (keys.includes(keyOrSelector)) continue;
      keys.push(keyOrSelector);
    }
    if (!hasSelector) return keys;
    if (!selectorKeys) return null;
    for (const key of selectorKeys) {
      if (keys.includes(key)) continue;
      keys.push(key);
    }
    return keys;
  }
  function useStoreStateObject(store, objectOrKeys, object) {
    const stateObject = isStoreKeyArray(objectOrKeys) ? object ?? {} : objectOrKeys;
    const selectorKeys = isStoreKeyArray(objectOrKeys) ? objectOrKeys : void 0;
    const objRef = React2.useRef({});
    const subscriptionKeys = useStableStoreKeys(getStoreStateObjectKeys(stateObject, selectorKeys));
    const storeSubscribe = React2.useCallback((callback) => {
      if (!store) return noopSubscribe();
      if (subscriptionKeys?.length === 0) return noopSubscribe();
      return subscribe(store, subscriptionKeys, callback);
    }, [store, subscriptionKeys]);
    const getSnapshot = () => {
      const state = store?.getState();
      let updated = false;
      const obj = objRef.current;
      for (const prop in stateObject) {
        const keyOrSelector = stateObject[prop];
        if (keyOrSelector === void 0) continue;
        if (typeof keyOrSelector === "function") {
          const value2 = keyOrSelector(state);
          if (!Object.is(value2, obj[prop])) {
            obj[prop] = value2;
            updated = true;
          }
        }
        if (typeof keyOrSelector === "function") continue;
        const value = state && hasOwnProperty(state, keyOrSelector) ? state[keyOrSelector] : void 0;
        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 setValue = setKey ? props[setKey] : void 0;
    const hasSetValue = !!setValue;
    const propsRef = useLiveRef({
      value,
      setValue
    });
    useSafeLayoutEffect(() => {
      if (!hasSetValue) return;
      return subscribe(store, [key], (state, prev) => {
        const { value: value2, setValue: setValue2 } = propsRef.current;
        if (!setValue2) return;
        if (isSameValue2(state[key], prev[key])) return;
        if (isSameValue2(state[key], value2)) return;
        setValue2(state[key]);
      });
    }, [
      store,
      key,
      hasSetValue,
      propsRef
    ]);
    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 useState105 = React2.useCallback((keyOrSelector) => useStoreState(store, keyOrSelector), [store]);
    return [React2.useMemo(() => ({
      ...store,
      useState: useState105
    }), [store, useState105]), useEvent(() => {
      setStore((store2) => createStore2({
        ...props,
        ...store2.getState()
      }));
    })];
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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, next, pageUp = false) {
    if (!store) return;
    if (!next) return;
    const { renderedItems } = store.getState();
    const scrollingElement = getScrollingElement(element);
    if (!scrollingElement) return;
    const nextPageOffset = getNextPageOffset(scrollingElement, pageUp);
    let id3;
    let prevDifference;
    for (let i2 = 0; i2 < renderedItems.length; i2 += 1) {
      const previousId = id3;
      id3 = next(i2);
      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: tabbable2 = false, getItem: getItemProp, typeaheadText, "aria-setsize": ariaSetSizeProp, "aria-posinset": ariaPosInSetProp, unstable_scrollIntoView: scrollIntoView, ...props }) {
    const context = useCompositeScopedContext();
    store = store || context;
    const accessibleWhenDisabled = accessibleWhenDisabledFromProps(props);
    const id3 = useId(props.id);
    const ref = (0, import_react8.useRef)(null);
    const mountedElementRef = (0, import_react8.useRef)(null);
    const markUnmountingRef = (0, import_react8.useCallback)((element) => {
      const mountedElement = mountedElementRef.current;
      if (!element && mountedElement) markItemUnmounting(mountedElement);
      if (element) markItemMounted(element);
      mountedElementRef.current = element;
    }, []);
    const row = (0, import_react8.useContext)(CompositeRowContext);
    const disabled2 = disabledFromProps(props);
    const trulyDisabled = disabled2 && !accessibleWhenDisabled;
    const inactiveDisabled = disabled2 && props.focusable === false;
    const shouldRegisterItem = props.shouldRegisterItem;
    const getRowId = (state) => {
      if (rowIdProp) return rowIdProp;
      if (!state) return;
      if (!row?.compositeElement) return;
      if (row.compositeElement !== state.compositeElement) return;
      return row.id;
    };
    const { rowId, compositeElement, ariaSetSize, ariaPosInSet } = useStoreStateObject(store, ["compositeElement", "renderedItems"], {
      rowId: getRowId,
      compositeElement(state) {
        return state?.compositeElement || void 0;
      },
      ariaSetSize(state) {
        if (ariaSetSizeProp != null) return ariaSetSizeProp;
        if (!state) return;
        if (!row?.ariaSetSize) return;
        if (row.compositeElement !== state.compositeElement) return;
        return row.ariaSetSize;
      },
      ariaPosInSet(state) {
        if (ariaPosInSetProp != null) return ariaPosInSetProp;
        if (!state) return;
        if (!row?.ariaPosInSet) return;
        if (row.compositeElement !== state.compositeElement) return;
        const rowId2 = getRowId(state);
        const itemsInRow = state.renderedItems.filter((item) => item.rowId === rowId2);
        return row.ariaPosInSet + itemsInRow.findIndex((item) => item.id === id3);
      }
    });
    const { isActiveItem, isTabbable: isTabbable3 } = useStoreStateObject(store, [
      "activeId",
      "compositeElement",
      "renderedItems",
      "virtualFocus",
      "items"
    ], {
      isActiveItem(state) {
        return !!state && state.activeId === id3;
      },
      isTabbable(state) {
        if (!state) return true;
        if (!state.compositeElement && !state.renderedItems.length) return true;
        if (state.virtualFocus) return false;
        if (!state.renderedItems.length) return true;
        if (tabbable2) return true;
        if (state.activeId === null) return false;
        const item = store?.item(state.activeId);
        if (item?.disabled) return true;
        if (!item?.element) return true;
        return state.activeId === id3;
      }
    });
    const getItem = (0, import_react8.useCallback)((item) => {
      const itemDisabled = (item.element ? resolvedTrulyDisabledFromElement(item.element) : void 0) ?? (inactiveDisabled || trulyDisabled);
      const nextItem = {
        ...item,
        id: id3 || item.id,
        rowId,
        disabled: itemDisabled,
        children: item.element?.textContent,
        typeaheadText
      };
      if (getItemProp) return getItemProp(nextItem);
      return nextItem;
    }, [
      id3,
      rowId,
      inactiveDisabled,
      trulyDisabled,
      typeaheadText,
      getItemProp
    ]);
    const onFocusProp = props.onFocus;
    const hasFocusedComposite = (0, import_react8.useRef)(false);
    const cancelScheduledFocusRedirectRef = (0, import_react8.useRef)(null);
    const present = usePresentItem(store);
    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, compositeElement: compositeElement2 } = store.getState();
      store.setActiveId(id3);
      if (isTextbox(event.currentTarget)) selectTextField(event.currentTarget);
      if (!virtualFocus) {
        if (isSelfTarget(event) && store.item(id3)) present({
          id: id3,
          markedOnly: true,
          requireFocus: true,
          scrollIntoView
        });
        return;
      }
      if (!isSelfTarget(event)) return;
      if (isEditableElement(event.currentTarget)) return;
      const redirectFocusToCompositeElement = (relatedTarget2, compositeElement3) => {
        if (!isFocusable(compositeElement3)) {
          if (true) warnOnce("A composite widget with `virtualFocus` enabled requires a focusable composite element. Set the `focusable` prop to `true` or the `virtualFocus` option to `false`.", compositeElement3);
          return;
        }
        const fromComposite = relatedTarget2 === compositeElement3 || isItem(store, relatedTarget2);
        if (store.item(id3)) present({
          id: id3,
          markedOnly: true,
          requireFocus: true,
          scrollIntoView
        });
        hasFocusedComposite.current = true;
        if (fromComposite) focusSilently(compositeElement3);
        else compositeElement3.focus({ preventScroll: true });
      };
      if (compositeElement2?.isConnected) {
        redirectFocusToCompositeElement(event.relatedTarget, compositeElement2);
        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 nextCompositeElement = state.compositeElement;
        if (!nextCompositeElement?.isConnected) return;
        cancelScheduledFocusRedirect();
        if (!state.virtualFocus) return;
        redirectFocusToCompositeElement(relatedTarget, nextCompositeElement);
      });
    });
    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.compositeElement) return true;
        if (!isTextField(state.compositeElement)) 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_react8.useMemo)(() => ({
      id: id3,
      compositeElement
    }), [id3, compositeElement]);
    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, markUnmountingRef, props.ref),
      tabIndex: isTabbable3 ? props.tabIndex : -1,
      onFocus,
      onBlurCapture,
      onKeyDown
    };
    props = useCommand(props);
    props = useCollectionItem({
      store,
      ...props,
      getItem,
      shouldRegisterItem: id3 ? shouldRegisterItem : false
    });
    return {
      ...props,
      "aria-setsize": ariaSetSize,
      "aria-posinset": ariaPosInSet
    };
  });
  var CompositeItem = memo2(forwardRef2(function CompositeItem2(props) {
    const htmlProps = useCompositeItem(withDefaultButtonType(props));
    return createElement(TagName4, htmlProps);
  }));

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/tab/tab.js
  var import_react9 = __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_react9.useCallback)((item) => {
      const nextItem = {
        ...item,
        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, ["items"], () => store.panel(id3)?.id);
    const shouldRegisterItem = defaultId ? props.shouldRegisterItem : false;
    const selected = useStoreState(store, ["selectedId"], (state) => !!id3 && state.selectedId === id3);
    const canRegisterComposedItem = useStoreState(store.composite ? store : void 0, [
      "activeId",
      "items",
      "selectedId"
    ], (state) => {
      if (!state) return false;
      if (!id3) return false;
      if (state.activeId === id3) return true;
      if (state.selectedId !== id3) return false;
      return !store.item(state.activeId);
    });
    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) {
    const htmlProps = useTab(withDefaultButtonType(props));
    return createElement(TagName5, htmlProps);
  }));

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/CDh2UhnG.js
  var sourceEvents = /* @__PURE__ */ new WeakMap();
  function fireProxiedKeyboardEvent(element, source, eventInit) {
    const { KeyboardEvent } = getWindow(element);
    const event = new KeyboardEvent(source.type, eventInit);
    sourceEvents.set(event, getKeyboardEventSource(source));
    return element.dispatchEvent(event);
  }
  function getKeyboardEventSource(event) {
    return sourceEvents.get(event) ?? event;
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/xFYjARz5.js
  var cancelled = /* @__PURE__ */ Symbol("cancelled");
  var moveRequests = /* @__PURE__ */ new WeakMap();
  function getMoveRequest(store, source) {
    const key = store.getState;
    const cached = moveRequests.get(key);
    if (cached) return cached;
    const sourceState = source?.getState();
    if (source && sourceState && hasOwnProperty(sourceState, "moves") && hasOwnProperty(sourceState, "activeId")) {
      const request2 = getMoveRequest(source);
      moveRequests.set(key, request2);
      return request2;
    }
    const request = {
      consumedBy: null,
      targetId: store.getState().activeId
    };
    moveRequests.set(key, request);
    sync(store, ["moves", "activeId"], (state, prevState) => {
      if (state.moves !== prevState.moves) {
        request.consumedBy = null;
        request.targetId = state.activeId;
        return;
      }
      if (state.activeId !== prevState.activeId) request.targetId = cancelled;
    });
    return request;
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/composite/composite.js
  var import_react10 = __toESM(require_react(), 1);
  var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
  var TagName6 = "div";
  function isGrid(items) {
    return items.some((item) => !!item.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 state = store.getState();
      const activeElement2 = getEnabledItem(store, state.activeId)?.element;
      if (!activeElement2) return;
      const { view: view2, ...eventInit } = event;
      if (activeElement2 !== previousElementRef?.current) activeElement2.focus({ preventScroll: true });
      if (!fireProxiedKeyboardEvent(activeElement2, event.nativeEvent, eventInit)) event.preventDefault();
      if (event.currentTarget.contains(activeElement2)) event.stopPropagation();
    });
  }
  function findFirstEnabledItemInTheLastRow(items) {
    return findFirstEnabledItem2(flatten2DArray(reverseArray(groupItemsByRows2(items))));
  }
  function mayActOnMove(store, instance) {
    const { consumedBy } = getMoveRequest(store);
    return !consumedBy || consumedBy === instance;
  }
  function consumeMove(store, instance, moves) {
    if (store.getState().moves !== moves) return;
    getMoveRequest(store).consumedBy = instance;
  }
  var CompositeFocusOnMove = memo2(function CompositeFocusOnMove2({ store, focusOnMove, previousElementRef, present, scrollIntoView }) {
    const moves = useStoreState(store, "moves");
    const compositeElement = useStoreState(store, "compositeElement");
    const instance = (0, import_react10.useMemo)(() => ({}), [store.getState]);
    (0, import_react10.useEffect)(() => {
      const moveRequest = getMoveRequest(store);
      if (!moves) return;
      if (!focusOnMove) return;
      if (!mayActOnMove(store, instance)) return;
      const { activeId } = store.getState();
      if (activeId == null) return;
      if (activeId !== moveRequest.targetId) return;
      return present({
        id: activeId,
        requireFocus: ownsFocus(store),
        focus: true,
        scrollIntoView,
        onConsume: () => consumeMove(store, instance, moves)
      });
    }, [
      store,
      moves,
      focusOnMove,
      compositeElement,
      present,
      scrollIntoView,
      instance
    ]);
    useSafeLayoutEffect(() => {
      const moveRequest = getMoveRequest(store);
      if (!moves) return;
      if (!compositeElement) return;
      if (!mayActOnMove(store, instance)) return;
      const { activeId } = store.getState();
      if (!(activeId === null)) return;
      if (activeId !== moveRequest.targetId) return;
      consumeMove(store, instance, moves);
      const previousElement = previousElementRef.current;
      previousElementRef.current = null;
      if (previousElement) fireBlurEvent(previousElement, { relatedTarget: compositeElement });
      if (!hasFocus(compositeElement)) {
        if (isFocusable(compositeElement)) compositeElement.scrollIntoView({
          block: "nearest",
          inline: "nearest"
        });
        compositeElement.focus({ preventScroll: true });
      }
    }, [
      store,
      moves,
      compositeElement,
      previousElementRef,
      instance
    ]);
    return null;
  });
  var useComposite = createHook(function useComposite2({ store, composite = true, focusOnMove = composite, moveOnKeyPress = true, unstable_scrollIntoView: scrollIntoView, ...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_react10.useRef)(null);
    const previousElementRef = (0, import_react10.useRef)(null);
    const present = usePresentItem(store);
    const scheduleFocusUpdateRef = (0, import_react10.useRef)(void 0);
    useSafeLayoutEffect(() => {
      if (!composite) return;
      let focusElement = null;
      let pending = false;
      let disposed = false;
      const update2 = () => {
        pending = false;
        if (disposed) return;
        const { activeId: activeId2, compositeElement } = store.getState();
        const ownerHasFocus = !!compositeElement && compositeElement === ref.current && getTreeActiveElement(compositeElement) === compositeElement;
        const itemElement = store.item(activeId2)?.element;
        const nextElement = ownerHasFocus && itemElement?.isConnected && itemElement !== compositeElement ? itemElement : null;
        if (focusElement === nextElement) return;
        focusElement?.removeAttribute("data-focus");
        nextElement?.setAttribute("data-focus", "true");
        focusElement = nextElement;
      };
      const schedule = () => {
        if (pending) return;
        pending = true;
        queueMicrotask(update2);
      };
      scheduleFocusUpdateRef.current = schedule;
      const unsubscribe = subscribe(store, [
        "activeId",
        "items",
        "compositeElement"
      ], schedule);
      schedule();
      return () => {
        disposed = true;
        scheduleFocusUpdateRef.current = void 0;
        unsubscribe();
        focusElement?.removeAttribute("data-focus");
      };
    }, [store, composite]);
    const [, setCompositeElement] = useTransactionState(composite ? store.setCompositeElement : null);
    const virtualFocus = useStoreState(store, "virtualFocus");
    const activeId = useStoreState(store, composite && virtualFocus ? ["activeId"] : [], (state) => composite && 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) => {
      scheduleFocusUpdateRef.current?.();
      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(() => present({
          focus: true,
          markedOnly: true,
          requireFocus: true,
          scrollIntoView
        }));
      } else if (isSelfTarget(event)) {
        if (!isItem(store, relatedTarget)) {
          const { activeId: activeId2 } = store.getState();
          if (activeId2 != null) present({
            id: activeId2,
            markedOnly: true,
            requireFocus: true,
            scrollIntoView
          });
        }
        store.setActiveId(null);
      }
    });
    const onBlurCaptureProp = props.onBlurCapture;
    const onBlurCapture = useEvent((event) => {
      scheduleFocusUpdateRef.current?.();
      onBlurCaptureProp?.(event);
      if (event.defaultPrevented) return;
      if (!store) return;
      const { virtualFocus: virtualFocus2, activeId: activeId2, compositeElement } = store.getState();
      if (!virtualFocus2) return;
      if (event.currentTarget !== compositeElement) return;
      const activeElement2 = 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 === activeElement2) {
          if (previousElement && previousElement !== nextActiveElement) fireBlurEvent(previousElement, event);
        } else if (activeElement2) fireBlurEvent(activeElement2, event);
        else if (previousElement) fireBlurEvent(previousElement, event);
        event.stopPropagation();
      } else if (!isItem(store, event.target) && activeElement2) fireBlurEvent(activeElement2, 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, items, renderedItems, activeId: activeId2, rtl } = store.getState();
      const activeItem = getEnabledItem(store, activeId2);
      if (activeItem?.element?.isConnected) return;
      const elementlessActiveItem = activeItem && activeId2 != null;
      const movementItems = elementlessActiveItem ? items : renderedItems;
      const isVertical = orientation !== "horizontal";
      const isHorizontal = orientation !== "vertical";
      const grid = isGrid(movementItems);
      if ((event.key === "ArrowLeft" || event.key === "ArrowRight" || event.key === "Home" || event.key === "End") && isTextField(event.currentTarget)) return;
      const up = () => {
        if (elementlessActiveItem) return store.up({
          activeId: activeId2,
          renderedItems: movementItems
        });
        if (grid) return findFirstEnabledItemInTheLastRow(renderedItems)?.id;
        return store?.last();
      };
      const right = () => {
        if (elementlessActiveItem) return store.next({
          activeId: activeId2,
          renderedItems: movementItems
        });
        return rtl ? store.last() : store.first();
      };
      const down = () => {
        if (elementlessActiveItem) return store.down({
          activeId: activeId2,
          renderedItems: movementItems
        });
        return store.first();
      };
      const left = () => {
        if (elementlessActiveItem) return store.previous({
          activeId: activeId2,
          renderedItems: movementItems
        });
        return rtl ? store.first() : store.last();
      };
      const action = {
        ArrowUp: (grid || isVertical) && up,
        ArrowRight: (grid || isHorizontal) && right,
        ArrowDown: (grid || isVertical) && down,
        ArrowLeft: (grid || isHorizontal) && left,
        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,
        present,
        scrollIntoView
      })]
    }), [
      store,
      composite,
      focusOnMove,
      present
    ]);
    props = {
      "aria-activedescendant": useStoreState(store, composite && virtualFocus ? ["items"] : [], () => {
        if (!store) return;
        if (!composite) return;
        if (!virtualFocus) return;
        return getEnabledItem(store, activeId)?.id;
      }),
      ...props,
      ref: useMergeRefs(ref, setCompositeElement, props.ref),
      onKeyDownCapture,
      onKeyUpCapture,
      onFocusCapture,
      onFocus,
      onBlurCapture,
      onKeyDown
    };
    const focusable2 = useStoreState(store, composite && !virtualFocus ? ["activeId"] : [], (state) => composite && (virtualFocus || state.activeId === null));
    props = useFocusable({
      focusable: focusable2,
      ...props
    });
    return props;
  });
  var Composite = forwardRef2(function Composite2(props) {
    const htmlProps = useComposite(props);
    return createElement(TagName6, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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, ["orientation"], (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) {
    const htmlProps = useTabList(props);
    return createElement(TagName7, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/dialog-context.js
  var import_react11 = __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_react11.createContext)(void 0);
  var DialogDescriptionContext = (0, import_react11.createContext)(void 0);

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/disclosure/disclosure-content.js
  var import_react12 = __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_react12.useRef)(null);
    const id3 = useId(props.id);
    const [transition, setTransition] = (0, import_react12.useState)(null);
    const { open: open2, mounted, animated, contentElement } = useStoreStateObject(store, {
      open: "open",
      mounted: "mounted",
      animated: "animated",
      contentElement: "contentElement"
    });
    const otherElement = useStoreState(store.disclosure, "contentElement");
    const hasClosedRef = (0, import_react12.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 (!open2) {
          hasClosedRef.current = true;
          setTransition(null);
        } else if (hasClosedRef.current) {
          hasClosedRef.current = false;
          setTransition("enter");
        }
        return;
      }
      if (!contentElement?.isConnected) {
        setTransition(null);
        return;
      }
      return afterPaint(() => {
        setTransition(open2 ? "enter" : mounted ? "leave" : null);
      });
    }, [
      animated,
      contentElement,
      open2,
      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" && open2) return;
      if (transition === "enter" && !open2) 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,
      open2,
      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_react12.useMemo)(() => {
      if (hidden) return {
        ...styleProp,
        display: "none"
      };
      return styleProp;
    }, [hidden, styleProp]);
    props = {
      "data-open": open2 || 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) {
    const htmlProps = useDisclosureContent(props);
    return createElement(TagName8, htmlProps);
  });
  var DisclosureContent = forwardRef2(function DisclosureContent2({ unmountOnHide, ...props }) {
    const context = useDisclosureProviderContext();
    const store = props.store || context;
    if (useStoreState(store, ["mounted"], (state) => !unmountOnHide || state?.mounted) === false) return null;
    return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DisclosureContentImpl, { ...props });
  });

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/node_modules/@ariakit/components/dist/disclosure/disclosure-store.js
  function getParentHideRequest(store) {
    const onHideRequest = store?.unstable_onHideRequest;
    const requestHide = store?.unstable_requestHide;
    if (!onHideRequest) return;
    if (!requestHide) return;
    return {
      onHideRequest,
      requestHide
    };
  }
  function createDisclosureStore(props = {}) {
    const store = props.store || props.disclosure ? mergeStore(props.store, omit2(props.disclosure, ["contentElement", "disclosureElement"])) : void 0;
    throwOnConflictingProps(props, store);
    const syncState = store?.getState();
    const open2 = defaultValue(props.open, syncState?.open, props.defaultOpen, false);
    const animated = defaultValue(props.animated, syncState?.animated, false);
    const initialState2 = {
      open: open2,
      animated,
      animating: !!animated && open2,
      mounted: open2,
      contentElement: defaultValue(syncState?.contentElement, null),
      disclosureElement: defaultValue(syncState?.disclosureElement, null)
    };
    const disclosure = store ? createStore(initialState2, store) : createStore(initialState2);
    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);
    }));
    const parentHideRequest = getParentHideRequest(props.store);
    const hideHandlers = /* @__PURE__ */ new Map();
    const onHideRequest = parentHideRequest?.onHideRequest ?? ((handler) => {
      if (handler === requestHide) return () => {
      };
      hideHandlers.set(handler, (hideHandlers.get(handler) ?? 0) + 1);
      return () => {
        const count = hideHandlers.get(handler);
        if (count == null) return;
        if (count > 1) {
          hideHandlers.set(handler, count - 1);
          return;
        }
        hideHandlers.delete(handler);
      };
    });
    const requestHide = parentHideRequest?.requestHide ?? ((hide5) => {
      const handlers = [...hideHandlers.keys()];
      const runHandler = (index2) => {
        const handler = handlers[index2];
        if (!handler) {
          hide5();
          return;
        }
        handler(() => runHandler(index2 + 1));
      };
      runHandler(0);
    });
    setup(disclosure, () => {
      if (!props.disclosure) return;
      return onHideRequest(props.disclosure.unstable_requestHide);
    });
    const setOpen = (value) => {
      const { open: open3 } = disclosure.getState();
      const nextOpen = applyState(value, open3);
      if (!open3 || nextOpen) {
        disclosure.setState("open", nextOpen);
        return;
      }
      requestHide(() => disclosure.setState("open", false));
    };
    return {
      ...disclosure,
      disclosure: props.disclosure,
      setOpen,
      show: () => disclosure.setState("open", true),
      hide: () => setOpen(false),
      toggle: () => setOpen((open3) => !open3),
      unstable_onHideRequest: onHideRequest,
      unstable_requestHide: requestHide,
      stopAnimation: () => disclosure.setState("animating", false),
      setContentElement: (value) => disclosure.setState("contentElement", value),
      setDisclosureElement: (value) => disclosure.setState("disclosureElement", value)
    };
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/disclosure/disclosure-store.js
  function useDisclosureStoreProps(store, update2, props) {
    useUpdateEffect(update2, [
      props.store,
      props.disclosure,
      update2
    ]);
    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, update2] = useStore(createDisclosureStore, props);
    return useDisclosureStoreProps(store, update2, props);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/tab/tab-panel.js
  var import_react13 = __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_react13.useRef)(null);
    const id3 = useId(props.id);
    const tabId = useStoreState(tabIdProp ? void 0 : store.panels, ["items"], () => tabIdProp || store?.panels.item(id3)?.tabId);
    const open2 = useStoreState(store, ["selectedId"], (state) => !!tabId && state.selectedId === tabId);
    const disclosure = useDisclosureStore({ open: open2 });
    const mounted = useStoreState(disclosure, "mounted");
    const scrollPositionRef = (0, import_react13.useRef)(null);
    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_react13.useEffect)(() => {
      if (!scrollRestoration) return;
      if (!mounted) return;
      const element = getScrollElement();
      if (!element) return;
      if (scrollRestoration === "reset") {
        element.scroll(0, 0);
        return;
      }
      if (!tabId) return;
      let scrollPositions = scrollPositionRef.current;
      if (!scrollPositions) {
        scrollPositions = /* @__PURE__ */ new Map();
        scrollPositionRef.current = scrollPositions;
      }
      const position = scrollPositions.get(tabId);
      element.scroll(position?.x ?? 0, position?.y ?? 0);
      const onScroll = () => {
        scrollPositions.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_react13.useState)(false);
    useSafeLayoutEffect(() => {
      if (!mounted) return;
      const element = ref.current;
      if (!element) return;
      setHasTabbableChildren(!!getFirstTabbableIn(element));
    }, [mounted, tabId]);
    const getItem = (0, import_react13.useCallback)((item) => {
      const nextItem = {
        ...item,
        id: id3 || item.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) {
    const htmlProps = useTabPanel(props);
    return createElement(TagName9, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/combobox/combobox-context.js
  var import_react14 = __toESM(require_react(), 1);
  var ComboboxListRoleContext = (0, import_react14.createContext)(null);
  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_react14.createContext)(void 0);
  var ComboboxItemCheckedContext = (0, import_react14.createContext)(false);
  var ComboboxHeadingContext = (0, import_react14.createContext)(null);

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/composite/composite-store.js
  function useCompositeStoreOptions(props) {
    return {
      id: useId(props.id),
      ...props
    };
  }
  function useCompositeStoreProps(store, update2, props) {
    store = useCollectionStoreProps(store, update2, props);
    getMoveRequest(store, props.store);
    useStoreProps(store, props, "activeId", "setActiveId");
    const focusOrderProps = { compositeElementInFocusOrder: props.compositeElementInFocusOrder ?? props.includesBaseElement };
    useStoreProps(store, focusOrderProps, "compositeElementInFocusOrder");
    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, update2] = useStore(createCompositeStore, props);
    return useCompositeStoreProps(store, update2, props);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/select/select-context.js
  var import_react15 = __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_react15.createContext)(false);
  var SelectHeadingContext = (0, import_react15.createContext)(null);

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

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/node_modules/@ariakit/components/dist/tab/tab-store.js
  function getFocusedTab(items) {
    const element = items[0]?.element;
    if (!element) return;
    const activeElement2 = getActiveElement(element);
    if (!activeElement2) return;
    return items.find((item) => item.element === activeElement2);
  }
  function getTabById(items, id3) {
    if (id3 == null) return;
    return items.find((item) => item.id === id3);
  }
  function isEnabledTab(item) {
    if (!item) return false;
    if (item.disabled) return false;
    if (item.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",
      "compositeElementInFocusOrder",
      "includesBaseElement",
      "compositeElement",
      "baseElement",
      "focusLoop",
      "focusShift",
      "focusWrap",
      "selectOnMove"
    ];
    const store = mergeStore(props.store, omit2(parentComposite, independentKeys), omit2(combobox, independentKeys));
    const syncState = store?.getState();
    const composite = createCompositeStore({
      ...props,
      store,
      compositeElementInFocusOrder: defaultValue(props.compositeElementInFocusOrder, props.includesBaseElement, syncState?.compositeElementInFocusOrder, syncState?.includesBaseElement, false),
      orientation: defaultValue(props.orientation, syncState?.orientation, "horizontal"),
      focusLoop: defaultValue(props.focusLoop, syncState?.focusLoop, true)
    });
    const { panels, panel } = createPanelsStore();
    const initialState2 = {
      ...composite.getState(),
      selectedId: defaultValue(props.selectedId, syncState?.selectedId, props.defaultSelectedId),
      selectOnMove: defaultValue(props.selectOnMove, syncState?.selectOnMove, true)
    };
    const tab = createStore(initialState2, 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, prev) => {
        if (pendingRestore) {
          pendingRestore = false;
          if (state.selectedId === restoredSelectedId) return;
        }
        if (parentComposite && state.selectedId === prev.selectedId) return;
        const { activeId, renderedItems } = tab.getState();
        if (activeId === state.selectedId) return;
        const focusedTab = getFocusedTab(renderedItems);
        const selectedTab = getTabById(renderedItems, state.selectedId);
        if (focusedTab && isEnabledTab(selectedTab)) {
          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, i2) => {
          if (panel2.tabId) return;
          const tabItem = tabs[i2];
          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);
      };
      const isParentCombobox = !!parentComposite && "setSelectedValue" in parentComposite;
      const parentCombobox = isParentCombobox ? parentComposite : combobox;
      if (parentComposite && !isParentCombobox && "setSelectElement" in parentComposite) return chain(sync(parentComposite, ["value"], backupSelectedId), sync(parentComposite, ["mounted"], restoreSelectedId));
      if (!parentCombobox) return;
      return chain(sync(parentCombobox, ["selectedValue"], backupSelectedId), sync(parentCombobox, ["mounted"], restoreSelectedId));
    });
    return {
      ...composite,
      ...tab,
      panels,
      panel,
      setSelectedId: (id3) => tab.setState("selectedId", id3),
      select: (id3) => {
        tab.setState("selectedId", id3);
        composite.move(id3);
      }
    };
  }

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/toolbar/toolbar-store.js
  function useToolbarStoreProps(store, update2, props) {
    return useCompositeStoreProps(store, update2, props);
  }
  function useToolbarStore(props = {}) {
    const [store, update2] = useStore(createToolbarStore, props);
    return useToolbarStoreProps(store, update2, props);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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, ...props }) {
    const context = useToolbarProviderContext();
    storeProp = storeProp || context;
    const store = useToolbarStore({
      store: storeProp,
      orientation: orientationProp,
      virtualFocus,
      focusLoop,
      rtl
    });
    const orientation = useStoreState(store, ["orientation"], (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) {
    const htmlProps = useToolbar(props);
    return createElement(TagName10, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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) {
    const htmlProps = useToolbarItem(withDefaultButtonType(props));
    return createElement(TagName11, htmlProps);
  }));

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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) {
    const htmlProps = useSeparator(props);
    return createElement(TagName12, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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, ["orientation"], (state) => orientationProp ?? (state.orientation === "horizontal" ? "vertical" : "horizontal"));
    props = useSeparator({
      ...props,
      orientation
    });
    return props;
  });
  var CompositeSeparator = forwardRef2(function CompositeSeparator2(props) {
    const htmlProps = useCompositeSeparator(props);
    return createElement(TagName13, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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) {
    const htmlProps = useFocusableContainer(props);
    return createElement(TagName14, htmlProps);
  });

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/heading/heading-level.js
  var import_react18 = __toESM(require_react(), 1);
  var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
  function HeadingLevel({ level, children }) {
    const contextLevel = (0, import_react18.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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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) {
    const htmlProps = useVisuallyHidden(props);
    return createElement(TagName15, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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) {
    const htmlProps = useFocusTrap(props);
    return createElement(TagName16, htmlProps);
  });

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/portal/portal.js
  var import_react20 = __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, parentPortalNode) {
    const doc = getDocument(element);
    const rootElement = parentPortalNode || doc.body;
    const { fullscreenElement } = doc;
    const HTMLElementClass = getWindow(element).HTMLElement;
    if (!HTMLElementClass) return rootElement;
    if (!(fullscreenElement instanceof HTMLElementClass)) return rootElement;
    if (contains(fullscreenElement, rootElement)) return rootElement;
    if (parentPortalNode && !contains(parentPortalNode, fullscreenElement)) return parentPortalNode;
    return fullscreenElement;
  }
  function getPortalElement(element, portalElement) {
    if (!portalElement) return getDocument(element).createElement("div");
    if (typeof portalElement === "function") return portalElement(element);
    return portalElement;
  }
  function followFullscreen(portalNode, parentPortalNode) {
    const doc = getDocument(portalNode);
    const onFullscreenChange = () => {
      const rootElement = getRootElement(portalNode, parentPortalNode);
      if (portalNode.parentElement === rootElement) return;
      if (contains(portalNode, rootElement)) return;
      rootElement.appendChild(portalNode);
    };
    doc.addEventListener("fullscreenchange", onFullscreenChange);
    return () => {
      doc.removeEventListener("fullscreenchange", onFullscreenChange);
    };
  }
  function getRandomId(prefix = "id") {
    return `${prefix ? `${prefix}-` : ""}${Math.random().toString(36).slice(2, 8)}`;
  }
  function queueFocus(element) {
    queueMicrotask(() => {
      element?.focus();
    });
  }
  function attachPortalRef(ref, node) {
    return {
      ref,
      node,
      cleanup: setRef(ref, node)
    };
  }
  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_react20.useRef)(null);
    const refProp = useMergeRefs(ref, props.ref);
    const context = (0, import_react20.useContext)(PortalContext);
    const [portalNode, setPortalNode] = (0, import_react20.useState)(null);
    const [anchorPortalNode, setAnchorPortalNode] = (0, import_react20.useState)(null);
    const outerBeforeRef = (0, import_react20.useRef)(null);
    const innerBeforeRef = (0, import_react20.useRef)(null);
    const innerAfterRef = (0, import_react20.useRef)(null);
    const outerAfterRef = (0, import_react20.useRef)(null);
    const portalRefProp = useLiveRef(portalRef);
    const attachedPortalRefRef = (0, import_react20.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) getRootElement(element, context).appendChild(portalEl);
      if (!portalEl.id) portalEl.id = element.id ? `portal/${element.id}` : getRandomId();
      setPortalNode(portalEl);
      attachedPortalRefRef.current = attachPortalRef(portalRefProp.current, portalEl);
      const stopFollowingFullscreen = portalElement ? void 0 : followFullscreen(portalEl, context);
      return () => {
        stopFollowingFullscreen?.();
        const attached = attachedPortalRefRef.current;
        if (attached) {
          attachedPortalRefRef.current = null;
          detachPortalRef(attached);
        }
        if (!isPortalInDocument) portalEl.remove();
      };
    }, [
      portal,
      portalElement,
      context,
      portalRefProp
    ]);
    useSafeLayoutEffect(() => {
      const attached = attachedPortalRefRef.current;
      if (!attached) return;
      if (attached.ref === portalRef) return;
      detachPortalRef(attached);
      attachedPortalRefRef.current = attachPortalRef(portalRef, attached.node);
    }, [portalRef]);
    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_react20.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) {
    const htmlProps = usePortal(props);
    return createElement(TagName17, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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, attr2, value) {
    const setup2 = () => {
      const previousValue = element.getAttribute(attr2);
      element.setAttribute(attr2, value);
      return () => {
        if (previousValue == null) element.removeAttribute(attr2);
        else element.setAttribute(attr2, previousValue);
      };
    };
    return orchestrate(element, attr2, 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);
      const previousPriority = element.style.getPropertyPriority(property);
      element.style.setProperty(property, value);
      return () => {
        if (previousValue) element.style.setProperty(property, previousValue, previousPriority);
        else element.style.removeProperty(property);
      };
    };
    return orchestrate(element, property, setup2);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/utils/tree-cleanup.js
  function isElementMarkedBy(element, cleanups2) {
    if (!cleanups2) return false;
    if (cleanups2.get(element)?.has("ancestorMark")) return true;
    do {
      if (cleanups2.get(element)?.has("mark")) return true;
      if (!element.parentElement) return false;
      element = element.parentElement;
    } while (true);
  }
  var insideElements = /* @__PURE__ */ new WeakMap();
  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(dialog, elements2) {
    const marker = /* @__PURE__ */ new WeakSet();
    insideElements.set(dialog, marker);
    for (const element of elements2) if (element) marker.add(element);
    return () => {
      if (insideElements.get(dialog) !== marker) return;
      insideElements.delete(dialog);
    };
  }
  function isElementInside(element, dialog) {
    const marker = insideElements.get(dialog);
    if (!marker) return false;
    do {
      if (marker.has(element)) 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 startCleanupWalk(previousCleanups) {
    return {
      cleanups: /* @__PURE__ */ new Map(),
      previousCleanups
    };
  }
  function addCleanup({ walk, element, kind, setup: setup2 }) {
    const elementCleanups = walk.cleanups.get(element) ?? /* @__PURE__ */ new Map();
    if (elementCleanups.has(kind)) return;
    walk.cleanups.set(element, elementCleanups);
    const previousElementCleanups = walk.previousCleanups?.get(element);
    const previousCleanup = previousElementCleanups?.get(kind);
    previousElementCleanups?.delete(kind);
    elementCleanups.set(kind, previousCleanup ?? setup2());
  }
  function finishCleanupWalk(walk) {
    if (walk.previousCleanups) restoreCleanups(walk.previousCleanups);
    return walk.cleanups;
  }
  function addElementMarkCleanup({ walk, element, id: id3, ids }) {
    if (isBackdrop(element, ...ids)) return;
    addCleanup({
      walk,
      element,
      kind: "mark",
      setup: () => markElement(element, id3)
    });
  }
  function addAncestorMarkCleanup({ walk, ancestor, element, id: id3 }) {
    if (element.hasAttribute("data-dialog") && element.id !== id3) return;
    addCleanup({
      walk,
      element: ancestor,
      kind: "ancestorMark",
      setup: () => markAncestor(ancestor, id3)
    });
  }
  function restoreCleanups(cleanups2) {
    for (const elementCleanups of cleanups2.values()) for (const cleanup of elementCleanups.values()) cleanup();
    cleanups2.clear();
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/swj3d1r-.js
  function getSnapshotPropertyName(id3) {
    return `__ariakit-dialog-snapshot-${id3}`;
  }
  function getSnapshotAncestorPropertyName(id3) {
    return `__ariakit-dialog-snapshotAncestor-${id3}`;
  }
  function addToWalkTreeSnapshot(id3, elements2) {
    return setSnapshotProperty(getSnapshotPropertyName(id3), elements2);
  }
  function addAncestorsToWalkTreeSnapshot(id3, ancestors) {
    return setSnapshotProperty(getSnapshotAncestorPropertyName(id3), ancestors);
  }
  function setSnapshotProperty(propertyName, elements2) {
    const cleanups2 = [];
    for (const element of elements2) cleanups2.push(setProperty(element, propertyName, true));
    return () => {
      for (const cleanup of cleanups2) cleanup();
    };
  }
  var ignoreTags = ["SCRIPT", "STYLE"];
  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 containsSomeElement(element, elements2) {
    return elements2.some((enabledElement) => enabledElement && contains(element, enabledElement));
  }
  function shouldWalkElement(id3, element, ignoredElements) {
    if (ignoreTags.includes(element.tagName)) return false;
    if (!inSnapshot(id3, element)) return false;
    return !containsSomeElement(element, ignoredElements);
  }
  function isFormerAncestor(id3, element, ignoredElements) {
    if (!element[getSnapshotAncestorPropertyName(id3)]) return false;
    return !containsSomeElement(element, ignoredElements);
  }
  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;
      const walkChildren = (parent) => {
        for (const child of parent.children) {
          if (shouldWalkElement(id3, child, elements2)) {
            callback(child, originalElement);
            continue;
          }
          if (!isFormerAncestor(id3, child, elements2)) continue;
          ancestorCallback?.(child, originalElement);
          walkChildren(child);
        }
      };
      while (element.parentElement && element !== doc.body) {
        ancestorCallback?.(element.parentElement, originalElement);
        if (!hasAncestorAlready) walkChildren(element.parentElement);
        element = element.parentElement;
      }
    }
  }
  function createWalkTreeSnapshot(id3, elements2) {
    const { body } = getDocument(elements2[0]);
    const snapshotElements = [];
    const ancestors = [];
    walkTreeOutside(id3, elements2, (element) => {
      snapshotElements.push(element);
    }, (ancestor) => {
      ancestors.push(ancestor);
    });
    return chain(setProperty(body, getSnapshotPropertyName(id3), true), addToWalkTreeSnapshot(id3, snapshotElements), addAncestorsToWalkTreeSnapshot(id3, ancestors));
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/utils/mark-tree-outside.js
  function markTreeOutside(id3, elements2, previousCleanups) {
    const walk = startCleanupWalk(previousCleanups);
    const ids = elements2.map((el) => el?.id);
    walkTreeOutside(id3, elements2, (element) => {
      addElementMarkCleanup({
        walk,
        element,
        id: id3,
        ids
      });
    }, (ancestor, element) => {
      addAncestorMarkCleanup({
        walk,
        ancestor,
        element,
        id: id3
      });
    });
    return finishCleanupWalk(walk);
  }

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/node_modules/@ariakit/components/dist/role/role.js
  var elements = [
    "a",
    "abbr",
    "address",
    "area",
    "article",
    "aside",
    "audio",
    "b",
    "base",
    "bdi",
    "bdo",
    "blockquote",
    "body",
    "br",
    "button",
    "canvas",
    "caption",
    "cite",
    "code",
    "col",
    "colgroup",
    "data",
    "datalist",
    "dd",
    "del",
    "details",
    "dfn",
    "dialog",
    "div",
    "dl",
    "dt",
    "em",
    "embed",
    "fieldset",
    "figcaption",
    "figure",
    "footer",
    "form",
    "h1",
    "h2",
    "h3",
    "h4",
    "h5",
    "h6",
    "head",
    "header",
    "hgroup",
    "hr",
    "html",
    "i",
    "iframe",
    "img",
    "input",
    "ins",
    "kbd",
    "label",
    "legend",
    "li",
    "link",
    "main",
    "map",
    "mark",
    "menu",
    "meta",
    "meter",
    "nav",
    "noscript",
    "object",
    "ol",
    "optgroup",
    "option",
    "output",
    "p",
    "picture",
    "pre",
    "progress",
    "q",
    "rp",
    "rt",
    "ruby",
    "s",
    "samp",
    "script",
    "section",
    "select",
    "slot",
    "small",
    "source",
    "span",
    "strong",
    "style",
    "sub",
    "summary",
    "sup",
    "table",
    "tbody",
    "td",
    "template",
    "textarea",
    "tfoot",
    "th",
    "thead",
    "time",
    "title",
    "tr",
    "track",
    "u",
    "ul",
    "var",
    "video",
    "wbr",
    "svg"
  ];

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/role/role.js
  var TagName18 = "div";
  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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/dialog-backdrop.js
  var import_react21 = __toESM(require_react(), 1);
  var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
  function DialogBackdrop({ store, backdrop, backdropRef, onElementChange, alwaysVisible, hidden }) {
    const [backdropElement, setBackdropElement] = (0, import_react21.useState)(null);
    const disclosure = useDisclosureStore({ disclosure: store });
    const contentElement = useStoreState(store, "contentElement");
    useSafeLayoutEffect(() => {
      const dialog = contentElement;
      if (!backdropElement) return;
      if (!dialog) return;
      const { zIndex } = getComputedStyle(dialog);
      backdropElement.style.setProperty("z-index", zIndex);
    }, [contentElement, backdropElement]);
    useSafeLayoutEffect(() => {
      const id3 = contentElement?.id;
      if (!id3) return;
      if (!backdropElement) return;
      return markAncestor(backdropElement, id3);
    }, [contentElement, backdropElement]);
    useSafeLayoutEffect(() => {
      if (!backdropElement) return;
      onElementChange?.();
    }, [backdropElement, onElementChange]);
    const props = useDisclosureContent({
      ref: useMergeRefs(setBackdropElement, backdropRef),
      store: disclosure,
      role: "presentation",
      "data-backdrop": contentElement?.id || "",
      alwaysVisible,
      ...hidden != null && { hidden },
      style: {
        position: "fixed",
        top: 0,
        right: 0,
        bottom: 0,
        left: 0
      }
    });
    if (!backdrop) return null;
    if ((0, import_react21.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/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/node_modules/@ariakit/components/dist/dialog/dialog-store.js
  function createDialogStore(props = {}) {
    return createDisclosureStore(props);
  }

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/DztuoDGI.js
  function isHiddenDismiss(element, ...ids) {
    if (!element) return false;
    const dismiss = element.getAttribute("data-dialog-hidden-dismiss");
    if (dismiss == null) return false;
    if (dismiss === "") return true;
    if (!ids.length) return true;
    return ids.some((id3) => dismiss === id3);
  }

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

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

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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);
    const enableElements = 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);
    });
    return chain(...enableElements, hideElementFromAccessibilityTree(element), assignStyle(element, {
      pointerEvents: "none",
      userSelect: "none",
      cursor: "default"
    }));
  }
  function addDisabledElementCleanup({ walk, element, elements: elements2, ids }) {
    if (isBackdrop(element, ...ids)) return;
    if (isFocusTrap(element, ...ids)) return;
    if (isHiddenDismiss(element, ...ids)) return;
    addCleanup({
      walk,
      element,
      kind: "disable",
      setup: () => disableTree(element, elements2)
    });
  }
  function addRoleNoneCleanup(walk, ancestor, elements2) {
    if (!ancestor.hasAttribute("role")) return;
    if (elements2.some((el) => el && contains(el, ancestor))) return;
    addCleanup({
      walk,
      element: ancestor,
      kind: "role",
      setup: () => setAttribute(ancestor, "role", "none")
    });
  }
  function markAndDisableTreeOutside(id3, elements2, previousCleanups) {
    if (previousCleanups && !supportsInert()) restoreCleanups(previousCleanups);
    const walk = startCleanupWalk(previousCleanups);
    const ids = elements2.map((el) => el?.id);
    walkTreeOutside(id3, elements2, (element) => {
      addElementMarkCleanup({
        walk,
        element,
        id: id3,
        ids
      });
      addDisabledElementCleanup({
        walk,
        element,
        elements: elements2,
        ids
      });
    }, (ancestor, element) => {
      addAncestorMarkCleanup({
        walk,
        ancestor,
        element,
        id: id3
      });
      addRoleNoneCleanup(walk, ancestor, elements2);
    });
    return finishCleanupWalk(walk);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/utils/use-previous-mouse-down-ref.js
  var import_react22 = __toESM(require_react(), 1);
  function getFrameChain(element) {
    const chain3 = [element];
    while (true) {
      let frameElement;
      try {
        frameElement = getWindow(element).frameElement;
      } catch {
        return chain3;
      }
      if (!isElement(frameElement)) return chain3;
      chain3.push(frameElement);
      element = frameElement;
    }
  }
  function getEventTargets(event, referenceElement) {
    const elements2 = event.composedPath().filter(isElement);
    if (!elements2.length && isElement(event.target)) elements2.push(event.target);
    const composedTarget = elements2[0];
    if (composedTarget) {
      for (const frameElement of getFrameChain(composedTarget).slice(1)) if (!elements2.includes(frameElement)) elements2.push(frameElement);
    }
    const root = referenceElement?.getRootNode();
    return {
      elements: elements2,
      rootTarget: root ? elements2.find((target) => target.getRootNode() === root) || event.target : elements2[0] || event.target
    };
  }
  function usePreviousMouseDownRef(enabled, scope, referenceElement) {
    const previousMouseDownRef = (0, import_react22.useRef)(null);
    (0, import_react22.useEffect)(() => {
      if (!enabled) {
        previousMouseDownRef.current = null;
        return;
      }
      const onMouseDown = (event) => {
        previousMouseDownRef.current = getEventTargets(event, referenceElement);
      };
      return addGlobalEventListener("mousedown", onMouseDown, true, scope);
    }, [
      enabled,
      scope,
      referenceElement
    ]);
    return previousMouseDownRef;
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/utils/use-hide-on-interact-outside.js
  var import_react23 = __toESM(require_react(), 1);
  function getHighestReadableWindow(element) {
    const highestElement = getFrameChain(element).at(-1);
    return getWindow(highestElement ?? element);
  }
  function isInDocument(target) {
    return target.isConnected;
  }
  function isDisclosure(disclosure, target) {
    if (!disclosure) return false;
    if (contains(disclosure, target)) return true;
    const activeId = target.getAttribute("aria-activedescendant");
    if (activeId) {
      const activeElement2 = getDocument(target).getElementById(activeId);
      if (activeElement2) return contains(disclosure, activeElement2);
    }
    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 isElementWithinDialog(target, contentElement, disclosureElement) {
    if (contains(contentElement, target)) return true;
    if (isDisclosure(disclosureElement, target)) return true;
    if (target.hasAttribute("data-focus-trap")) return true;
    if (isHiddenDismiss(target, contentElement.id)) return true;
    return isElementInside(target, contentElement);
  }
  function isEventInsideDialog(targets, contentElement, disclosureElement) {
    return targets.elements.some((target) => isElementWithinDialog(target, contentElement, disclosureElement));
  }
  function useEventOutside({ store, type, listener, capture, open: open2, contentElement, focusedRef }) {
    const callListener = useEvent(listener);
    (0, import_react23.useEffect)(() => {
      if (!open2) return;
      const onEvent = (event) => {
        const { contentElement: contentElement2, disclosureElement } = store.getState();
        if (!contentElement2) return;
        const targets = getEventTargets(event, contentElement2);
        const composedTarget = targets.elements[0];
        const target = targets.rootTarget;
        if (!isElement(target)) return;
        if (composedTarget && !isInDocument(composedTarget)) return;
        if (!isInDocument(target)) return;
        if (isEventInsideDialog(targets, contentElement2, disclosureElement)) return;
        const contentDocument = getDocument(contentElement2);
        if (getDocument(target) !== contentDocument) {
          callListener(event);
          return;
        }
        if (getDocument(composedTarget ?? target) === contentDocument && isMouseEventOnDialog(event, contentElement2)) return;
        if (focusedRef.current && !isElementMarked(target, contentElement2.id)) return;
        callListener(event);
      };
      const win = contentElement ? getHighestReadableWindow(contentElement) : void 0;
      return addGlobalEventListener(type, onEvent, capture, win);
    }, [
      open2,
      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, focusedStoreRef }) {
    const open2 = useStoreState(store, "open");
    const contentElement = useStoreState(store, "contentElement");
    const eventWindow = contentElement ? getHighestReadableWindow(contentElement) : void 0;
    const previousMouseDownRef = usePreviousMouseDownRef(open2, eventWindow, contentElement);
    const focusedRef = (0, import_react23.useRef)(false);
    useSafeLayoutEffect(() => {
      if (!open2) return;
      focusedRef.current = false;
    }, [open2, store]);
    useSafeLayoutEffect(() => {
      if (!open2) return;
      if (!domReady) return;
      if (!contentElement) return;
      const onFocus = () => {
        focusedRef.current = true;
        focusedStoreRef.current = store;
      };
      contentElement.addEventListener("focusin", onFocus, true);
      return () => contentElement.removeEventListener("focusin", onFocus, true);
    }, [
      open2,
      domReady,
      contentElement,
      store,
      focusedStoreRef
    ]);
    const props = {
      store,
      capture: true,
      open: open2,
      contentElement,
      focusedRef
    };
    const hide5 = () => {
      store.hide();
      if (!store.getState().open) return;
      interactedOutsideRef.current = false;
    };
    useEventOutside({
      ...props,
      type: "click",
      listener: (event) => {
        const { contentElement: contentElement2, disclosureElement } = store.getState();
        const previousMouseDown = previousMouseDownRef.current;
        if (!previousMouseDown) return;
        if (!contentElement2) return;
        if (isEventInsideDialog(previousMouseDown, contentElement2, disclosureElement)) return;
        const previousRootTarget = previousMouseDown.rootTarget;
        if (!isElement(previousRootTarget)) return;
        if (getDocument(previousRootTarget) === getDocument(contentElement2) && !isElementMarked(previousRootTarget, contentElement2.id)) return;
        if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
        interactedOutsideRef.current = true;
        hide5();
      }
    });
    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;
        const target = event.target;
        if (isElement(target) && getDocument(target) !== getDocument(contentElement2)) interactedOutsideRef.current = true;
        hide5();
      }
    });
    useEventOutside({
      ...props,
      type: "contextmenu",
      listener: (event) => {
        if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
        interactedOutsideRef.current = true;
        hide5();
      }
    });
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/utils/use-nested-dialogs.js
  var import_react24 = __toESM(require_react(), 1);
  var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
  var NestedDialogsContext = (0, import_react24.createContext)({});
  function useNestedDialogs(store) {
    const context = (0, import_react24.useContext)(NestedDialogsContext);
    const [dialogs, setDialogs] = (0, import_react24.useState)([]);
    const add2 = (0, import_react24.useCallback)((dialog) => {
      setDialogs((dialogs2) => [...dialogs2, dialog]);
      return chain(context.add?.(dialog), () => {
        setDialogs((dialogs2) => dialogs2.filter((d2) => d2 !== 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_react24.useMemo)(() => ({
      store,
      add: add2
    }), [store, add2]);
    return {
      wrapElement: (0, import_react24.useCallback)((element) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(NestedDialogsContext.Provider, {
        value: providerValue,
        children: element
      }), [providerValue]),
      nestedDialogs: dialogs
    };
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/utils/use-root-dialog.js
  var import_react25 = __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_react25.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,
      retry
    ]);
    return isRootDialog;
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/utils/use-prevent-body-scroll.js
  var import_react26 = __toESM(require_react(), 1);
  var isIOS = isApple() && !isMac();
  var useLockEffect = isIOS ? import_react26.useEffect : useSafeLayoutEffect;
  function supportsScrollbarGutter(win) {
    const { CSS: CSS2 } = win;
    return !!CSS2?.supports("scrollbar-gutter", "stable");
  }
  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
    });
    useLockEffect(() => {
      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 setStyle = () => {
        const computedStyle = win.getComputedStyle(documentElement);
        const scrollbarGutter = computedStyle.getPropertyValue("scrollbar-gutter");
        const hasGutter = scrollbarGutter.includes("stable");
        const isOverflowVisible = (value) => !value || value === "visible";
        const htmlScrolls = !isOverflowVisible(computedStyle.getPropertyValue("overflow-x")) || !isOverflowVisible(computedStyle.getPropertyValue("overflow-y"));
        const hideHtmlOverflow = () => chain(setCSSProperty(documentElement, "overflow-x", "hidden"), setCSSProperty(documentElement, "overflow-y", "hidden"));
        const withHiddenHtmlOverflow = (restoreStyle) => {
          if (!htmlScrolls) return restoreStyle;
          return chain(restoreStyle, hideHtmlOverflow());
        };
        if (!hasGutter && !scrollbarWidth) return withHiddenHtmlOverflow(assignStyle(body, { overflow: "hidden" }));
        if (hasGutter || supportsScrollbarGutter(win)) return chain(setCSSProperty(documentElement, "scrollbar-gutter", hasGutter ? scrollbarGutter : "stable"), hideHtmlOverflow());
        return withHiddenHtmlOverflow(chain(setCSSProperty(documentElement, "--scrollbar-width", `${scrollbarWidth}px`), assignStyle(body, {
          overflow: "hidden",
          [getPaddingProperty(documentElement)]: `${scrollbarWidth}px`
        })));
      };
      const setIOSStyle = () => {
        const { scrollX, scrollY, visualViewport } = win;
        const offsetLeft = visualViewport?.offsetLeft ?? 0;
        const offsetTop = visualViewport?.offsetTop ?? 0;
        const restoreStyle = assignStyle(body, {
          position: "fixed",
          overflow: "hidden",
          top: `${-(scrollY - Math.floor(offsetTop))}px`,
          left: `${-(scrollX - Math.floor(offsetLeft))}px`,
          right: "0",
          [getPaddingProperty(documentElement)]: `${scrollbarWidth}px`
        });
        return () => {
          restoreStyle();
          if (true) win.scrollTo({
            left: scrollX,
            top: scrollY,
            behavior: "instant"
          });
        };
      };
      if (isIOS) return setIOSStyle();
      const restore = setStyle();
      return () => {
        queueMicrotask(restore);
      };
    }, [isRootDialog, contentElement]);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/CEV0PLZp.js
  var import_react27 = __toESM(require_react(), 1);
  var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
  var capturedDisclosures = /* @__PURE__ */ new WeakSet();
  function captureDisclosure(element) {
    capturedDisclosures.add(element);
  }
  function isCapturedDisclosure(element) {
    return capturedDisclosures.has(element);
  }
  var openDialogs = /* @__PURE__ */ new Map();
  function addOpenDialog(dialogRef, options2 = {}) {
    openDialogs.set(dialogRef, options2);
  }
  function removeOpenDialog(dialogRef) {
    openDialogs.delete(dialogRef);
  }
  function getEarlierOpenDialogElements(dialogRef) {
    const elements2 = [];
    const dialog = dialogRef.current;
    for (const [openDialogRef, options2] of openDialogs) {
      if (openDialogRef === dialogRef) break;
      const openDialogElements = [
        options2.getPortalNode?.(),
        options2.getWrapperElement?.(),
        options2.getBackdropElement?.(),
        options2.getHiddenDismissElement?.(),
        openDialogRef.current
      ];
      for (const element of openDialogElements) {
        if (!element?.isConnected) continue;
        if (dialog && contains(element, dialog)) continue;
        elements2.push(element);
      }
    }
    return elements2;
  }
  function notifyOpenDialogElementChange(dialogRef) {
    let foundDialog = false;
    for (const [openDialogRef, options2] of openDialogs) {
      if (openDialogRef === dialogRef) {
        foundDialog = true;
        continue;
      }
      if (!foundDialog) continue;
      options2.onEarlierDialogElementChange?.();
    }
  }
  function hasDialogAbove(dialogRef) {
    const dialog = dialogRef.current;
    if (!dialog) return false;
    if (!isElementMarked(dialog)) return false;
    const cleanups2 = openDialogs.get(dialogRef)?.getOutsideCleanups?.();
    let openedAfterDialog = false;
    let isAboveEarlierDialog = false;
    for (const [openDialogRef, options2] of openDialogs) {
      if (openDialogRef === dialogRef) {
        openedAfterDialog = true;
        continue;
      }
      const openDialog = openDialogRef.current;
      if (!openDialog) continue;
      if (!isElementMarkedBy(dialog, options2.getOutsideCleanups?.())) continue;
      if (openedAfterDialog) return true;
      if (!isElementMarkedBy(openDialog, cleanups2)) return true;
      isAboveEarlierDialog = true;
    }
    return !(openedAfterDialog && isAboveEarlierDialog);
  }
  var TagName19 = "div";
  var isSafariBrowser2 = isSafari();
  var openModalPortals = /* @__PURE__ */ new WeakSet();
  var escapeKeyPressesThatHid = /* @__PURE__ */ new WeakSet();
  function isAlreadyFocusingAnotherElement(dialog) {
    const activeElement2 = getActiveElement(dialog);
    if (!activeElement2) return false;
    if (dialog && contains(dialog, activeElement2)) return false;
    if (isHiddenDismiss(activeElement2, dialog?.id)) return false;
    if (isFocusable(activeElement2)) return true;
    return false;
  }
  function getDeepestActiveElement(element) {
    let activeElement2 = element;
    while (activeElement2.shadowRoot) {
      const nextElement = activeElement2.shadowRoot.activeElement;
      if (!isElement(nextElement)) break;
      activeElement2 = nextElement;
    }
    return activeElement2;
  }
  function isElementInDialog(element, dialog, disclosureElement) {
    if (contains(dialog, element)) return true;
    if (disclosureElement && contains(disclosureElement, element)) return true;
    return isElementInside(element, dialog);
  }
  function hasOwnDismiss(dialog) {
    const dismisses = dialog.querySelectorAll("[data-dialog-dismiss]");
    for (const dismiss of dismisses) if (dismiss.closest("[data-dialog]") === dialog) return true;
    return false;
  }
  function getElementFromProp(prop, focusable2 = false) {
    if (!prop) return null;
    const element = "current" in prop ? prop.current : prop;
    if (!element) return null;
    if (focusable2) return isFocusable(element) ? element : null;
    return element;
  }
  function getLaterOpenModalPortals(dialog) {
    if (!dialog.isConnected) return [];
    const root = dialog.getRootNode();
    const dialogs = root.querySelectorAll("[data-dialog][data-dialog-portal][data-open]");
    const portals = [];
    let foundDialog = false;
    for (const currentDialog of dialogs) {
      if (currentDialog === dialog) {
        foundDialog = true;
        continue;
      }
      if (!foundDialog) continue;
      const portalId = currentDialog.getAttribute("data-dialog-portal");
      if (!portalId) continue;
      const portal = root.getElementById(portalId);
      if (!portal || !contains(portal, currentDialog)) continue;
      if (openModalPortals.has(portal)) continue;
      portals.push(portal);
    }
    return portals;
  }
  var useDialog = createHook(function useDialog2({ store: storeProp, open: openProp, onClose, focusable: focusable2 = true, modal = true, portal = modal, backdrop = modal, hideOnEscape = true, hideOnInteractOutside = true, getPersistentElements, preventBodyScroll = modal, autoFocusOnShow = true, autoFocusOnHide = true, initialFocus, finalFocus, unmountOnHide, unstable_treeSnapshotKey, unstable_wrapperElement, ...props }) {
    const context = useDialogProviderContext();
    const ref = (0, import_react27.useRef)(null);
    const backdropRef = (0, import_react27.useRef)(null);
    const hiddenDismissRef = (0, import_react27.useRef)(null);
    const hasDefaultModalPortal = modal && portal && !props.portalElement;
    const handlingHideRef = (0, import_react27.useRef)(false);
    const dispatchClose = useEvent(() => {
      const dialog = ref.current;
      if (!dialog) return true;
      const event = new Event("close", {
        bubbles: false,
        cancelable: true
      });
      if (onClose) dialog.addEventListener("close", onClose, { once: true });
      dialog.dispatchEvent(event);
      return !event.defaultPrevented;
    });
    const store = useDialogStore({
      store: storeProp || context,
      open: openProp,
      setOpen(open3) {
        if (open3) return;
        if (handlingHideRef.current) return;
        if (dispatchClose()) return;
        store.setOpen(true);
      }
    });
    useSafeLayoutEffect(() => {
      return store.unstable_onHideRequest((hide5) => {
        if (handlingHideRef.current) return;
        handlingHideRef.current = true;
        try {
          if (!dispatchClose()) return;
          hide5();
        } finally {
          handlingHideRef.current = false;
        }
      });
    }, [store, dispatchClose]);
    const { portalRef, portalNode, domReady } = usePortalRef(portal, props.portalRef);
    const portalNodeRef = useLiveRef(portalNode);
    const wrapperElementRef = useLiveRef(unstable_wrapperElement);
    const preserveTabOrderProp = props.preserveTabOrder;
    const preserveTabOrder = useStoreState(store, ["mounted"], (state) => preserveTabOrderProp && !modal && state.mounted);
    const id3 = useId(props.id);
    const open2 = 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_react27.useRef)(false);
    const focusedStoreRef = (0, import_react27.useRef)(null);
    useSafeLayoutEffect(() => {
      return sync(store, ["open"], (state) => {
        if (!state.open) {
          focusedStoreRef.current = null;
          return;
        }
        interactedOutsideRef.current = false;
        if (focusedStoreRef.current === store) return;
        focusedStoreRef.current = null;
      });
    }, [store]);
    useHideOnInteractOutside({
      store,
      hideOnInteractOutside,
      domReady,
      interactedOutsideRef,
      focusedStoreRef
    });
    const { wrapElement, nestedDialogs } = useNestedDialogs(store);
    props = useWrapElement(props, wrapElement, [wrapElement]);
    const lastMousedownRef = (0, import_react27.useRef)(null);
    if (isSafariBrowser2) (0, import_react27.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 (!open2) return;
      if (focusedStoreRef.current === store) return;
      const dialog = ref.current;
      const hasNamedDisclosure = () => {
        const { disclosureElement } = store.getState();
        if (!disclosureElement) return false;
        if (isCapturedDisclosure(disclosureElement)) return false;
        if (!disclosureElement.isConnected) return false;
        if (dialog && contains(dialog, disclosureElement)) return false;
        return true;
      };
      if (hasNamedDisclosure()) return;
      const setCapturedDisclosure = (element) => {
        captureDisclosure(element);
        store.setDisclosureElement(element);
      };
      const activeElement2 = getActiveElement(dialog, { activeDescendant: true });
      if (!activeElement2) return;
      if (activeElement2.tagName === "BODY") {
        const fallback = lastMousedownRef.current;
        lastMousedownRef.current = null;
        if (!fallback?.isConnected) return;
        if (!isFocusable(fallback)) return;
        if (dialog && contains(dialog, fallback)) return;
        setCapturedDisclosure(fallback);
        return;
      }
      if (dialog && contains(dialog, activeElement2)) return;
      setCapturedDisclosure(activeElement2);
    }, [store, open2]);
    (0, import_react27.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]);
    const [needsHiddenDismiss, setNeedsHiddenDismiss] = (0, import_react27.useState)(false);
    useSafeLayoutEffect(() => {
      if (!(modal && open2 && domReady) || !contentElement) {
        setNeedsHiddenDismiss(false);
        return;
      }
      const update2 = () => {
        setNeedsHiddenDismiss(!hasOwnDismiss(contentElement));
      };
      update2();
      const { MutationObserver: MutationObserver2 } = getWindow(contentElement);
      const observer = new MutationObserver2(update2);
      observer.observe(contentElement, {
        childList: true,
        subtree: true
      });
      return () => observer.disconnect();
    }, [
      modal,
      open2,
      domReady,
      contentElement
    ]);
    useSafeLayoutEffect(() => {
      if (!supportsInert()) return;
      if (open2) return;
      if (!mounted) return;
      if (!domReady) return;
      const dialog = ref.current;
      if (!dialog) return;
      return disableTree(dialog);
    }, [
      open2,
      mounted,
      domReady
    ]);
    const canTakeTreeSnapshot = open2 && domReady;
    const openingCohortRef = (0, import_react27.useRef)(null);
    useSafeLayoutEffect(() => {
      if (!id3 || !hasDefaultModalPortal || !canTakeTreeSnapshot || !portalNode) {
        openingCohortRef.current = null;
        return;
      }
      const dialog = ref.current;
      if (!dialog || !contains(portalNode, dialog)) {
        openingCohortRef.current = null;
        return;
      }
      if (openingCohortRef.current?.portal !== portalNode) openingCohortRef.current = {
        portal: portalNode,
        peers: getLaterOpenModalPortals(dialog)
      };
      openModalPortals.add(portalNode);
      return () => {
        openModalPortals.delete(portalNode);
      };
    }, [
      id3,
      canTakeTreeSnapshot,
      hasDefaultModalPortal,
      portalNode
    ]);
    const isOpenAndReady = !!canTakeTreeSnapshot;
    const [earlierDialogElementChanges, setEarlierDialogElementChanges] = (0, import_react27.useState)(0);
    useSafeLayoutEffect(() => {
      if (!isOpenAndReady) return;
      addOpenDialog(ref, {
        getOutsideCleanups: () => treeRef.current?.outsideCleanups,
        getPortalNode: () => portalNodeRef.current,
        getWrapperElement: () => wrapperElementRef.current,
        getBackdropElement: () => backdropRef.current,
        getHiddenDismissElement: () => hiddenDismissRef.current,
        onEarlierDialogElementChange: () => {
          setEarlierDialogElementChanges((count) => count + 1);
        }
      });
    }, [
      isOpenAndReady,
      portalNodeRef,
      wrapperElementRef
    ]);
    useSafeLayoutEffect(() => {
      if (!open2) return;
      return () => removeOpenDialog(ref);
    }, [open2]);
    const previousContentElementRef = (0, import_react27.useRef)(null);
    useSafeLayoutEffect(() => {
      if (!isOpenAndReady) {
        previousContentElementRef.current = null;
        return;
      }
      if (!contentElement) return;
      const previousContentElement = previousContentElementRef.current;
      previousContentElementRef.current = contentElement;
      if (!previousContentElement) return;
      if (previousContentElement === contentElement) return;
      notifyOpenDialogElementChange(ref);
    }, [isOpenAndReady, contentElement]);
    const onBackdropElementChange = (0, import_react27.useCallback)(() => {
      notifyOpenDialogElementChange(ref);
    }, []);
    useSafeLayoutEffect(() => {
      if (!needsHiddenDismiss) return;
      notifyOpenDialogElementChange(ref);
    }, [needsHiddenDismiss]);
    const treeSnapshotRef = (0, import_react27.useRef)(null);
    useSafeLayoutEffect(() => {
      if (!id3) return;
      if (!canTakeTreeSnapshot) return;
      const dialog = ref.current;
      if (!dialog) return;
      const rootNode = dialog.getRootNode();
      const treeSnapshot = treeSnapshotRef.current;
      if (treeSnapshot?.rootNode === rootNode) return;
      treeSnapshot?.restore();
      const restore = createWalkTreeSnapshot(id3, [dialog]);
      treeSnapshotRef.current = {
        rootNode,
        restore
      };
    }, [
      id3,
      canTakeTreeSnapshot,
      unstable_treeSnapshotKey
    ]);
    useSafeLayoutEffect(() => {
      if (!open2) return;
      return () => {
        treeSnapshotRef.current?.restore();
        treeSnapshotRef.current = null;
      };
    }, [
      id3,
      open2,
      unstable_treeSnapshotKey
    ]);
    useSafeLayoutEffect(() => {
      if (!id3) return;
      if (!canTakeTreeSnapshot) return;
      const earlierDialogs = getEarlierOpenDialogElements(ref);
      return addToWalkTreeSnapshot(id3, earlierDialogs);
    }, [
      id3,
      canTakeTreeSnapshot,
      earlierDialogElementChanges
    ]);
    const getPersistentElementsProp = useEvent(getPersistentElements);
    const treeRef = (0, import_react27.useRef)(null);
    useSafeLayoutEffect(() => {
      return () => {
        const tree = treeRef.current;
        if (!tree) return;
        treeRef.current = null;
        tree.restoreInsideMarks();
        restoreCleanups(tree.outsideCleanups);
      };
    }, [
      id3,
      store,
      canTakeTreeSnapshot,
      contentElement,
      modal,
      hasDefaultModalPortal,
      getPersistentElementsProp,
      unstable_treeSnapshotKey
    ]);
    useSafeLayoutEffect(() => {
      if (!id3) return;
      if (!canTakeTreeSnapshot) return;
      const { disclosureElement } = store.getState();
      const dialog = contentElement ?? ref.current;
      if (!dialog) return;
      const allElements = [
        dialog,
        ...getPersistentElementsProp() || [],
        ...openingCohortRef.current?.peers || [],
        ...nestedDialogs.map((dialog2) => dialog2.getState().contentElement)
      ];
      const previousTree = treeRef.current;
      previousTree?.restoreInsideMarks();
      const restoreInsideMarks = markTreeInside(dialog, allElements);
      const outsideCleanups = modal ? markAndDisableTreeOutside(id3, allElements, previousTree?.outsideCleanups) : markTreeOutside(id3, [disclosureElement, ...allElements], previousTree?.outsideCleanups);
      treeRef.current = {
        restoreInsideMarks,
        outsideCleanups
      };
    }, [
      id3,
      store,
      canTakeTreeSnapshot,
      contentElement,
      modal,
      hasDefaultModalPortal,
      getPersistentElementsProp,
      nestedDialogs,
      unstable_treeSnapshotKey,
      earlierDialogElementChanges
    ]);
    const mayAutoFocusOnShow = !!autoFocusOnShow;
    const autoFocusOnShowProp = useBooleanEvent(autoFocusOnShow);
    const [autoFocusEnabled, setAutoFocusEnabled] = (0, import_react27.useState)(false);
    (0, import_react27.useEffect)(() => {
      if (!open2) 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(() => {
        const { open: open3, disclosureElement } = store.getState();
        if (!open3) return;
        const activeElement2 = getActiveElement(contentElement, { frame: false });
        const deepestActiveElement = activeElement2 && getDeepestActiveElement(activeElement2);
        if (focusedStoreRef.current === store && activeElement2 && deepestActiveElement && isFocusable(deepestActiveElement) && !isElementInDialog(activeElement2, contentElement, disclosureElement) && !isElementInDialog(deepestActiveElement, contentElement, disclosureElement)) return;
        if (isFocusable(element)) element.scrollIntoView({
          block: "nearest",
          inline: "nearest"
        });
        element.focus({ preventScroll: true });
      });
    }, [
      open2,
      mayAutoFocusOnShow,
      domReady,
      contentElement,
      initialFocus,
      portal,
      preserveTabOrder,
      store,
      autoFocusOnShowProp,
      focusedStoreRef
    ]);
    const mayAutoFocusOnHide = !!autoFocusOnHide;
    const autoFocusOnHideProp = useBooleanEvent(autoFocusOnHide);
    const [hasOpened, setHasOpened] = (0, import_react27.useState)(false);
    useSafeLayoutEffect(() => {
      if (!open2) return;
      setHasOpened(true);
      return () => setHasOpened(false);
    }, [open2]);
    const focusOnHide = (0, import_react27.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_react27.useRef)(false);
    useSafeLayoutEffect(() => {
      if (open2) return;
      if (!hasOpened) return;
      if (!mayAutoFocusOnHide) return;
      const dialog = ref.current;
      focusedOnHideRef.current = true;
      focusOnHide(dialog);
    }, [
      open2,
      hasOpened,
      domReady,
      mayAutoFocusOnHide,
      focusOnHide
    ]);
    (0, import_react27.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);
    const [escapeEvents] = (0, import_react27.useState)(() => /* @__PURE__ */ new WeakMap());
    const [escapeKeyPresses] = (0, import_react27.useState)(() => /* @__PURE__ */ new WeakMap());
    const onKeyDownProp = props.onKeyDown;
    const onKeyDownCaptureProp = props.onKeyDownCapture;
    const onFocusCaptureProp = props.onFocusCapture;
    const onFocusCapture = useEvent((event) => {
      onFocusCaptureProp?.(event);
      if (!store.getState().open) return;
      const target = event.target;
      if (!isNode(target)) return;
      if (!contains(event.currentTarget, target)) return;
      focusedStoreRef.current = store;
    });
    const acceptEscape = useEvent((event) => {
      if (event.key !== "Escape") return false;
      if (!event.bubbles) return false;
      const result = escapeEvents.get(event);
      if (result) {
        if (event.defaultPrevented && !result.defaultPrevented) return false;
        return result.accepted;
      }
      if (event.defaultPrevented) return false;
      const dialog = ref.current;
      if (!mounted) return false;
      if (!dialog) return false;
      const source = getKeyboardEventSource(event);
      let keyPress = escapeKeyPresses.get(source);
      if (!keyPress) {
        keyPress = {
          accepted: !hasDialogAbove(ref) && !escapeKeyPressesThatHid.has(source) && hideOnEscapeProp(event),
          hidden: false
        };
        escapeKeyPresses.set(source, keyPress);
      }
      escapeEvents.set(event, {
        accepted: keyPress.accepted,
        defaultPrevented: event.defaultPrevented
      });
      return keyPress.accepted;
    });
    const hideOnEscapeEvent = useEvent((event) => {
      const accepted = acceptEscape(event);
      escapeEvents.delete(event);
      if (!accepted) return false;
      const source = getKeyboardEventSource(event);
      const keyPress = escapeKeyPresses.get(source);
      if (keyPress?.hidden) return true;
      if (keyPress) keyPress.hidden = true;
      escapeKeyPressesThatHid.add(source);
      store.hide();
      return true;
    });
    const onKeyDown = useEvent((event) => {
      const nativeEvent = event.nativeEvent;
      const wasPropagationStopped = nativeEvent.cancelBubble;
      onKeyDownProp?.(event);
      if (wasPropagationStopped) {
        escapeEvents.delete(nativeEvent);
        return;
      }
      if (!hideOnEscapeEvent(nativeEvent)) return;
      event.stopPropagation();
    });
    const onKeyDownCapture = useEvent((event) => {
      const nativeEvent = event.nativeEvent;
      const wasPropagationStopped = nativeEvent.cancelBubble;
      onKeyDownCaptureProp?.(event);
      if (wasPropagationStopped) {
        escapeEvents.delete(nativeEvent);
        return;
      }
      if (!acceptEscape(nativeEvent)) return;
      if (!(event.isPropagationStopped() || nativeEvent.cancelBubble)) return;
      hideOnEscapeEvent(nativeEvent);
    });
    (0, import_react27.useEffect)(() => {
      if (!domReady) return;
      if (!mounted) return;
      const onDocumentKeyDownCapture = (event) => {
        if (event.key !== "Escape") return;
        if (!event.bubbles) return;
        if (event.cancelBubble) {
          escapeEvents.delete(event);
          return;
        }
        if (escapeEvents.has(event)) return;
        const dialog = ref.current;
        if (!dialog) return;
        const targets = [event.target, event.composedPath()[0]].filter(isNode);
        const { disclosureElement } = store.getState();
        const isValidTarget = (target) => {
          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;
          if (isElement(target) && isHiddenDismiss(target, dialog.id)) return true;
          return false;
        };
        if (!targets.some(isValidTarget)) return;
        if (!acceptEscape(event)) return;
        if (!event.cancelBubble) return;
        hideOnEscapeEvent(event);
      };
      const onDocumentKeyDown = (event) => {
        if (!escapeEvents.has(event)) return;
        if (event.cancelBubble) {
          escapeEvents.delete(event);
          return;
        }
        if (!hideOnEscapeEvent(event)) return;
        event.stopPropagation();
      };
      const win = contentElement ? getWindow(contentElement) : void 0;
      return chain(addGlobalEventListener("keydown", onDocumentKeyDownCapture, true, win), addGlobalEventListener("keydown", onDocumentKeyDown, false, win));
    }, [
      store,
      domReady,
      mounted,
      contentElement,
      hideOnEscapeEvent,
      acceptEscape,
      escapeEvents
    ]);
    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) => /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [needsHiddenDismiss && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("button", {
      ref: hiddenDismissRef,
      type: "button",
      tabIndex: -1,
      "data-dialog-hidden-dismiss": id3 || "",
      style: getVisuallyHiddenStyle(),
      onClick: store.hide,
      children: "Dismiss popup"
    }), element] }), [
      needsHiddenDismiss,
      id3,
      store
    ]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [!!backdrop && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogBackdrop, {
      store,
      backdrop,
      backdropRef,
      onElementChange: onBackdropElementChange,
      hidden: hiddenProp,
      alwaysVisible
    }), element] }), [
      store,
      backdrop,
      onBackdropElementChange,
      hiddenProp,
      alwaysVisible
    ]);
    const [headingId, setHeadingId] = (0, import_react27.useState)();
    const [descriptionId, setDescriptionId] = (0, import_react27.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: focusable2 ? -1 : void 0,
      "aria-labelledby": props["aria-label"] != null ? void 0 : headingId,
      "aria-describedby": descriptionId,
      ...props,
      "data-dialog-portal": hasDefaultModalPortal ? portalNode?.id : void 0,
      id: id3,
      ref: useMergeRefs(ref, props.ref),
      onFocusCapture,
      onKeyDown,
      onKeyDownCapture
    };
    props = useFocusableContainer({
      ...props,
      autoFocusOnShow: autoFocusEnabled
    });
    props = useDisclosureContent({
      store,
      ...props,
      unstable_otherElementRef: backdropRef
    });
    props = useFocusable({
      ...props,
      focusable: focusable2
    });
    props = usePortal({
      portal,
      ...props,
      portalRef,
      preserveTabOrder
    });
    return props;
  });
  function createDialogComponent(Component7, useProviderContext = useDialogProviderContext) {
    return forwardRef2(function DialogComponent(props) {
      const context = useProviderContext();
      const store = props.store || context;
      if (!useStoreState(store, ["mounted"], (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) {
    const htmlProps = useDialog(props);
    return createElement(TagName19, htmlProps);
  }), 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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/B3k5_R1L.js
  function getBasePlacement(placement) {
    return placement.split("-")[0];
  }

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

  // node_modules/.store/@floating-ui/utils@0.2.12-gOxTzMf36nCrbeHpEew-rw/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, rtl) {
    if (rtl === void 0) {
      rtl = false;
    }
    const alignment = getAlignment(placement);
    const alignmentAxis = getAlignmentAxis(placement);
    const length = getAxisLength(alignmentAxis);
    let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
    if (rects.reference[length] > rects.floating[length]) {
      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, rtl) {
    switch (side) {
      case "top":
      case "bottom":
        if (rtl) return isStart ? rlPlacement : lrPlacement;
        return isStart ? lrPlacement : rlPlacement;
      case "left":
      case "right":
        return isStart ? tbPlacement : btPlacement;
      default:
        return [];
    }
  }
  function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
    const alignment = getAlignment(placement);
    let list = getSideList(getSide(placement), direction === "start", rtl);
    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(padding) {
    var _padding$top, _padding$right, _padding$bottom, _padding$left;
    return {
      top: (_padding$top = padding.top) != null ? _padding$top : 0,
      right: (_padding$right = padding.right) != null ? _padding$right : 0,
      bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
      left: (_padding$left = padding.left) != null ? _padding$left : 0
    };
  }
  function getPaddingObject(padding) {
    return typeof padding !== "number" ? expandPaddingObject(padding) : {
      top: padding,
      right: padding,
      bottom: padding,
      left: padding
    };
  }
  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/.store/@floating-ui/core@1.8.0-3V8aS7jJHHGcsCINjP9-5A/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
  function computeCoordsFromPlacement(_ref, placement, rtl) {
    let {
      reference,
      floating
    } = _ref;
    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
        };
    }
    const alignment = getAlignment(placement);
    if (alignment) {
      coords[alignmentAxis] += commonAlign * (alignment === "end" ? 1 : -1) * (rtl && isVertical ? -1 : 1);
    }
    return coords;
  }
  async function detectOverflow(state, options2) {
    var _await$platform$isEle;
    if (options2 === void 0) {
      options2 = {};
    }
    const {
      x: x2,
      y: y3,
      platform: platform3,
      rects,
      elements: elements2,
      strategy
    } = state;
    const {
      boundary = "clippingAncestors",
      rootBoundary = "viewport",
      elementContext = "floating",
      altBoundary = false,
      padding = 0
    } = evaluate(options2, state);
    const paddingObject = getPaddingObject(padding);
    const altContext = elementContext === "floating" ? "reference" : "floating";
    const element = elements2[altBoundary ? altContext : elementContext];
    const clippingClientRect = rectToClientRect(await platform3.getClippingRect({
      element: ((_await$platform$isEle = await (platform3.isElement == null ? void 0 : platform3.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform3.getDocumentElement == null ? void 0 : platform3.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 (platform3.getOffsetParent == null ? void 0 : platform3.getOffsetParent(elements2.floating));
    const offsetScale = await (platform3.isElement == null ? void 0 : platform3.isElement(offsetParent)) && await (platform3.getScale == null ? void 0 : platform3.getScale(offsetParent)) || {
      x: 1,
      y: 1
    };
    const elementClientRect = rectToClientRect(platform3.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform3.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 = [],
      platform: platform3
    } = config;
    const platformWithDetectOverflow = platform3.detectOverflow ? platform3 : {
      ...platform3,
      detectOverflow
    };
    const rtl = await (platform3.isRTL == null ? void 0 : platform3.isRTL(floating));
    let rects = await platform3.getElementRects({
      reference,
      floating,
      strategy
    });
    let {
      x: x2,
      y: y3
    } = computeCoordsFromPlacement(rects, placement, rtl);
    let statefulPlacement = placement;
    let resetCount = 0;
    const middlewareData = {};
    for (let i2 = 0; i2 < middleware.length; i2++) {
      const currentMiddleware = middleware[i2];
      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 platform3.getElementRects({
              reference,
              floating,
              strategy
            }) : reset.rects;
          }
          ({
            x: x2,
            y: y3
          } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
        }
        i2 = -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: platform3,
        elements: elements2,
        middlewareData
      } = state;
      const {
        element,
        padding = 0
      } = evaluate(options2, state) || {};
      if (element == null) {
        return {};
      }
      const paddingObject = getPaddingObject(padding);
      const coords = {
        x: x2,
        y: y3
      };
      const axis = getAlignmentAxis(placement);
      const length = getAxisLength(axis);
      const arrowDimensions = await platform3.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[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
      const startDiff = coords[axis] - rects.reference[axis];
      const arrowOffsetParent = await (platform3.getOffsetParent == null ? void 0 : platform3.getOffsetParent(element));
      let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
      if (!clientSize || !await (platform3.isElement == null ? void 0 : platform3.isElement(arrowOffsetParent))) {
        clientSize = elements2.floating[clientProp] || rects.floating[length];
      }
      const centerToReference = endDiff / 2 - startDiff / 2;
      const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
      const minPadding = min(paddingObject[minProp], largestPossiblePadding);
      const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
      const max2 = clientSize - arrowDimensions[length] - maxPadding;
      const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
      const offset4 = clamp(minPadding, center, max2);
      const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length] / 2 - (center < minPadding ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
      const alignmentOffset = shouldAddOffset ? center < minPadding ? center - minPadding : center - max2 : 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: platform3,
          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 rtl = await (platform3.isRTL == null ? void 0 : platform3.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, rtl));
        }
        const placements2 = [initialPlacement, ...fallbackPlacements];
        const overflow = await platform3.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, rtl);
          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((d2) => getSideAxis(d2.placement) === initialSideAxis ? d2.overflows[0] > 0 : true)) {
              return {
                data: {
                  index: nextIndex,
                  overflows: overflowsData
                },
                reset: {
                  placement: nextPlacement
                }
              };
            }
          }
          let resetPlacement = (_overflowsData$filter = overflowsData.filter((d2) => d2.overflows[0] <= 0).sort((a2, b2) => a2.overflows[1] - b2.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
          if (!resetPlacement) {
            switch (fallbackStrategy) {
              case "bestFit": {
                var _overflowsData$filter2;
                const placement2 = (_overflowsData$filter2 = overflowsData.filter((d2) => {
                  if (hasFallbackAxisSideDirection) {
                    const currentSideAxis = getSideAxis(d2.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((d2) => [d2.placement, d2.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a2, b2) => a2[1] - b2[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: platform3,
      elements: elements2
    } = state;
    const rtl = await (platform3.isRTL == null ? void 0 : platform3.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 = rtl && 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: platform3
        } = state;
        const {
          mainAxis: checkMainAxis = true,
          crossAxis: checkCrossAxis = false,
          limiter = {
            fn: (_ref) => {
              let {
                x: x3,
                y: y4
              } = _ref;
              return {
                x: x3,
                y: y4
              };
            }
          },
          ...detectOverflowOptions
        } = evaluate(options2, state);
        const coords = {
          x: x2,
          y: y3
        };
        const overflow = await platform3.detectOverflow(state, detectOverflowOptions);
        const crossAxis = getSideAxis(placement);
        const mainAxis = getOppositeAxis(crossAxis);
        let mainAxisCoord = coords[mainAxis];
        let crossAxisCoord = coords[crossAxis];
        const clampCoord = (axis, coord) => clamp(coord + overflow[axis === "y" ? "top" : "left"], coord, coord - overflow[axis === "y" ? "bottom" : "right"]);
        if (checkMainAxis) {
          mainAxisCoord = clampCoord(mainAxis, mainAxisCoord);
        }
        if (checkCrossAxis) {
          crossAxisCoord = clampCoord(crossAxis, crossAxisCoord);
        }
        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) {
        var _rawOffset$mainAxis, _rawOffset$crossAxis;
        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: (_rawOffset$mainAxis = rawOffset.mainAxis) != null ? _rawOffset$mainAxis : 0,
          crossAxis: (_rawOffset$crossAxis = rawOffset.crossAxis) != null ? _rawOffset$crossAxis : 0
        };
        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) {
        const {
          placement,
          rects,
          platform: platform3,
          elements: elements2
        } = state;
        const {
          apply = () => {
          },
          ...detectOverflowOptions
        } = evaluate(options2, state);
        const overflow = await platform3.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 (platform3.isRTL == null ? void 0 : platform3.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 shiftData = state.middlewareData.shift;
        const noShift = !shiftData;
        let availableHeight2 = overflowAvailableHeight;
        let availableWidth2 = overflowAvailableWidth;
        if (shiftData != null && shiftData.enabled.x) {
          availableWidth2 = maximumClippingWidth;
        }
        if (shiftData != null && shiftData.enabled.y) {
          availableHeight2 = maximumClippingHeight;
        }
        if (noShift && !alignment) {
          if (isYAxis) {
            availableWidth2 = width - 2 * max(overflow.left, overflow.right);
          } else {
            availableHeight2 = height - 2 * max(overflow.top, overflow.bottom);
          }
        }
        await apply({
          ...state,
          availableWidth: availableWidth2,
          availableHeight: availableHeight2
        });
        const nextDimensions = await platform3.getDimensions(elements2.floating);
        if (width !== nextDimensions.width || height !== nextDimensions.height) {
          return {
            reset: {
              rects: true
            }
          };
        }
        return {};
      }
    };
  };

  // node_modules/.store/@floating-ui/utils@0.2.12-gOxTzMf36nCrbeHpEew-rw/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
  function hasWindow() {
    return typeof window !== "undefined";
  }
  function getNodeName(node) {
    if (isNode2(node)) {
      return (node.nodeName || "").toLowerCase();
    }
    return "#document";
  }
  function getWindow2(node) {
    var _node$ownerDocument;
    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
  }
  function getDocumentElement(node) {
    var _ref;
    return (_ref = (isNode2(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.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 isShadowRoot2(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 css2 = isElement2(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
    return isNotNone(css2.transform) || isNotNone(css2.translate) || isNotNone(css2.scale) || isNotNone(css2.rotate) || isNotNone(css2.perspective) || !isWebKit() && (isNotNone(css2.backdropFilter) || isNotNone(css2.filter)) || willChangeRe.test(css2.willChange || "") || containRe.test(css2.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(node) {
    return /^(html|body|#document)$/.test(getNodeName(node));
  }
  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(node) {
    if (getNodeName(node) === "html") {
      return node;
    }
    const result = (
      // Step into the shadow DOM of the parent of a slotted node.
      node.assignedSlot || // DOM Element detected.
      node.parentNode || // ShadowRoot detected.
      isShadowRoot2(node) && node.host || // Fallback.
      getDocumentElement(node)
    );
    return isShadowRoot2(result) ? result.host : result;
  }
  function getNearestOverflowAncestor(node) {
    const parentNode = getParentNode(node);
    if (isLastTraversableNode(parentNode)) {
      return (node.ownerDocument || node).body;
    }
    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
      return parentNode;
    }
    return getNearestOverflowAncestor(parentNode);
  }
  function getOverflowAncestors(node, list, traverseIframes) {
    var _node$ownerDocument2;
    if (list === void 0) {
      list = [];
    }
    if (traverseIframes === void 0) {
      traverseIframes = true;
    }
    const scrollableAncestor = getNearestOverflowAncestor(node);
    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.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/.store/@floating-ui/dom@1.8.0-vHXcr4FgWneV0cgwFw-d7A/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
  function getCssDimensions(element) {
    const css2 = getComputedStyle2(element);
    let width = parseFloat(css2.width) || 0;
    let height = parseFloat(css2.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;
    }
    return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow2(element);
  }
  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 && offsetParent) {
      const win = getWindow2(domElement);
      const offsetWin = isElement2(offsetParent) ? getWindow2(offsetParent) : offsetParent;
      let currentWin = win;
      let currentIFrame = getFrameElement(currentWin);
      while (currentIFrame && offsetWin !== currentWin) {
        const iframeScale = getScale(currentIFrame);
        const iframeRect = currentIFrame.getBoundingClientRect();
        const css2 = getComputedStyle2(currentIFrame);
        const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css2.paddingLeft)) * iframeScale.x;
        const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css2.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(_ref) {
    let {
      elements: elements2,
      rect,
      offsetParent,
      strategy
    } = _ref;
    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 || !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 element.getClientRects ? Array.from(element.getClientRects()) : [];
  }
  function getDocumentRect(html) {
    const scroll = getNodeScroll(html);
    const body = html.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(html);
    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, rootBoundary) {
    if (rootBoundary === void 0) {
      rootBoundary = "viewport";
    }
    const isLayoutViewport = rootBoundary === "layoutViewport";
    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) {
      const layoutRelativeClientCoords = !isWebKit() || strategy === "fixed";
      if (isLayoutViewport) {
        if (!layoutRelativeClientCoords) {
          x2 = -visualViewport.offsetLeft;
          y3 = -visualViewport.offsetTop;
        }
      } else {
        width = visualViewport.width;
        height = visualViewport.height;
        if (layoutRelativeClientCoords) {
          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 reservedWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
      const gutter = getComputedStyle(html).scrollbarGutter === "stable both-edges" ? reservedWidth / 2 : reservedWidth;
      if (gutter <= SCROLLBAR_MAX) {
        width -= gutter;
      }
    }
    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 = getScale(element);
    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" || clippingAncestor === "layoutViewport") {
      rect = getViewportRect(element, strategy, clippingAncestor);
    } 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 getClippingElementAncestors(element, cache) {
    const cachedResult = cache.get(element);
    if (cachedResult) {
      return cachedResult;
    }
    let result = getOverflowAncestors(element, [], false).filter((el) => isElement2(el) && getNodeName(el) !== "body");
    let lastKeptComputedStyle = 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);
      const lastPosition = lastKeptComputedStyle ? lastKeptComputedStyle.position : elementIsFixed ? "fixed" : "";
      const shouldDropCurrentNode = !currentNodeIsContaining && (lastPosition === "fixed" || lastPosition === "absolute" && computedStyle.position === "static");
      if (shouldDropCurrentNode) {
        result = result.filter((ancestor) => ancestor !== currentNode);
      } else {
        lastKeptComputedStyle = computedStyle;
      }
      currentNode = getParentNode(currentNode);
    }
    cache.set(element, result);
    return result;
  }
  function getClippingRect(_ref) {
    let {
      element,
      boundary,
      rootBoundary,
      strategy
    } = _ref;
    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 i2 = 1; i2 < clippingAncestors.length; i2++) {
      const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i2], 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);
    if (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;
      }
    }
    if (!isOffsetParentAnElement && documentElement) {
      offsets.x = getWindowScrollBarX(documentElement);
    }
    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(a2, b2) {
    return a2.x === b2.x && a2.y === b2.y && a2.width === b2.width && a2.height === b2.height;
  }
  function observeMove(element, onMove, ancestorResize) {
    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 (!rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
          return refresh();
        }
        if (ratio !== threshold) {
          if (!isFirstUpdate) {
            return refresh();
          }
          if (!ratio) {
            timeoutId = setTimeout(() => {
              refresh(false, 1e-7);
            }, 1e3);
          } else {
            refresh(false, ratio);
          }
        }
        isFirstUpdate = false;
      }
      try {
        io = new IntersectionObserver(handleObserve, {
          ...options2,
          // Handle <iframe>s
          root: root.ownerDocument
        });
      } catch (_e) {
        io = new IntersectionObserver(handleObserve, options2);
      }
      io.observe(element);
    }
    const win = getWindow2(element);
    const handleResize = () => refresh(ancestorResize);
    win.addEventListener("resize", handleResize);
    refresh(true);
    return () => {
      win.removeEventListener("resize", handleResize);
      cleanup();
    };
  }
  function autoUpdate(reference, floating, update2, 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", update2);
      ancestorResize && ancestor.addEventListener("resize", update2);
    });
    const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update2, ancestorResize) : null;
    let reobserveFrame = -1;
    let resizeObserver = null;
    if (elementResize) {
      resizeObserver = new ResizeObserver((_ref) => {
        let [firstEntry] = _ref;
        if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
          resizeObserver.unobserve(floating);
          cancelAnimationFrame(reobserveFrame);
          reobserveFrame = requestAnimationFrame(() => {
            var _resizeObserver;
            (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
          });
        }
        update2();
      });
      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)) {
        update2();
      }
      prevRefRect = nextRefRect;
      frameId = requestAnimationFrame(frameLoop);
    }
    update2();
    return () => {
      var _resizeObserver2;
      ancestors.forEach((ancestor) => {
        ancestorScroll && ancestor.removeEventListener("scroll", update2);
        ancestorResize && ancestor.removeEventListener("resize", update2);
      });
      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 cache = /* @__PURE__ */ new Map();
    const mergedOptions = options2 != null ? options2 : {};
    const platformWithCache = {
      ...platform,
      ...mergedOptions.platform,
      _c: cache
    };
    return computePosition(reference, floating, {
      ...mergedOptions,
      platform: platformWithCache
    });
  };

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/popover/popover.js
  var TagName20 = "div";
  var placingWriters = /* @__PURE__ */ new WeakMap();
  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 getOverflowPaddingValue(padding) {
    if (typeof padding === "number") return padding;
    return Math.max(padding.left ?? 0, padding.right ?? 0);
  }
  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: availableWidth2, availableHeight: availableHeight2, rects }) {
        if (shouldCancel?.()) return;
        const wrapper = elements2.floating;
        const referenceWidth = Math.round(rects.reference.width);
        availableWidth2 = Math.floor(availableWidth2);
        availableHeight2 = Math.floor(availableHeight2);
        wrapper.style.setProperty("--popover-anchor-width", `${referenceWidth}px`);
        wrapper.style.setProperty("--popover-available-width", `${availableWidth2}px`);
        wrapper.style.setProperty("--popover-available-height", `${availableHeight2}px`);
        if (props.sameWidth) wrapper.style.width = `${referenceWidth}px`;
        if (props.fitViewport) {
          wrapper.style.maxWidth = `${availableWidth2}px`;
          wrapper.style.maxHeight = `${availableHeight2}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 shouldPreserveTabOrder = preserveTabOrder && portal && !modal;
    const disclosureElement = useStoreState(store, shouldPreserveTabOrder ? ["disclosureElement"] : [], (state) => shouldPreserveTabOrder ? state.disclosureElement : null);
    const popoverElement = useStoreState(store, "popoverElement");
    const placing = useStoreState(store, "unstable_placing");
    const contentElement = useStoreState(store, "contentElement");
    const placement = useStoreState(store, "placement");
    const mounted = useStoreState(store, "mounted");
    const rendered = useStoreState(store, "rendered");
    const defaultArrowElementRef = (0, import_react28.useRef)(null);
    const requestedElementRef = (0, import_react28.useRef)(null);
    const requestedInitialFocus = !!popoverElement && requestedElementRef.current === popoverElement;
    const positioned = !placing || requestedInitialFocus;
    const autoFocusOnShowProp = useBooleanEvent(autoFocusOnShow);
    const shouldAutoFocusOnShow = useEvent((element) => {
      const shouldFocus = autoFocusOnShowProp(element);
      if (!store?.getState().unstable_placing) requestedElementRef.current = popoverElement;
      return shouldFocus;
    });
    useSafeLayoutEffect(() => {
      return sync(store, ["open"], () => {
        requestedElementRef.current = null;
      });
    }, [store]);
    const { portalRef, domReady } = usePortalRef(portal, props.portalRef);
    const getAnchorRectProp = useEvent(getAnchorRect);
    const updatePositionProp = useEvent(updatePosition);
    const hasCustomUpdatePosition = !!updatePosition;
    const overflowPaddingTop = typeof overflowPadding === "number" ? overflowPadding : overflowPadding.top ?? 0;
    const overflowPaddingRight = typeof overflowPadding === "number" ? overflowPadding : overflowPadding.right ?? 0;
    const overflowPaddingBottom = typeof overflowPadding === "number" ? overflowPadding : overflowPadding.bottom ?? 0;
    const overflowPaddingLeft = typeof overflowPadding === "number" ? overflowPadding : overflowPadding.left ?? 0;
    const hiddenWhileUnmounted = !mounted && isHidden(mounted, props.hidden, props.alwaysVisible);
    useSafeLayoutEffect(() => {
      if (mounted) store?.setState("unstable_placing", true);
      if (!popoverElement?.isConnected) return;
      const positioningPadding = {
        top: overflowPaddingTop,
        right: overflowPaddingRight,
        bottom: overflowPaddingBottom,
        left: overflowPaddingLeft
      };
      popoverElement.style.setProperty("--popover-overflow-padding", `${getOverflowPaddingValue(positioningPadding)}px`);
      if (hiddenWhileUnmounted && !hasCustomUpdatePosition) return;
      const anchor = getAnchorElement(anchorElement, getAnchorRectProp);
      let canceled = false;
      let placed = 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 arrow5 = arrowElement || defaultArrowElementRef.current;
        const middleware = [
          getOffsetMiddleware(arrow5, {
            gutter,
            shift: shift4
          }),
          getFlipMiddleware({
            flip: flip4,
            overflowPadding: positioningPadding
          }),
          getShiftMiddleware({
            slide,
            shift: shift4,
            overlap,
            overflowPadding: positioningPadding
          }),
          getArrowMiddleware(arrow5, { arrowPadding }),
          getSizeMiddleware({
            sameWidth,
            fitViewport,
            overflowPadding: positioningPadding
          }, shouldCancelUpdate)
        ];
        const pos = await computePosition2(anchor, popoverElement, {
          placement,
          strategy: fixed ? "fixed" : "absolute",
          middleware
        });
        if (shouldCancelUpdate()) return;
        store?.setState("currentPlacement", pos.placement);
        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)`
        });
        placed = true;
        if (arrow5 && pos.middlewareData.arrow) {
          const { x: arrowX, y: arrowY } = pos.middlewareData.arrow;
          const side = getBasePlacement(pos.placement);
          const centerX = arrow5.clientWidth / 2;
          const centerY = arrow5.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(arrow5.style, {
            left: arrowX != null ? `${arrowX}px` : "",
            top: arrowY != null ? `${arrowY}px` : "",
            right: "",
            bottom: "",
            [side]: "100%"
          });
        }
      };
      const update2 = async () => {
        if (shouldCancelUpdate()) return;
        try {
          if (hasCustomUpdatePosition) await updatePositionProp({ updatePosition: updatePosition2 });
          else await updatePosition2();
        } catch (error2) {
          if (placed && !shouldCancelUpdate()) store?.setState("unstable_placing", false);
          throw error2;
        }
        if (shouldCancelUpdate()) return;
        store?.setState("unstable_placing", false);
      };
      const cancelAutoUpdate = autoUpdate(anchor, popoverElement, update2, { elementResize: typeof ResizeObserver === "function" });
      return () => {
        canceled = true;
        cancelAutoUpdate();
      };
    }, [
      store,
      rendered,
      popoverElement,
      arrowElement,
      anchorElement,
      placement,
      mounted,
      hiddenWhileUnmounted,
      domReady,
      fixed,
      flip4,
      shift4,
      slide,
      overlap,
      sameWidth,
      fitViewport,
      gutter,
      arrowPadding,
      overflowPaddingTop,
      overflowPaddingRight,
      overflowPaddingBottom,
      overflowPaddingLeft,
      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
    ]);
    useSafeLayoutEffect(() => {
      if (!store) return;
      const currentStore = store;
      placingWriters.set(currentStore, (placingWriters.get(currentStore) ?? 0) + 1);
      const desync = sync(currentStore, ["mounted"], (state) => {
        currentStore.setState("unstable_placing", state.mounted);
      });
      return () => {
        desync();
        placingWriters.set(currentStore, (placingWriters.get(currentStore) ?? 1) - 1);
        queueMicrotask(() => {
          if (placingWriters.get(currentStore)) return;
          currentStore.setState("unstable_placing", false);
        });
      };
    }, [store]);
    const position = fixed ? "fixed" : "absolute";
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("div", {
      ...wrapperProps,
      style: {
        position,
        top: 0,
        left: 0,
        width: "max-content",
        ...wrapperProps?.style
      },
      ref: store?.setPopoverElement,
      children: element
    }), [
      store,
      position,
      wrapperProps
    ]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(PopoverScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    props = {
      "data-placing": placing || void 0,
      ...props,
      style: {
        position: "relative",
        ...props.style
      }
    };
    props = useDialog({
      store,
      modal,
      portal,
      preserveTabOrder,
      preserveTabOrderAnchor: disclosureElement || anchorElement,
      autoFocusOnShow: positioned && !!autoFocusOnShow && shouldAutoFocusOnShow,
      ...props,
      portalRef,
      unstable_wrapperElement: popoverElement
    });
    return props;
  });
  var Popover = createDialogComponent(forwardRef2(function Popover2(props) {
    const htmlProps = usePopover(props);
    return createElement(TagName20, htmlProps);
  }), usePopoverProviderContext);

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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 length = polygon.length;
    for (let l3 = length, i2 = 0, j2 = l3 - 1; i2 < l3; j2 = i2++) {
      const currentPoint = polygon[i2];
      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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/C0hvEg6i.js
  var import_react29 = __toESM(require_react(), 1);
  var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
  function useEscapeClose({ hideOnEscape, onClose, onEscapeClose }) {
    const acceptedEscapeRef = (0, import_react29.useRef)(null);
    return {
      hideOnEscape: useEvent((event) => {
        if (isFalsyBooleanCallback(hideOnEscape, event)) return false;
        const acceptedEscape = {};
        acceptedEscapeRef.current = acceptedEscape;
        setTimeout(() => {
          if (acceptedEscapeRef.current !== acceptedEscape) return;
          acceptedEscapeRef.current = null;
        });
        return true;
      }),
      onClose: useEvent((event) => {
        const acceptedEscape = acceptedEscapeRef.current;
        acceptedEscapeRef.current = null;
        onClose?.(event);
        if (event.defaultPrevented) return;
        if (!acceptedEscape) return;
        onEscapeClose();
      })
    };
  }
  var TagName21 = "div";
  function isMovingOnHovercard(path, card, hoverElements, nested) {
    if (hasFocusWithin(card)) return true;
    if (path.includes(card)) return true;
    if (hoverElements.some((element) => element && path.includes(element))) 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);
    const polygon = getElementPolygon(element, enterPoint);
    if (!isPointInPolygon(currentPoint, polygon)) 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_react29.useState)(false);
    const mounted = useStoreState(store, "mounted");
    (0, import_react29.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_react29.useRef)(null);
    (0, import_react29.useEffect)(() => {
      return sync(store, ["anchorElement"], (state) => {
        finalFocusRef.current = state.anchorElement;
      });
    }, [store]);
    props = {
      autoFocusOnHide,
      finalFocus: finalFocusRef,
      ...props,
      onFocus
    };
    return props;
  }
  var NestedHovercardContext = (0, import_react29.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_react29.useRef)(null);
    const nestedHovercardsRef = (0, import_react29.useRef)([]);
    const hideTimeoutRef = (0, import_react29.useRef)(0);
    const enterPointRef = (0, import_react29.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 open2 = useStoreState(store, "open");
    const mounted = useStoreState(store, "mounted");
    const clearHideTimeout = (0, import_react29.useCallback)(() => {
      window.clearTimeout(hideTimeoutRef.current);
      hideTimeoutRef.current = 0;
    }, []);
    (0, import_react29.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, disclosureElement, hideTimeout, timeout } = store.getState();
        const path = event.composedPath();
        const hoverElements = [anchorElement, disclosureElement];
        const hoveredElement = hoverElements.find((element2) => element2 && path.includes(element2));
        if (isMovingOnHovercard(path, element, hoverElements, nestedHovercardsRef.current)) {
          enterPointRef.current = hoveredElement ? 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_react29.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_react29.useEffect)(() => {
      if (!domReady) return;
      if (open2) return;
      store?.setAutoFocusOnShow(false);
    }, [
      store,
      domReady,
      open2
    ]);
    const openRef = useLiveRef(open2);
    (0, import_react29.useEffect)(() => {
      if (!domReady) return;
      return () => {
        if (!openRef.current) store?.setAutoFocusOnShow(false);
      };
    }, [store, domReady]);
    const registerOnParent = (0, import_react29.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,
      registerOnParent
    ]);
    const registerNestedHovercard = (0, import_react29.useCallback)((element) => {
      clearHideTimeout();
      nestedHovercardsRef.current = [...nestedHovercardsRef.current, element];
      const parentUnregister = registerOnParent?.(element);
      return () => {
        clearHideTimeout();
        nestedHovercardsRef.current = nestedHovercardsRef.current.filter((item) => item !== 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, ["autoFocusOnShow"], (state) => modal || state.autoFocusOnShow);
    const escapeClose = useEscapeClose({
      hideOnEscape,
      onClose: props.onClose,
      onEscapeClose() {
        requestAnimationFrame(() => {
          requestAnimationFrame(() => {
            if (!store?.getState().open) return;
            store.hide();
          });
        });
      }
    });
    props = usePopover({
      store,
      modal,
      portal,
      autoFocusOnShow,
      ...props,
      portalRef,
      hideOnEscape: escapeClose.hideOnEscape,
      onClose: escapeClose.onClose
    });
    return props;
  });
  var Hovercard = createDialogComponent(forwardRef2(function Hovercard2(props) {
    const htmlProps = useHovercard(props);
    return createElement(TagName21, htmlProps);
  }), useHovercardProviderContext);

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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, ["type"], (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) {
    const htmlProps = useTooltip(props);
    return createElement(TagName22, htmlProps);
  }), useTooltipProviderContext);

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/Dv0S4FLv.js
  var import_react30 = __toESM(require_react(), 1);
  var useHovercardTrigger = createHook(function useHovercardTrigger2({ store, showOnHover = true, unstable_showOnHoverWhenDisabled: showOnHoverWhenDisabled = true, setAnchorElement = false, ...props }) {
    const disabled2 = disabledFromProps(props);
    const focusable2 = props.focusable !== false;
    const triggerRef = (0, import_react30.useRef)(null);
    const showTimeoutRef = (0, import_react30.useRef)(0);
    const isTrulyDisabled = useEvent((element) => {
      if (disabled2 && !focusable2) return true;
      return trulyDisabledFromElement(element);
    });
    (0, import_react30.useEffect)(() => () => window.clearTimeout(showTimeoutRef.current), []);
    (0, import_react30.useEffect)(() => {
      const onMouseLeave = (event) => {
        const trigger = triggerRef.current;
        if (!trigger) return;
        if (event.target !== trigger) return;
        window.clearTimeout(showTimeoutRef.current);
        showTimeoutRef.current = 0;
      };
      return addGlobalEventListener("mouseleave", onMouseLeave, true);
    }, []);
    const onMouseMoveProp = props.onMouseMove;
    const showOnHoverProp = useBooleanEvent(showOnHover);
    const showOnHoverWhenDisabledProp = useBooleanEvent(showOnHoverWhenDisabled);
    const isMouseMoving = useIsMouseMoving();
    const onMouseMove = useEvent((event) => {
      onMouseMoveProp?.(event);
      if (event.defaultPrevented) return;
      if (showTimeoutRef.current) return;
      if (!isMouseMoving()) return;
      const element = event.currentTarget;
      if (isTrulyDisabled(element)) return;
      if (disabled2 || disabledFromElement(element)) {
        if (!showOnHoverWhenDisabledProp(event)) return;
      }
      if (!showOnHoverProp(event)) return;
      if (setAnchorElement) store.setAnchorElement(element);
      store.setDisclosureElement(element);
      const { showTimeout, timeout } = store.getState();
      const showHovercard = () => {
        showTimeoutRef.current = 0;
        if (!isMouseMoving()) return;
        if (isTrulyDisabled(element)) return;
        if (setAnchorElement) 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);
      window.clearTimeout(showTimeoutRef.current);
      showTimeoutRef.current = 0;
    });
    const ref = (0, import_react30.useCallback)((element) => {
      triggerRef.current = element;
      if (!setAnchorElement) return;
      const { anchorElement } = store.getState();
      if (anchorElement?.isConnected) return;
      store.setAnchorElement(element);
    }, [store, setAnchorElement]);
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref),
      onMouseMove,
      onClick
    };
    props = useFocusable(props);
    return props;
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/hovercard/hovercard-anchor.js
  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.");
    return useHovercardTrigger({
      store,
      showOnHover,
      setAnchorElement: true,
      ...props
    });
  });
  var HovercardAnchor = forwardRef2(function HovercardAnchor2(props) {
    const htmlProps = useHovercardAnchor(props);
    return createElement(TagName23, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/tooltip/tooltip-anchor.js
  var import_react31 = __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 isEscapeKeyEvent(event) {
    if (!("key" in event)) return false;
    return event.key === "Escape";
  }
  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_react31.useRef)(false);
    (0, import_react31.useEffect)(() => {
      return sync(store, ["mounted"], (state) => {
        if (state.mounted) return;
        canShowOnHoverRef.current = false;
      });
    }, [store]);
    const returningFocusRef = (0, import_react31.useRef)(false);
    const returnedFocusRef = (0, import_react31.useRef)(null);
    (0, import_react31.useEffect)(() => {
      return sync(store, ["open"], (state) => {
        if (state.open) return;
        if (!store) return;
        const { contentElement } = store.getState();
        if (!contentElement) return;
        if (!hasFocusWithin(contentElement)) return;
        returningFocusRef.current = true;
        setTimeout(() => {
          returningFocusRef.current = false;
        });
      });
    }, [store]);
    const onFocusProp = props.onFocus;
    const onFocus = useEvent((event) => {
      onFocusProp?.(event);
      if (!returningFocusRef.current) return;
      returningFocusRef.current = false;
      returnedFocusRef.current = event.nativeEvent;
    });
    (0, import_react31.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;
      if (isEscapeKeyEvent(event.nativeEvent)) return;
      if (event.nativeEvent === returnedFocusRef.current) 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 labelElement = useStoreState(store, ["type", "contentElement"], (state) => state.type === "label" ? state.contentElement : null);
    useAttribute(labelElement, "id");
    const labelledBy = labelElement?.id;
    props = {
      "aria-labelledby": props["aria-label"] == null ? labelledBy : void 0,
      ...props,
      onMouseEnter,
      onFocus,
      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) {
    const htmlProps = useTooltipAnchor(props);
    return createElement(TagName24, htmlProps);
  });

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/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",
      "unstable_placing"
    ]));
    throwOnConflictingProps(props, store);
    const syncState = store?.getState();
    const dialog = createDialogStore({
      ...props,
      store
    });
    const placement = defaultValue(props.placement, syncState?.placement, "bottom");
    const initialState2 = {
      ...dialog.getState(),
      placement,
      currentPlacement: placement,
      anchorElement: defaultValue(syncState?.anchorElement, null),
      popoverElement: defaultValue(syncState?.popoverElement, null),
      arrowElement: defaultValue(syncState?.arrowElement, null),
      rendered: /* @__PURE__ */ Symbol("rendered"),
      unstable_placing: false
    };
    const popover = createStore(initialState2, dialog, store);
    let syncedAnchorElement = initialState2.anchorElement === initialState2.disclosureElement ? initialState2.anchorElement : null;
    setup(popover, () => sync(popover, ["anchorElement", "disclosureElement"], (state) => {
      if (state.anchorElement && state.anchorElement !== syncedAnchorElement) {
        syncedAnchorElement = null;
        return;
      }
      syncedAnchorElement = state.disclosureElement;
      popover.setState("anchorElement", syncedAnchorElement);
    }));
    setup(popover, () => otherPopover?.unstable_onHideRequest(dialog.unstable_requestHide));
    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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/popover/popover-store.js
  function usePopoverStoreProps(store, update2, props) {
    useUpdateEffect(update2, [props.popover, update2]);
    useStoreProps(store, props, "placement");
    return useDialogStoreProps(store, update2, props);
  }

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/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 initialState2 = {
      ...popover.getState(),
      timeout,
      showTimeout: defaultValue(props.showTimeout, syncState?.showTimeout),
      hideTimeout: defaultValue(props.hideTimeout, syncState?.hideTimeout),
      autoFocusOnShow: defaultValue(syncState?.autoFocusOnShow, false)
    };
    const hovercard = createStore(initialState2, popover, props.store);
    return {
      ...popover,
      ...hovercard,
      setAutoFocusOnShow: (value) => hovercard.setState("autoFocusOnShow", value)
    };
  }

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

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/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 initialState2 = {
      ...hovercard.getState(),
      type: defaultValue(props.type, syncState?.type, "description"),
      skipTimeout: defaultValue(props.skipTimeout, syncState?.skipTimeout, 300)
    };
    const tooltip = createStore(initialState2, hovercard, props.store);
    return {
      ...hovercard,
      ...tooltip
    };
  }

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/button/button.js
  var import_react32 = __toESM(require_react(), 1);
  var TagName25 = "button";
  var useButton = createHook(function useButton2(props) {
    const ref = (0, import_react32.useRef)(null);
    const tagName = useTagName(ref, TagName25);
    const [isNativeButton, setIsNativeButton] = (0, import_react32.useState)(() => !!tagName && isButton({
      tagName,
      type: props.type
    }));
    (0, import_react32.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) {
    const htmlProps = useButton(withDefaultButtonType(props));
    return createElement(TagName25, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/disclosure/disclosure.js
  var import_react33 = __toESM(require_react(), 1);
  var TagName26 = "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_react33.useRef)(null);
    const [expanded, setExpanded] = (0, import_react33.useState)(false);
    const disclosureElement = useStoreState(store, "disclosureElement");
    const open2 = useStoreState(store, "open");
    const setDisclosureElement = (0, import_react33.useCallback)((element) => {
      const previousElement = ref.current;
      ref.current = element;
      if (element) {
        if (!store?.getState().disclosureElement?.isConnected) store.setDisclosureElement(element);
        return;
      }
      if (store?.getState().disclosureElement !== previousElement) return;
      store.setDisclosureElement(null);
    }, [store]);
    (0, import_react33.useEffect)(() => {
      let isCurrentDisclosure = disclosureElement === ref.current;
      if (!disclosureElement?.isConnected) {
        store?.setDisclosureElement(ref.current);
        isCurrentDisclosure = true;
      }
      setExpanded(open2 && isCurrentDisclosure);
    }, [
      disclosureElement,
      store,
      open2
    ]);
    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(setDisclosureElement, props.ref),
      onClick
    };
    props = useButton(props);
    return props;
  });
  var Disclosure = forwardRef2(function Disclosure2(props) {
    const htmlProps = useDisclosure(withDefaultButtonType(props));
    return createElement(TagName26, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/dialog/dialog-disclosure.js
  var TagName27 = "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.");
    const contentElement = useStoreState(store, "contentElement");
    props = {
      "aria-haspopup": getPopupRole(contentElement, "dialog"),
      ...props
    };
    props = useDisclosure({
      store,
      ...props
    });
    return props;
  });
  var DialogDisclosure = forwardRef2(function DialogDisclosure2(props) {
    const htmlProps = useDialogDisclosure(withDefaultButtonType(props));
    return createElement(TagName27, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/popover/popover-disclosure.js
  var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
  var TagName28 = "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.");
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(PopoverScopedContextProvider, {
      value: store,
      children: element
    }), [store]);
    props = useDialogDisclosure({
      store,
      ...props
    });
    return props;
  });
  var PopoverDisclosure = forwardRef2(function PopoverDisclosure2(props) {
    const htmlProps = usePopoverDisclosure(withDefaultButtonType(props));
    return createElement(TagName28, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/popover/popover-disclosure-arrow.js
  var import_react34 = __toESM(require_react(), 1);
  var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
  var TagName29 = "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 position = useStoreState(store, ["placement"], (state) => placement || state.placement);
    const dir = getBasePlacement(position);
    const points = pointsMap[dir];
    props = {
      children: (0, import_react34.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 props;
  });
  var PopoverDisclosureArrow = forwardRef2(function PopoverDisclosureArrow2(props) {
    const htmlProps = usePopoverDisclosureArrow(props);
    return createElement(TagName29, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/radio/radio-context.js
  var import_react35 = __toESM(require_react(), 1);
  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;
  var RadioGroupDisabledContext = (0, import_react35.createContext)(false);

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/radio/radio.js
  var import_react36 = __toESM(require_react(), 1);
  var TagName30 = "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: checked2, ...props }) {
    const context = useRadioContext();
    store = store || context;
    const groupDisabled = (0, import_react36.useContext)(RadioGroupDisabledContext);
    const id3 = useId(props.id);
    const ref = (0, import_react36.useRef)(null);
    const isChecked = useStoreState(store, ["value"], (state) => checked2 ?? getIsChecked(value, state?.value));
    const storeId = useStoreState(store, "id");
    const name = nameProp ?? storeId;
    (0, import_react36.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, TagName30), props.type);
    const disabled2 = groupDisabled || disabledFromProps(props);
    const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
    (0, import_react36.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 (disabled2) {
        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 (disabled2) 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,
      disabled: disabled2 || void 0,
      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) {
    const htmlProps = useRadio(props);
    return createElement(TagName30, htmlProps);
  }));

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/radio/radio-group.js
  var import_react37 = __toESM(require_react(), 1);
  var import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
  var TagName31 = "div";
  function isCheckedRadio(element) {
    if (!element) return false;
    if (element.tagName === "INPUT") {
      const { type, checked: checked2 } = element;
      if (type === "radio") return checked2;
    }
    if (element.getAttribute("role") !== "radio") return false;
    return element.getAttribute("aria-checked") === "true";
  }
  function getCheckedRadioId(store) {
    const { renderedItems } = store.getState();
    return renderedItems.find((item) => isCheckedRadio(item.element))?.id;
  }
  var useRadioGroup = createHook(function useRadioGroup2({ store, ...props }) {
    const context = useRadioProviderContext();
    store = store || context;
    const disabled2 = (0, import_react37.useContext)(RadioGroupDisabledContext) || disabledFromProps(props);
    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: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(RadioGroupDisabledContext.Provider, {
        value: disabled2,
        children: element
      })
    }), [store, disabled2]);
    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,
      "aria-disabled": disabled2 || void 0,
      onBlurCapture
    };
    props = useComposite({
      store,
      ...props
    });
    return props;
  });
  var RadioGroup = forwardRef2(function RadioGroup2(props) {
    const htmlProps = useRadioGroup(props);
    return createElement(TagName31, htmlProps);
  });

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/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 initialState2 = {
      ...composite.getState(),
      value: defaultValue(props.value, syncState?.value, props.defaultValue, null)
    };
    const radio = createStore(initialState2, composite, props.store);
    return {
      ...composite,
      ...radio,
      setValue: (value) => radio.setState("value", value)
    };
  }

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/composite/composite-typeahead.js
  var TagName32 = "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((item) => item.element === target);
  }
  function getEnabledItems2(items) {
    return items.filter((item) => !item.disabled);
  }
  function itemTextStartsWith(item, text) {
    const itemText = item.typeaheadText ?? (item.element?.textContent || item.children || "value" in item && item.value);
    if (!itemText) return false;
    return normalizeString(itemText).trim().toLowerCase().startsWith(text.toLowerCase());
  }
  function getSameInitialItems({ activeId, char, items, typeaheadState }) {
    if (!activeId) return items;
    const activeItem = items.find((item) => item.id === activeId);
    if (!activeItem) return items;
    if (!itemTextStartsWith(activeItem, char)) return items;
    const { chars } = typeaheadState;
    if (chars !== char && itemTextStartsWith(activeItem, chars)) return items;
    typeaheadState.chars = char;
    return flipItems2(items.filter((item) => itemTextStartsWith(item, char)), activeId).filter((item) => item.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 } = store.getState();
      let enabledItems = getEnabledItems2(items.length > renderedItems.length ? items : renderedItems);
      if (!isSelfTargetOrItem(event, enabledItems)) return clearChars(typeaheadState);
      event.preventDefault();
      window.clearTimeout(typeaheadState.cleanupTimeout);
      typeaheadState.cleanupTimeout = window.setTimeout(() => {
        clearChars(typeaheadState);
      }, 500);
      const char = event.key.toLowerCase();
      typeaheadState.chars += char;
      enabledItems = getSameInitialItems({
        activeId,
        char,
        items: enabledItems,
        typeaheadState
      });
      const item = enabledItems.find((item2) => itemTextStartsWith(item2, typeaheadState.chars));
      if (item) store.move(item.id);
      else clearChars(typeaheadState);
    });
    props = {
      ...props,
      onKeyDownCapture
    };
    return removeUndefinedValues(props);
  });
  var CompositeTypeahead = forwardRef2(function CompositeTypeahead2(props) {
    const htmlProps = useCompositeTypeahead(props);
    return createElement(TagName32, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/select/select-arrow.js
  var TagName33 = "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) {
    const htmlProps = useSelectArrow(props);
    return createElement(TagName33, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/select/select.js
  var import_react38 = __toESM(require_react(), 1);
  var import_jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
  var TagName34 = "button";
  function getSelectedValues(select) {
    return Array.from(select.selectedOptions).map((option) => option.value);
  }
  function nextWithValue(store, next) {
    return () => {
      const visitedIds = /* @__PURE__ */ new Set();
      let nextId = next();
      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 = next({ 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 disabledProp = disabledFromProps(props);
    const showOnKeyDownProp = useBooleanEvent(showOnKeyDown);
    const moveOnKeyDownProp = useBooleanEvent(moveOnKeyDown);
    const placement = useStoreState(store, "placement");
    const dir = getBasePlacement(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((item) => !item.disabled && item.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_react38.useState)(false);
    const nativeSelectChangedRef = (0, import_react38.useRef)(false);
    (0, import_react38.useEffect)(() => {
      const nativeSelectChanged = nativeSelectChangedRef.current;
      nativeSelectChangedRef.current = false;
      if (nativeSelectChanged) return;
      setAutofill(false);
    }, [value]);
    const labelElement = useStoreState(store, "labelElement");
    useAttribute(labelElement, "id");
    const labelId = labelElement?.id;
    const label = props["aria-label"];
    const labelledBy = props["aria-labelledby"] || labelId;
    const items = useStoreState(store, ["items"], (state) => {
      if (!name) return;
      return state.items;
    });
    const values = (0, import_react38.useMemo)(() => {
      const itemValues = items?.flatMap((item) => item.value ?? []);
      return [...new Set(itemValues)];
    }, [items]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [!!name && /* @__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: disabledProp,
      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,
      disabledProp
    ]);
    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) {
    const htmlProps = useSelect(withDefaultButtonType(props));
    return createElement(TagName34, htmlProps);
  });

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/group/group.js
  var import_react40 = __toESM(require_react(), 1);
  var import_jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
  var TagName35 = "div";
  var useGroup = createHook(function useGroup2(props) {
    const [labelId, setLabelId] = (0, import_react40.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 props;
  });
  var Group = forwardRef2(function Group2(props) {
    const htmlProps = useGroup(props);
    return createElement(TagName35, htmlProps);
  });

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

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

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/composite/composite-hover.js
  var import_react42 = __toESM(require_react(), 1);
  var TagName39 = "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 compositeElement = store?.getState().compositeElement;
        if (compositeElement && !hasFocus(compositeElement)) compositeElement.focus({ preventScroll: true });
      }
      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().compositeElement?.focus({ preventScroll: true });
    });
    const ref = (0, import_react42.useCallback)((element) => {
      if (!element) return;
      element[symbol3] = true;
    }, []);
    props = {
      ...props,
      ref: useMergeRefs(ref, props.ref),
      onMouseMove,
      onMouseLeave
    };
    return props;
  });
  var CompositeHover = memo2(forwardRef2(function CompositeHover2(props) {
    const htmlProps = useCompositeHover(props);
    return createElement(TagName39, htmlProps);
  }));

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/select/select-item.js
  var import_react43 = __toESM(require_react(), 1);
  var import_jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
  var TagName40 = "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 disabled2 = disabledFromProps(props);
    const { listElement, multiSelectable, selected, autoFocus } = useStoreStateObject(store, [
      "value",
      "activeId",
      "items"
    ], {
      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_react43.useCallback)((item) => {
      const nextItem = {
        ...item,
        value: disabled2 ? void 0 : value
      };
      if (getItemProp) return getItemProp(nextItem);
      return nextItem;
    }, [
      disabled2,
      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 (!store.getState().open) return false;
        if (!focusOnHoverProp(event)) return false;
        return store.getState().open;
      }
    });
    return props;
  });
  var SelectItem = memo2(forwardRef2(function SelectItem2(props) {
    const htmlProps = useSelectItem(props);
    return createElement(TagName40, htmlProps);
  }));

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/checkbox/checkbox-check.js
  var import_react45 = __toESM(require_react(), 1);
  var import_jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
  var TagName41 = "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: checked2, ...props }) {
    const context = (0, import_react45.useContext)(CheckboxCheckedContext);
    checked2 = checked2 ?? context;
    const children = getChildren({
      checked: checked2,
      children: props.children
    });
    props = {
      "aria-hidden": true,
      ...props,
      children,
      style: {
        width: "1em",
        height: "1em",
        pointerEvents: "none",
        ...props.style
      }
    };
    return props;
  });
  var CheckboxCheck = forwardRef2(function CheckboxCheck2(props) {
    const htmlProps = useCheckboxCheck(props);
    return createElement(TagName41, htmlProps);
  });

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/select/select-label.js
  var TagName43 = "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 props;
  });
  var SelectLabel = memo2(forwardRef2(function SelectLabel2(props) {
    const htmlProps = useSelectLabel(props);
    return createElement(TagName43, htmlProps);
  }));

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/select/select-list.js
  var import_react47 = __toESM(require_react(), 1);
  var import_jsx_runtime25 = __toESM(require_jsx_runtime(), 1);
  var TagName44 = "div";
  var SelectListContext = (0, import_react47.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_react47.useState)(value);
    const mounted = useStoreState(store, "mounted");
    (0, import_react47.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_react47.useContext)(SelectHeadingContext);
    const headingState = (0, import_react47.useState)();
    const [headingId, setHeadingId] = headingContext || headingState;
    const headingContextValue = (0, import_react47.useMemo)(() => [headingId, setHeadingId], [headingId, setHeadingId]);
    const [childStore, setChildStore] = (0, import_react47.useState)(null);
    const setStore = (0, import_react47.useContext)(SelectListContext);
    (0, import_react47.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 labelElement = useStoreState(store, ["labelElement"], (state) => headingId ? null : state.labelElement);
    useAttribute(labelElement, "id");
    const labelId = headingId || 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) {
    const htmlProps = useSelectList(props);
    return createElement(TagName44, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/select/select-popover.js
  var TagName45 = "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) {
    const htmlProps = useSelectPopover(props);
    return createElement(TagName45, htmlProps);
  }), useSelectProviderContext);

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/node_modules/@ariakit/components/dist/select/select-store.js
  function createSelectStore({ combobox, ...props } = {}) {
    const store = mergeStore(props.store, omit2(combobox, [
      "value",
      "items",
      "renderedItems",
      "compositeElement",
      "baseElement",
      "arrowElement",
      "anchorElement",
      "contentElement",
      "popoverElement",
      "disclosureElement",
      "inputElement",
      "labelElement",
      "selectElement",
      "selectLabelElement"
    ]));
    throwOnConflictingProps(props, store);
    const syncState = store.getState();
    const composite = createCompositeStore({
      ...props,
      store,
      virtualFocus: defaultValue(props.virtualFocus, syncState.virtualFocus, true),
      compositeElementInFocusOrder: defaultValue(props.compositeElementInFocusOrder, props.includesBaseElement, syncState.compositeElementInFocusOrder, 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, () => combobox?.unstable_onHideRequest(popover.unstable_requestHide));
    setup(select, () => sync(select, ["value", "items"], (state) => {
      if (state.value !== initialValue2) return;
      if (!state.items.length) return;
      const item = state.items.find((item2) => !item2.disabled && item2.value != null);
      if (item?.value == null) return;
      select.setState("value", item.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 item = state.items.find((item2) => !item2.disabled && item2.value === lastValue);
      if (!item) return;
      select.setState("activeId", item.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 item = composite.item(activeId);
      if (!item || item.disabled || item.value == null) return;
      select.setState("value", item.value);
    }));
    return {
      ...composite,
      ...popover,
      ...select,
      combobox,
      setValue: (value) => select.setState("value", value),
      setLabelElement: (element) => {
        select.setState("labelElement", element);
        combobox?.setSelectLabelElement(element);
      },
      setSelectElement: (element) => select.setState("selectElement", element),
      setListElement: (element) => select.setState("listElement", element)
    };
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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, update2, props) {
    useUpdateEffect(update2, [props.combobox, update2]);
    useStoreProps(store, props, "value", "setValue");
    useStoreProps(store, props, "setValueOnMove");
    return Object.assign(usePopoverStoreProps(useCompositeStoreProps(store, update2, props), update2, props), { combobox: props.combobox });
  }
  function useSelectStore(props = {}) {
    props = useSelectStoreOptions(props);
    const [store, update2] = useStore(createSelectStore, props);
    return useSelectStoreProps(store, update2, props);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/composite/composite-row.js
  var import_react48 = __toESM(require_react(), 1);
  var import_jsx_runtime26 = __toESM(require_jsx_runtime(), 1);
  var TagName46 = "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 compositeElement = useStoreState(store, "compositeElement") || void 0;
    const providerValue = (0, import_react48.useMemo)(() => ({
      id: id3,
      compositeElement,
      ariaSetSize,
      ariaPosInSet
    }), [
      id3,
      compositeElement,
      ariaSetSize,
      ariaPosInSet
    ]);
    props = useWrapElement(props, (element) => /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(CompositeRowContext.Provider, {
      value: providerValue,
      children: element
    }), [providerValue]);
    props = {
      ...props,
      id: id3
    };
    return props;
  });
  var CompositeRow = forwardRef2(function CompositeRow2(props) {
    const htmlProps = useCompositeRow(props);
    return createElement(TagName46, htmlProps);
  });

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

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/__chunks/DjvJNLSl.js
  var import_react49 = __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 TagName47 = "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_react49.useState)(defaultChecked ?? false);
    const checked2 = useStoreState(store, ["value"], (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_react49.useRef)(null);
    const nativeCheckbox = isNativeCheckbox(useTagName(ref, TagName47), props.type);
    const mixed = checked2 ? checked2 === "mixed" : void 0;
    const isChecked = checked2 === "mixed" ? false : checked2;
    const disabled2 = disabledFromProps(props);
    const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
    (0, import_react49.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 (disabled2) {
        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": checked2,
      ...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) {
    const htmlProps = useCheckbox(props);
    return createElement(TagName47, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-context.js
  var import_react50 = __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_react50.createContext)(void 0);
  var MenuListHiddenContext = (0, import_react50.createContext)(false);

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-list.js
  var import_react51 = __toESM(require_react(), 1);
  var import_jsx_runtime28 = __toESM(require_jsx_runtime(), 1);
  var TagName48 = "div";
  function useAriaLabelledBy({ store, ...props }) {
    const [id3, setId] = (0, import_react51.useState)(void 0);
    const label = props["aria-label"];
    const disclosureElement = useStoreState(store, "disclosureElement");
    const contentElement = useStoreState(store, "contentElement");
    (0, import_react51.useEffect)(() => {
      const menu2 = contentElement;
      if (!menu2) return;
      const nextId = label || menu2.hasAttribute("aria-label") ? void 0 : disclosureElement?.id || void 0;
      setId(nextId);
    }, [
      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, ["placement"], (state) => getBasePlacement(state.placement));
    const orientation = useStoreState(store, ["orientation"], (state) => state.orientation === "both" ? void 0 : state.orientation);
    const isHorizontal = orientation !== "vertical";
    const isMenubarHorizontal = useStoreState(parentMenubar, ["orientation"], (state) => !!state && state.orientation !== "vertical");
    const onKeyDown = useEvent((event) => {
      onKeyDownProp?.(event);
      if (event.defaultPrevented) return;
      const target = event.target;
      if (!isSelfTarget(event) && !isItem(store, target)) return;
      if (isTextbox(target)) {
        const selection = getTextboxSelection(target);
        const isPrevious = event.key === "ArrowLeft" || event.key === "ArrowUp";
        const isNext = event.key === "ArrowRight" || event.key === "ArrowDown";
        if (isPrevious && selection.start !== 0) return;
        if (isNext && selection.end !== getTextboxValue(target).length) 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.down();
          },
          ArrowUp: () => {
            if (isMenubarHorizontal) return;
            return parentMenubar.up();
          }
        }[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 mounted = useStoreState(store, "mounted");
    const hidden = isHidden(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) {
    const htmlProps = useMenuList(props);
    return createElement(TagName48, htmlProps);
  });

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu.js
  var import_react52 = __toESM(require_react(), 1);
  var TagName49 = "div";
  function hasFocusOnContent(menuElement, state) {
    const activeElement2 = getTreeActiveElement(menuElement);
    if (!activeElement2) return false;
    if (!isElementInside(activeElement2, menuElement)) return false;
    if (!isFocusable(activeElement2)) return false;
    if (activeElement2 !== state.compositeElement) return true;
    return state.renderedItems.some((item) => item.id === state.activeId && !item.disabled);
  }
  var useMenu = createHook(function useMenu2({ store, modal: modalProp = false, portal = modalProp, hideOnEscape = true, autoFocusOnShow = true, hideOnHoverOutside, alwaysVisible, getPersistentElements, unstable_treeSnapshotKey, ...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_react52.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_react52.useState)();
    const owesInitialFocusRef = (0, import_react52.useRef)(true);
    const open2 = useStoreState(store, "open");
    const initialFocusElement = useStoreState(store, [
      "autoFocusOnShow",
      "initialFocus",
      "renderedItems",
      "compositeElement"
    ], (state) => {
      if (!state.autoFocusOnShow) return;
      const isEnabled = (item) => !item.disabled && !!item.element;
      switch (state.initialFocus) {
        case "first":
          return state.renderedItems.find(isEnabled)?.element || null;
        case "last":
          for (let i2 = state.renderedItems.length - 1; i2 >= 0; i2 -= 1) {
            const item = state.renderedItems[i2];
            if (item && isEnabled(item)) return item.element;
          }
          return null;
        default:
          return state.compositeElement;
      }
    });
    (0, import_react52.useEffect)(() => {
      let cleaning = false;
      const menuElement = ref.current;
      const focusOnContent = !owesInitialFocusRef.current && !!menuElement && hasFocusOnContent(menuElement, store.getState());
      owesInitialFocusRef.current = !open2 || initialFocusElement === null && !focusOnContent;
      setInitialFocusRef((prevInitialFocusRef) => {
        if (cleaning) return;
        if (modal && open2 && initialFocusElement === void 0) return prevInitialFocusRef;
        if (initialFocusElement === void 0) return;
        if (initialFocusElement && initialFocusElement === prevInitialFocusRef?.current) return prevInitialFocusRef;
        if (focusOnContent && prevInitialFocusRef) {
          prevInitialFocusRef.current = initialFocusElement;
          return prevInitialFocusRef;
        }
        const ref2 = (0, import_react52.createRef)();
        ref2.current = initialFocusElement;
        return ref2;
      });
      return () => {
        cleaning = true;
      };
    }, [
      store,
      modal,
      open2,
      initialFocusElement
    ]);
    const canAutoFocusOnShow = !!initialFocusRef || !!props.initialFocus || modal;
    const autoFocusOnShowProp = autoFocusOnShow === false ? false : canAutoFocusOnShow && autoFocusOnShow;
    const finalFocusElement = useStoreState(store, ["disclosureElement", "anchorElement"], (state) => state.disclosureElement || state.anchorElement);
    const persistentDisclosure = useStoreState(store, ["disclosureElement", "contentElement"], (state) => {
      const { disclosureElement, contentElement: contentElement2 } = state;
      if (!disclosureElement?.isConnected) return null;
      if (isCapturedDisclosure(disclosureElement)) return null;
      if (contentElement2?.contains(disclosureElement)) return null;
      return disclosureElement;
    });
    const disclosureKey = modal ? persistentDisclosure : null;
    const treeSnapshotKey = (0, import_react52.useMemo)(() => [unstable_treeSnapshotKey, disclosureKey], [unstable_treeSnapshotKey, disclosureKey]);
    const contentElement = useStoreState(store.combobox || store, "contentElement");
    const parentContentElement = useStoreState(parentMenu?.combobox || parentMenu, "contentElement");
    const preserveTabOrderAnchor = (0, import_react52.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
    };
    const escapeClose = useEscapeClose({
      hideOnEscape,
      onClose: props.onClose,
      onEscapeClose: () => parentMenu?.hideAll()
    });
    props = useHovercard({
      store,
      alwaysVisible,
      initialFocus: initialFocusRef,
      autoFocusOnShow: autoFocusOnShowProp,
      finalFocus: finalFocusElement,
      ...props,
      hideOnEscape: escapeClose.hideOnEscape,
      onClose: escapeClose.onClose,
      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;
      },
      getPersistentElements() {
        const elements2 = getPersistentElements?.() || [];
        if (!modal) return elements2;
        if (!persistentDisclosure) return elements2;
        return [...elements2, persistentDisclosure];
      },
      unstable_treeSnapshotKey: treeSnapshotKey,
      modal,
      portal,
      backdrop: hasParentMenu ? false : props.backdrop
    });
    props = {
      "aria-labelledby": ariaLabelledBy,
      ...props
    };
    return props;
  });
  var Menu = createDialogComponent(forwardRef2(function Menu2(props) {
    const htmlProps = useMenu(props);
    return createElement(TagName49, htmlProps);
  }), useMenuProviderContext);

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-button.js
  var import_react53 = __toESM(require_react(), 1);
  var import_jsx_runtime29 = __toESM(require_jsx_runtime(), 1);
  var TagName50 = "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((item) => {
      if (!item.element) return false;
      if (item.element === excludeElement) return false;
      return item.element.getAttribute("aria-expanded") === "true";
    });
  }
  var useMenuButton = createHook(function useMenuButton2({ store, focusable: focusable2, accessibleWhenDisabled, showOnHover, unstable_showOnHoverWhenDisabled: showOnHoverWhenDisabled = false, ...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_react53.useRef)(null);
    const parentMenu = store.parent;
    const parentMenubar = store.menubar;
    const hasParentMenu = !!parentMenu;
    const parentIsMenubar = !!parentMenubar && !hasParentMenu;
    const disabled2 = disabledFromProps(props);
    const isDisabled = (element) => disabled2 || disabledFromElement(element);
    const showMenu = () => {
      const trigger = ref.current;
      if (!trigger) return;
      store?.setDisclosureElement(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, ["placement"], (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: open2 } = store.getState();
        if (open2) {
          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 isKeyboardClick2 = !event.detail;
      const { open: open2 } = store.getState();
      if (!open2 || isKeyboardClick2) {
        if (!hasParentMenu || isKeyboardClick2) store.setAutoFocusOnShow(true);
        store.setInitialFocus(isKeyboardClick2 ? "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");
    const role = hasParentMenu || parentIsMenubar ? getPopupItemRole(parentContentElement, "menuitem") : void 0;
    const contentElement = useStoreState(store, "contentElement");
    const hasCombobox = !!store.combobox;
    props = {
      role,
      "aria-haspopup": getPopupRole(contentElement, hasCombobox ? "dialog" : "menu"),
      ...props,
      id: id3,
      ref: useMergeRefs(ref, props.ref),
      onFocus,
      onKeyDown,
      onClick
    };
    props = useHovercardTrigger({
      store,
      focusable: focusable2,
      accessibleWhenDisabled,
      ...props,
      unstable_showOnHoverWhenDisabled: showOnHoverWhenDisabled,
      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: focusable2,
      accessibleWhenDisabled,
      ...props
    });
    props = useCompositeTypeahead({
      store,
      typeahead: parentIsMenubar,
      ...props
    });
    return props;
  });
  var MenuButton = forwardRef2(function MenuButton2(props) {
    const htmlProps = useMenuButton(props);
    return createElement(TagName50, withDefaultButtonType(htmlProps));
  });

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

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-item.js
  var import_react54 = __toESM(require_react(), 1);
  var TagName53 = "div";
  function menuHasFocus(compositeElement, items, currentTarget) {
    if (!compositeElement) return false;
    if (hasFocusWithin(compositeElement)) return true;
    const expandedMenuId = items?.find((item) => {
      if (item.element === currentTarget) return false;
      return item.element?.getAttribute("aria-expanded") === "true";
    })?.element?.getAttribute("aria-controls");
    if (!expandedMenuId) return false;
    const expandedMenu = getDocument(compositeElement).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, ["contentElement"], (state) => "contentElement" in state ? state.contentElement : null);
    const menuListHidden = (0, import_react54.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 { compositeElement, items } = store.getState();
        if (isWithinMenu) {
          if (event.currentTarget.hasAttribute("aria-expanded")) event.currentTarget.focus({ preventScroll: true });
          return true;
        }
        if (menuHasFocus(compositeElement, items, event.currentTarget)) {
          event.currentTarget.focus({ preventScroll: true });
          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) {
    const htmlProps = useMenuItem(props);
    return createElement(TagName53, htmlProps);
  }));

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

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-item-checkbox.js
  var import_react56 = __toESM(require_react(), 1);
  var TagName55 = "div";
  function getValue(storeValue, value, checked2) {
    if (value === void 0) {
      if (Array.isArray(storeValue)) return storeValue;
      return !!checked2;
    }
    const primitiveValue = getPrimitiveValue(value);
    if (!Array.isArray(storeValue)) {
      if (checked2) return primitiveValue;
      return storeValue === primitiveValue ? false : storeValue;
    }
    if (checked2) {
      if (storeValue.includes(primitiveValue)) return storeValue;
      return [...storeValue, primitiveValue];
    }
    return storeValue.filter((v3) => v3 !== primitiveValue);
  }
  var useMenuItemCheckbox = createHook(function useMenuItemCheckbox2({ store, name, value, checked: checked2, 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_react56.useEffect)(() => {
      store?.setValue(name, (prevValue = value !== void 0 ? [] : false) => {
        if (!defaultChecked) return prevValue;
        return getValue(prevValue, value, true);
      });
    }, [
      store,
      name,
      value,
      defaultChecked
    ]);
    (0, import_react56.useEffect)(() => {
      if (checked2 === void 0) return;
      store?.setValue(name, (prevValue) => {
        return getValue(prevValue, value, checked2);
      });
    }, [
      store,
      name,
      value,
      checked2
    ]);
    const checkboxStore = useCheckboxStore({
      value: useStoreState(store, ["values"], (state) => state.values[name]),
      setValue(internalValue) {
        store?.setValue(name, () => {
          if (checked2 === void 0) return internalValue;
          const nextValue = getValue(internalValue, value, checked2);
          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: checked2,
      ...props
    });
    props = useMenuItem({
      store,
      hideOnClick,
      ...props
    });
    return props;
  });
  var MenuItemCheckbox = memo2(forwardRef2(function MenuItemCheckbox2(props) {
    const htmlProps = useMenuItemCheckbox(props);
    return createElement(TagName55, htmlProps);
  }));

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-item-radio.js
  var import_react57 = __toESM(require_react(), 1);
  var import_jsx_runtime30 = __toESM(require_jsx_runtime(), 1);
  var TagName56 = "div";
  function getValue2(prevValue, value, checked2) {
    if (checked2 === void 0) return prevValue;
    if (checked2) return value;
    return prevValue === value ? false : prevValue;
  }
  var useMenuItemRadio = createHook(function useMenuItemRadio2({ store, name, value, checked: checked2, 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_react57.useEffect)(() => {
      store?.setValue(name, (prevValue = false) => {
        return getValue2(prevValue, value, defaultChecked);
      });
    }, [
      store,
      name,
      value,
      defaultChecked
    ]);
    (0, import_react57.useEffect)(() => {
      if (checked2 === void 0) return;
      store?.setValue(name, (prevValue) => {
        return getValue2(prevValue, value, checked2);
      });
    }, [
      store,
      name,
      value,
      checked2
    ]);
    const isChecked = useStoreState(store, ["values"], (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, checked2 ?? element.checked);
        });
      },
      ...props
    });
    props = useMenuItem({
      store,
      hideOnClick,
      ...props
    });
    return props;
  });
  var MenuItemRadio = memo2(forwardRef2(function MenuItemRadio2(props) {
    const htmlProps = useMenuItemRadio(props);
    return createElement(TagName56, htmlProps);
  }));

  // node_modules/.store/@ariakit/components@0.1.15-b4ubwzeFfstoGvOR7daROQ/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",
      "placement",
      "currentPlacement"
    ]));
    throwOnConflictingProps(props, store);
    const syncState = store.getState();
    const orientedPlacement = (parent || menubar2)?.getState().orientation === "vertical" ? "right-start" : "bottom-start";
    const composite = createCompositeStore({
      ...props,
      store,
      orientation: defaultValue(props.orientation, syncState.orientation, "vertical")
    });
    const hovercard = createHovercardStore({
      ...props,
      store,
      placement: defaultValue(props.placement, syncState.placement, orientedPlacement),
      timeout: defaultValue(props.timeout, syncState.timeout, parentIsMenubar ? 0 : 150),
      hideTimeout: defaultValue(props.hideTimeout, syncState.hideTimeout, 0)
    });
    const initialState2 = {
      ...composite.getState(),
      ...hovercard.getState(),
      initialFocus: defaultValue(syncState.initialFocus, "container"),
      values: defaultValue(props.values, syncState.values, props.defaultValues, {})
    };
    const menu2 = createStore(initialState2, composite, hovercard, store);
    setup(menu2, () => combobox?.unstable_onHideRequest(hovercard.unstable_requestHide));
    setup(menu2, () => sync(menu2, ["mounted"], (state) => {
      if (state.mounted) return;
      menu2.setState("activeId", null);
    }));
    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/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-store.js
  function useMenuStoreProps(store, update2, props) {
    useUpdateEffect(update2, [
      props.combobox,
      props.parent,
      props.menubar,
      update2
    ]);
    useStoreProps(store, props, "values", "setValues");
    return Object.assign(useHovercardStoreProps(useCompositeStoreProps(store, update2, props), update2, 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, update2] = useStore(createMenuStore, props);
    return useMenuStoreProps(store, update2, props);
  }

  // node_modules/.store/@ariakit/react-components@0.7.1-aGG7Eicir0X5jH9sMy0tHA/node_modules/@ariakit/react-components/dist/menu/menu-separator.js
  var TagName57 = "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) {
    const htmlProps = useMenuSeparator(props);
    return createElement(TagName57, htmlProps);
  });

  // 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);
  var CompositeGroupContext = (0, import_element.createContext)(false);
  CompositeGroupContext.displayName = "CompositeGroupContext";
  var useCompositeGroupContext = () => (0, import_element.useContext)(CompositeGroupContext);

  // 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 UnforwardedCompositeGroup(props, ref) {
    const context = useCompositeContext2();
    const { children, ...restProps } = props;
    const store = props.store ?? context.store;
    return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(CompositeGroup, { store, ...restProps, ref, children: /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(CompositeGroupContext.Provider, { value: true, children }) });
  });

  // 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 UnforwardedCompositeGroupLabel(props, ref) {
    const context = useCompositeContext2();
    const isWithinGroup = useCompositeGroupContext();
    if (!isWithinGroup) {
      throw new Error(
        "Composite.GroupLabel can only be rendered inside Composite.Group."
      );
    }
    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 UnforwardedCompositeHover(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_warning = __toESM(require_warning(), 1);
  var import_jsx_runtime34 = __toESM(require_jsx_runtime(), 1);
  var CompositeItem22 = (0, import_element5.forwardRef)(function UnforwardedCompositeItem(props, ref) {
    const context = useCompositeContext2();
    const store = props.store ?? context.store;
    if (!store) {
      (0, import_warning.default)(
        "Composite.Item: Missing composite state. Render inside Composite to enable composite keyboard behavior."
      );
    }
    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 UnforwardedCompositeRow(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 UnforwardedCompositeTypeahead(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 UnforwardedComposite({
      // Composite store props
      activeId,
      defaultActiveId,
      setActiveId,
      focusLoop = false,
      focusWrap = false,
      focusShift = false,
      virtualFocus = false,
      orientation = "both",
      rtl = (0, import_i18n.isRTL)(),
      // Composite component props
      children,
      disabled: disabled2 = false,
      // Rest props
      ...props
    }, ref) {
      const storeProp = props.store;
      const internalStore = useCompositeStore({
        activeId,
        defaultActiveId,
        setActiveId,
        focusLoop,
        focusWrap,
        focusShift,
        virtualFocus,
        orientation,
        rtl
      });
      const store = storeProp ?? internalStore;
      const contextValue = (0, import_element8.useMemo)(
        () => ({
          store
        }),
        [store]
      );
      return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
        Composite,
        {
          disabled: disabled2,
          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_element10 = __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 } = 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, "aria-label": ariaLabel, children: displayText });
  }
  var shortcut_default = Shortcut;

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs
  var import_jsx_runtime41 = __toESM(require_jsx_runtime(), 1);
  var import_react67 = __toESM(require_react(), 1);

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs
  var import_react58 = __toESM(require_react(), 1);
  var LayoutGroupContext = (0, import_react58.createContext)({});

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

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs
  var import_jsx_runtime40 = __toESM(require_jsx_runtime(), 1);
  var React4 = __toESM(require_react(), 1);
  var import_react63 = __toESM(require_react(), 1);

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/context/PresenceContext.mjs
  var import_react60 = __toESM(require_react(), 1);
  var PresenceContext = (0, import_react60.createContext)(null);

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs
  var import_jsx_runtime39 = __toESM(require_jsx_runtime(), 1);
  var React3 = __toESM(require_react(), 1);
  var import_react62 = __toESM(require_react(), 1);

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

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

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

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs
  var import_react64 = __toESM(require_react(), 1);
  function usePresence(subscribe2 = true) {
    const context = (0, import_react64.useContext)(PresenceContext);
    if (context === null)
      return [true, null];
    const { isPresent: isPresent2, onExitComplete, register: register2 } = context;
    const id3 = (0, import_react64.useId)();
    (0, import_react64.useEffect)(() => {
      if (subscribe2)
        register2(id3);
    }, [subscribe2]);
    const safeToRemove = (0, import_react64.useCallback)(() => subscribe2 && onExitComplete && onExitComplete(id3), [id3, onExitComplete, subscribe2]);
    return !isPresent2 && onExitComplete ? [false, safeToRemove] : [true];
  }
  function useIsPresent() {
    return isPresent((0, import_react64.useContext)(PresenceContext));
  }
  function isPresent(context) {
    return context === null ? true : context.isPresent;
  }

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

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs
  var import_react66 = __toESM(require_react(), 1);

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/utils/is-browser.mjs
  var isBrowser = typeof window !== "undefined";

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs
  var useIsomorphicLayoutEffect = isBrowser ? import_react66.useLayoutEffect : import_react66.useEffect;

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

  // node_modules/.store/motion-utils@11.18.1-N6R1XkSNe0bS34zaIkHQcA/node_modules/motion-utils/dist/es/noop.mjs
  var noop2 = /* @__NO_SIDE_EFFECTS__ */ (any) => any;

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

  // node_modules/.store/motion-utils@11.18.1-N6R1XkSNe0bS34zaIkHQcA/node_modules/motion-utils/dist/es/memo.mjs
  // @__NO_SIDE_EFFECTS__
  function memo3(callback) {
    let result;
    return () => {
      if (result === void 0)
        result = callback();
      return result;
    };
  }

  // node_modules/.store/motion-utils@11.18.1-N6R1XkSNe0bS34zaIkHQcA/node_modules/motion-utils/dist/es/progress.mjs
  var progress = /* @__NO_SIDE_EFFECTS__ */ (from, to, value) => {
    const toFromDifference = to - from;
    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;
  };

  // node_modules/.store/motion-utils@11.18.1-N6R1XkSNe0bS34zaIkHQcA/node_modules/motion-utils/dist/es/time-conversion.mjs
  var secondsToMilliseconds = /* @__NO_SIDE_EFFECTS__ */ (seconds) => seconds * 1e3;
  var millisecondsToSeconds = /* @__NO_SIDE_EFFECTS__ */ (milliseconds) => milliseconds / 1e3;

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/utils/GlobalConfig.mjs
  var MotionGlobalConfig = {
    skipAnimations: false,
    useManualTiming: false
  };

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/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;
  }

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/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: update2, 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);
      update2.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 i2 = 0; i2 < stepsOrder.length; i2++) {
        steps[stepsOrder[i2]].cancel(process2);
      }
    };
    return { schedule, cancel, state, steps };
  }

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/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);

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/context/LazyContext.mjs
  var import_react68 = __toESM(require_react(), 1);
  var LazyContext = (0, import_react68.createContext)({ strict: false });

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

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

  // node_modules/.store/framer-motion@11.18.2-c6uTn1GdwNuTiEI_ZcwZaQ/node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs
  var validMotionProps = /* @__PURE__ */ new Set([
    "animate",
    "exit",
    "variants",
    "initial",
    "style",
    "values",
    "variants",
    "transition",
    "transformTemplate",
    "custom",
    "inherit",
    "onBeforeLayoutMeasure",
    "onAnimationStart",
    "onAnimationComplete",
    "onUpdate",
    "onDragStart",
    "onDrag",
    "onDragEnd",
    "onMeasureDragConstraints",
    "onDirectionLock",
    "onDragTransitionEnd",
    "_dragX",
    "_dragY",
    "onHoverStart",
    "onHoverEnd",
    "onViewportEnter",
    "onViewportLeave",
    "globalTapTarget",
    "ignoreStrict",
    "viewport"
  ]);
  function isValidMotionProp(key) {
Showing 512.00 KB of 3.47 MB. Use Edit/Download for full content.

Directory Contents

Dirs: 3 × Files: 130
Name Size Perms Modified Actions
development DIR
- drwxr-xr-x 2026-10-28 14:44:54
Edit Download
script-modules DIR
- drwxr-xr-x 2026-10-28 14:44:54
Edit Download
vendor DIR
- drwxr-xr-x 2026-10-28 14:44:54
Edit Download
a11y.js
5.56 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
a11y.min.js
2.55 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
annotations.js
15.74 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
annotations.min.js
5.84 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
api-fetch.js
20.32 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
api-fetch.min.js
7.68 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
autop.js
9.79 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
autop.min.js
5.57 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
base-styles.js
115 B lrw-r--r-- 2026-10-28 14:44:54
Edit Download
base-styles.min.js
142 B lrw-r--r-- 2026-10-28 14:44:54
Edit Download
blob.js
2.35 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
blob.min.js
1.21 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-directory.js
527.90 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-directory.min.js
222.35 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-editor.js
5.51 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-editor.min.js
2.34 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-library.js
3.86 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-library.min.js
1.72 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-serialization-default-parser.js
6.68 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-serialization-default-parser.min.js
2.54 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-serialization-spec-parser.js
50.59 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
block-serialization-spec-parser.min.js
10.48 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
blocks.js
295.67 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
blocks.min.js
147.18 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
commands.js
148.74 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
commands.min.js
62.35 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
components.js
3.47 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
components.min.js
1.71 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
compose.js
83.89 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
compose.min.js
29.10 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
core-commands.js
26.67 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
core-commands.min.js
11.00 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
core-data.js
709.27 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
core-data.min.js
245.94 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
customize-widgets.js
646.11 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
customize-widgets.min.js
240.20 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
data-controls.js
4.20 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
data-controls.min.js
1.84 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
data.js
87.41 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
data.min.js
26.96 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
date.js
177.00 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
date.min.js
141.37 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
deprecated.js
3.11 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
deprecated.min.js
1.35 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
dom-ready.js
1.53 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
dom-ready.min.js
881 B lrw-r--r-- 2026-10-28 14:44:54
Edit Download
dom.js
36.56 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
dom.min.js
13.68 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
edit-post.js
458.55 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
edit-post.min.js
156.13 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
edit-site.js
3.50 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
edit-site.min.js
1.59 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
edit-widgets.js
713.04 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
edit-widgets.min.js
265.15 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
editor.js
5.27 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
editor.min.js
2.37 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
element.js
28.67 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
element.min.js
12.34 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
escape-html.js
2.36 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
escape-html.min.js
1.13 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
format-library.js
858.37 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
format-library.min.js
397.41 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
hooks.js
12.01 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
hooks.min.js
4.99 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
html-entities.js
1.71 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
html-entities.min.js
950 B lrw-r--r-- 2026-10-28 14:44:54
Edit Download
i18n.js
15.73 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
i18n.min.js
5.66 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
is-shallow-equal.js
2.77 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
is-shallow-equal.min.js
1.17 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
keyboard-shortcuts.js
10.69 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
keyboard-shortcuts.min.js
3.76 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
keycodes.js
9.48 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
keycodes.min.js
3.25 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
list-reusable-blocks.js
24.94 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
list-reusable-blocks.min.js
10.79 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
media-utils.js
2.48 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
media-utils.min.js
1.15 MB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
notices.js
516.75 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
notices.min.js
214.01 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
nux.js
4.32 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
nux.min.js
1.71 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
patterns.js
107.90 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
patterns.min.js
45.50 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
plugins.js
18.22 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
plugins.min.js
7.40 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
preferences-persistence.js
18.14 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
preferences-persistence.min.js
5.73 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
preferences.js
21.45 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
preferences.min.js
7.96 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
primitives.js
5.20 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
primitives.min.js
2.04 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
priority-queue.js
10.23 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
priority-queue.min.js
3.42 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
private-apis.js
4.85 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
private-apis.min.js
2.96 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
react-i18n.js
3.97 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
react-i18n.min.js
1.59 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
redux-routine.js
25.86 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
redux-routine.min.js
9.72 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
reusable-blocks.js
5.21 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
reusable-blocks.min.js
2.15 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
rich-text.js
108.74 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
rich-text.min.js
43.36 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
router.js
36.39 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
router.min.js
14.21 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
server-side-render.js
12.32 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
server-side-render.min.js
4.51 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
shortcode.js
8.08 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
shortcode.min.js
3.35 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
style-engine.js
19.83 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
style-engine.min.js
7.33 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
theme.js
161.16 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
theme.min.js
70.73 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
token-list.js
6.18 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
token-list.min.js
1.68 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
undo-manager.js
5.36 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
undo-manager.min.js
1.77 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
upload-media.js
119.85 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
upload-media.min.js
50.53 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
url.js
20.33 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
url.min.js
8.97 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
viewport.js
7.15 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
viewport.min.js
2.33 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
warning.js
1.58 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
warning.min.js
816 B lrw-r--r-- 2026-10-28 14:44:54
Edit Download
widgets.js
694.87 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
widgets.min.js
315.80 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
wordcount.js
7.00 KB lrw-r--r-- 2026-10-28 14:44:54
Edit Download
wordcount.min.js
2.51 KB lrw-r--r-- 2026-10-28 14:44:54
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