[Summary view] [Print] [Text view]

   1  var __create = Object.create;
   2  var __defProp = Object.defineProperty;
   3  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   4  var __getOwnPropNames = Object.getOwnPropertyNames;
   5  var __getProtoOf = Object.getPrototypeOf;
   6  var __hasOwnProp = Object.prototype.hasOwnProperty;
   7  var __commonJS = (cb, mod) => function __require() {
   8    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   9  };
  10  var __export = (target, all) => {
  11    for (var name in all)
  12      __defProp(target, name, { get: all[name], enumerable: true });
  13  };
  14  var __copyProps = (to, from, except, desc) => {
  15    if (from && typeof from === "object" || typeof from === "function") {
  16      for (let key of __getOwnPropNames(from))
  17        if (!__hasOwnProp.call(to, key) && key !== except)
  18          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  19    }
  20    return to;
  21  };
  22  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  23    // If the importer is in node compatibility mode or this is not an ESM
  24    // file that has been converted to a CommonJS file using a Babel-
  25    // compatible transform (i.e. "__esModule" has not been set), then set
  26    // "default" to the CommonJS "module.exports" for node compatibility.
  27    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  28    mod
  29  ));
  30  
  31  // package-external:@wordpress/element
  32  var require_element = __commonJS({
  33    "package-external:@wordpress/element"(exports, module) {
  34      module.exports = window.wp.element;
  35    }
  36  });
  37  
  38  // package-external:@wordpress/data
  39  var require_data = __commonJS({
  40    "package-external:@wordpress/data"(exports, module) {
  41      module.exports = window.wp.data;
  42    }
  43  });
  44  
  45  // package-external:@wordpress/core-data
  46  var require_core_data = __commonJS({
  47    "package-external:@wordpress/core-data"(exports, module) {
  48      module.exports = window.wp.coreData;
  49    }
  50  });
  51  
  52  // package-external:@wordpress/primitives
  53  var require_primitives = __commonJS({
  54    "package-external:@wordpress/primitives"(exports, module) {
  55      module.exports = window.wp.primitives;
  56    }
  57  });
  58  
  59  // vendor-external:react/jsx-runtime
  60  var require_jsx_runtime = __commonJS({
  61    "vendor-external:react/jsx-runtime"(exports, module) {
  62      module.exports = window.ReactJSXRuntime;
  63    }
  64  });
  65  
  66  // vendor-external:react
  67  var require_react = __commonJS({
  68    "vendor-external:react"(exports, module) {
  69      module.exports = window.React;
  70    }
  71  });
  72  
  73  // vendor-external:react-dom
  74  var require_react_dom = __commonJS({
  75    "vendor-external:react-dom"(exports, module) {
  76      module.exports = window.ReactDOM;
  77    }
  78  });
  79  
  80  // 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
  81  var require_use_sync_external_store_shim_development = __commonJS({
  82    "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) {
  83      "use strict";
  84      (function() {
  85        function is(x, y) {
  86          return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
  87        }
  88        function useSyncExternalStore$2(subscribe, getSnapshot) {
  89          didWarnOld18Alpha || void 0 === React49.startTransition || (didWarnOld18Alpha = true, console.error(
  90            "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."
  91          ));
  92          var value = getSnapshot();
  93          if (!didWarnUncachedGetSnapshot) {
  94            var cachedValue = getSnapshot();
  95            objectIs(value, cachedValue) || (console.error(
  96              "The result of getSnapshot should be cached to avoid an infinite loop"
  97            ), didWarnUncachedGetSnapshot = true);
  98          }
  99          cachedValue = useState13({
 100            inst: { value, getSnapshot }
 101          });
 102          var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
 103          useLayoutEffect3(
 104            function() {
 105              inst.value = value;
 106              inst.getSnapshot = getSnapshot;
 107              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
 108            },
 109            [subscribe, value, getSnapshot]
 110          );
 111          useEffect11(
 112            function() {
 113              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
 114              return subscribe(function() {
 115                checkIfSnapshotChanged(inst) && forceUpdate({ inst });
 116              });
 117            },
 118            [subscribe]
 119          );
 120          useDebugValue2(value);
 121          return value;
 122        }
 123        function checkIfSnapshotChanged(inst) {
 124          var latestGetSnapshot = inst.getSnapshot;
 125          inst = inst.value;
 126          try {
 127            var nextValue = latestGetSnapshot();
 128            return !objectIs(inst, nextValue);
 129          } catch (error) {
 130            return true;
 131          }
 132        }
 133        function useSyncExternalStore$1(subscribe, getSnapshot) {
 134          return getSnapshot();
 135        }
 136        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
 137        var React49 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState13 = React49.useState, useEffect11 = React49.useEffect, useLayoutEffect3 = React49.useLayoutEffect, useDebugValue2 = React49.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
 138        exports.useSyncExternalStore = void 0 !== React49.useSyncExternalStore ? React49.useSyncExternalStore : shim;
 139        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
 140      })();
 141    }
 142  });
 143  
 144  // node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/shim/index.js
 145  var require_shim = __commonJS({
 146    "node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/shim/index.js"(exports, module) {
 147      "use strict";
 148      if (false) {
 149        module.exports = null;
 150      } else {
 151        module.exports = require_use_sync_external_store_shim_development();
 152      }
 153    }
 154  });
 155  
 156  // 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
 157  var require_with_selector_development = __commonJS({
 158    "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) {
 159      "use strict";
 160      (function() {
 161        function is(x, y) {
 162          return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
 163        }
 164        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
 165        var React49 = require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore3 = shim.useSyncExternalStore, useRef19 = React49.useRef, useEffect11 = React49.useEffect, useMemo16 = React49.useMemo, useDebugValue2 = React49.useDebugValue;
 166        exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
 167          var instRef = useRef19(null);
 168          if (null === instRef.current) {
 169            var inst = { hasValue: false, value: null };
 170            instRef.current = inst;
 171          } else inst = instRef.current;
 172          instRef = useMemo16(
 173            function() {
 174              function memoizedSelector(nextSnapshot) {
 175                if (!hasMemo) {
 176                  hasMemo = true;
 177                  memoizedSnapshot = nextSnapshot;
 178                  nextSnapshot = selector(nextSnapshot);
 179                  if (void 0 !== isEqual && inst.hasValue) {
 180                    var currentSelection = inst.value;
 181                    if (isEqual(currentSelection, nextSnapshot))
 182                      return memoizedSelection = currentSelection;
 183                  }
 184                  return memoizedSelection = nextSnapshot;
 185                }
 186                currentSelection = memoizedSelection;
 187                if (objectIs(memoizedSnapshot, nextSnapshot))
 188                  return currentSelection;
 189                var nextSelection = selector(nextSnapshot);
 190                if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
 191                  return memoizedSnapshot = nextSnapshot, currentSelection;
 192                memoizedSnapshot = nextSnapshot;
 193                return memoizedSelection = nextSelection;
 194              }
 195              var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
 196              return [
 197                function() {
 198                  return memoizedSelector(getSnapshot());
 199                },
 200                null === maybeGetServerSnapshot ? void 0 : function() {
 201                  return memoizedSelector(maybeGetServerSnapshot());
 202                }
 203              ];
 204            },
 205            [getSnapshot, getServerSnapshot, selector, isEqual]
 206          );
 207          var value = useSyncExternalStore3(subscribe, instRef[0], instRef[1]);
 208          useEffect11(
 209            function() {
 210              inst.hasValue = true;
 211              inst.value = value;
 212            },
 213            [value]
 214          );
 215          useDebugValue2(value);
 216          return value;
 217        };
 218        "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
 219      })();
 220    }
 221  });
 222  
 223  // node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/shim/with-selector.js
 224  var require_with_selector = __commonJS({
 225    "node_modules/.store/use-sync-external-store@1.7.0-jHNF5n8408rkWhZ5NHKclA/node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) {
 226      "use strict";
 227      if (false) {
 228        module.exports = null;
 229      } else {
 230        module.exports = require_with_selector_development();
 231      }
 232    }
 233  });
 234  
 235  // package-external:@wordpress/i18n
 236  var require_i18n = __commonJS({
 237    "package-external:@wordpress/i18n"(exports, module) {
 238      module.exports = window.wp.i18n;
 239    }
 240  });
 241  
 242  // package-external:@wordpress/theme
 243  var require_theme = __commonJS({
 244    "package-external:@wordpress/theme"(exports, module) {
 245      module.exports = window.wp.theme;
 246    }
 247  });
 248  
 249  // package-external:@wordpress/private-apis
 250  var require_private_apis = __commonJS({
 251    "package-external:@wordpress/private-apis"(exports, module) {
 252      module.exports = window.wp.privateApis;
 253    }
 254  });
 255  
 256  // package-external:@wordpress/html-entities
 257  var require_html_entities = __commonJS({
 258    "package-external:@wordpress/html-entities"(exports, module) {
 259      module.exports = window.wp.htmlEntities;
 260    }
 261  });
 262  
 263  // node_modules/.store/clsx@2.1.1-XOLP1vUL9vEGfpiXm37fAw/node_modules/clsx/dist/clsx.mjs
 264  function r(e) {
 265    var t, f, n = "";
 266    if ("string" == typeof e || "number" == typeof e) n += e;
 267    else if ("object" == typeof e) if (Array.isArray(e)) {
 268      var o = e.length;
 269      for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
 270    } else for (f in e) e[f] && (n && (n += " "), n += f);
 271    return n;
 272  }
 273  function clsx() {
 274    for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
 275    return n;
 276  }
 277  var clsx_default = clsx;
 278  
 279  // packages/core-fields/build-module/wp_template/author/view.mjs
 280  var import_element19 = __toESM(require_element(), 1);
 281  var import_data = __toESM(require_data(), 1);
 282  var import_core_data = __toESM(require_core_data(), 1);
 283  
 284  // packages/icons/build-module/icon/index.mjs
 285  var import_element = __toESM(require_element(), 1);
 286  var icon_default = (0, import_element.forwardRef)(
 287    ({ icon, size: size4 = 24, style, ...props }, ref) => {
 288      const intrinsicStyle = icon.props.style;
 289      const mergedStyle = intrinsicStyle || style ? { ...intrinsicStyle, ...style } : void 0;
 290      return (0, import_element.cloneElement)(icon, {
 291        width: size4,
 292        height: size4,
 293        ...props,
 294        // Merge styles so the icon's intrinsic style (e.g. `fill: none` on
 295        // stroke-based icons) is preserved unless the consumer overrides
 296        // the same property explicitly.
 297        ...mergedStyle ? { style: mergedStyle } : {},
 298        ref
 299      });
 300    }
 301  );
 302  
 303  // packages/icons/build-module/library/comment-author-avatar.mjs
 304  var import_primitives = __toESM(require_primitives(), 1);
 305  var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
 306  var comment_author_avatar_default = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_primitives.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: [
 307    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_primitives.Path, { d: "M8 18.0476V16C8 14.8954 8.89543 14 10 14H14C15.1046 14 16 14.8954 16 16V18.0476" }),
 308    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_primitives.Path, { d: "M12 4.75C7.99594 4.75 4.75 7.99593 4.75 12C4.75 16.0041 7.99593 19.25 12 19.25C16.0041 19.25 19.25 16.0041 19.25 12C19.25 7.99594 16.0041 4.75 12 4.75Z", strokeLinejoin: "round" }),
 309    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_primitives.Path, { d: "M13.75 10C13.75 10.9665 12.9665 11.75 12 11.75C11.0335 11.75 10.25 10.9665 10.25 10C10.25 9.0335 11.0335 8.25 12 8.25C12.9665 8.25 13.75 9.0335 13.75 10Z" })
 310  ] });
 311  
 312  // packages/icons/build-module/library/globe.mjs
 313  var import_primitives2 = __toESM(require_primitives(), 1);
 314  var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
 315  var globe_default = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_primitives2.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_primitives2.Path, { d: "M12 4.75C8.87453 4.75 6.21099 6.72773 5.19257 9.5M18.8074 14.5C19.0937 13.7207 19.25 12.8786 19.25 12C19.25 11.1214 19.0937 10.2793 18.8074 9.5C17.789 6.72773 15.1255 4.75 12 4.75M12 4.75C11 5.5 9 8.63218 9 12C9 15.3678 11 18.5 12 19.25M12 4.75C13 5.5 15 8.63218 15 12C15 15.3678 13 18.5 12 19.25M5.19257 9.5C4.90628 10.2793 4.75 11.1214 4.75 12C4.75 12.8786 4.90629 13.7207 5.19257 14.5C6.21099 17.2723 8.87453 19.25 12 19.25M12 19.25C15.1255 19.25 17.789 17.2723 18.8074 14.5M5.19257 9.5L18.8074 9.5M5.19257 14.5L18.8074 14.5", strokeLinejoin: "round" }) });
 316  
 317  // packages/icons/build-module/library/layout.mjs
 318  var import_primitives3 = __toESM(require_primitives(), 1);
 319  var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
 320  var layout_default = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_primitives3.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_primitives3.Path, { d: "M9.75 19.25H18C18.6904 19.25 19.25 18.6904 19.25 18V9.75M9.75 19.25H6C5.30964 19.25 4.75 18.6904 4.75 18V9.75M9.75 19.25V9.75M19.25 9.75V6C19.25 5.30964 18.6904 4.75 18 4.75H6C5.30964 4.75 4.75 5.30964 4.75 6V9.75M19.25 9.75H9.75M9.75 9.75H4.75" }) });
 321  
 322  // packages/icons/build-module/library/lock-small.mjs
 323  var import_primitives4 = __toESM(require_primitives(), 1);
 324  var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
 325  var lock_small_default = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_primitives4.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_primitives4.Path, { fillRule: "evenodd", clipRule: "evenodd", d: "M15 11h-.2V9c0-1.5-1.2-2.8-2.8-2.8S9.2 7.5 9.2 9v2H9c-.6 0-1 .4-1 1v4c0 .6.4 1 1 1h6c.6 0 1-.4 1-1v-4c0-.6-.4-1-1-1zm-1.8 0h-2.5V9c0-.7.6-1.2 1.2-1.2s1.2.6 1.2 1.2v2z" }) });
 326  
 327  // packages/icons/build-module/library/plugins.mjs
 328  var import_primitives5 = __toESM(require_primitives(), 1);
 329  var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
 330  var plugins_default = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_primitives5.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_primitives5.Path, { d: "M15.3995 11.5711L12.2175 8.38909L10.273 6.44454L7.67678 9.04074C7.3017 9.41581 7.09099 9.92452 7.09099 10.455L7.09099 13.455C7.09099 13.7202 6.98563 13.9745 6.7981 14.1621L5.14645 15.8137C4.95118 16.009 4.95118 16.3256 5.14645 16.5208L7.26777 18.6421C7.46303 18.8374 7.77961 18.8374 7.97487 18.6421L9.62652 16.9905C9.81406 16.8029 10.0684 16.6976 10.3336 16.6976H13.3336C13.8641 16.6976 14.3728 16.4869 14.7478 16.1118L17.344 13.5156L15.3995 11.5711ZM12.2175 8.38909L16.1066 4.5M15.3995 11.5711L19.2886 7.68198" }) });
 331  
 332  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useRenderElement.mjs
 333  var React4 = __toESM(require_react(), 1);
 334  
 335  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useRefWithInit.mjs
 336  var React = __toESM(require_react(), 1);
 337  var UNINITIALIZED = {};
 338  function useRefWithInit(init, initArg) {
 339    const ref = React.useRef(UNINITIALIZED);
 340    if (ref.current === UNINITIALIZED) {
 341      ref.current = init(initArg);
 342    }
 343    return ref;
 344  }
 345  
 346  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useMergedRefs.mjs
 347  function useMergedRefs(a, b, c, d) {
 348    const forkRef = useRefWithInit(createForkRef).current;
 349    if (didChange(forkRef, a, b, c, d)) {
 350      update(forkRef, [a, b, c, d]);
 351    }
 352    return forkRef.callback;
 353  }
 354  function useMergedRefsN(refs) {
 355    const forkRef = useRefWithInit(createForkRef).current;
 356    if (didChangeN(forkRef, refs)) {
 357      update(forkRef, refs);
 358    }
 359    return forkRef.callback;
 360  }
 361  function createForkRef() {
 362    return {
 363      callback: null,
 364      cleanup: null,
 365      refs: []
 366    };
 367  }
 368  function didChange(forkRef, a, b, c, d) {
 369    return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
 370  }
 371  function didChangeN(forkRef, newRefs) {
 372    return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index2) => ref !== newRefs[index2]);
 373  }
 374  function update(forkRef, refs) {
 375    forkRef.refs = refs;
 376    if (refs.every((ref) => ref == null)) {
 377      forkRef.callback = null;
 378      return;
 379    }
 380    forkRef.callback = (instance) => {
 381      if (forkRef.cleanup) {
 382        forkRef.cleanup();
 383        forkRef.cleanup = null;
 384      }
 385      if (instance != null) {
 386        const cleanupCallbacks = Array(refs.length).fill(null);
 387        for (let i = 0; i < refs.length; i += 1) {
 388          const ref = refs[i];
 389          if (ref == null) {
 390            continue;
 391          }
 392          switch (typeof ref) {
 393            case "function": {
 394              const refCleanup = ref(instance);
 395              if (typeof refCleanup === "function") {
 396                cleanupCallbacks[i] = refCleanup;
 397              }
 398              break;
 399            }
 400            case "object": {
 401              ref.current = instance;
 402              break;
 403            }
 404            default:
 405          }
 406        }
 407        forkRef.cleanup = () => {
 408          for (let i = 0; i < refs.length; i += 1) {
 409            const ref = refs[i];
 410            if (ref == null) {
 411              continue;
 412            }
 413            switch (typeof ref) {
 414              case "function": {
 415                const cleanupCallback = cleanupCallbacks[i];
 416                if (typeof cleanupCallback === "function") {
 417                  cleanupCallback();
 418                } else {
 419                  void ref(null);
 420                }
 421                break;
 422              }
 423              case "object": {
 424                ref.current = null;
 425                break;
 426              }
 427              default:
 428            }
 429          }
 430        };
 431      }
 432    };
 433  }
 434  
 435  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/getReactElementRef.mjs
 436  var React3 = __toESM(require_react(), 1);
 437  
 438  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/reactVersion.mjs
 439  var React2 = __toESM(require_react(), 1);
 440  var majorVersion = parseInt(React2.version, 10);
 441  function isReactVersionAtLeast(reactVersionToCheck) {
 442    return majorVersion >= reactVersionToCheck;
 443  }
 444  
 445  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/getReactElementRef.mjs
 446  function getReactElementRef(element) {
 447    if (!/* @__PURE__ */ React3.isValidElement(element)) {
 448      return null;
 449    }
 450    const reactElement = element;
 451    const propsWithRef = reactElement.props;
 452    return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
 453  }
 454  
 455  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/mergeObjects.mjs
 456  function mergeObjects(a, b) {
 457    if (a && !b) {
 458      return a;
 459    }
 460    if (!a && b) {
 461      return b;
 462    }
 463    if (a || b) {
 464      return {
 465        ...a,
 466        ...b
 467      };
 468    }
 469    return void 0;
 470  }
 471  
 472  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/createLogOnce.mjs
 473  var loggedMessages;
 474  if (true) {
 475    loggedMessages = /* @__PURE__ */ new Set();
 476  }
 477  function createLogOnce(severity, prefix) {
 478    return function logOnce(...messages) {
 479      if (true) {
 480        const message = messages.join(" ");
 481        const output = prefix ? `$prefix}: $message}` : message;
 482        const key = `$severity}:$output}`;
 483        if (!loggedMessages.has(key)) {
 484          loggedMessages.add(key);
 485          if (severity === "warn") {
 486            console.warn(output);
 487          } else {
 488            console.error(output);
 489          }
 490        }
 491      }
 492    };
 493  }
 494  
 495  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/warn.mjs
 496  var warn = createLogOnce("warn", "Base UI");
 497  
 498  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/empty.mjs
 499  function NOOP() {
 500  }
 501  var EMPTY_ARRAY = Object.freeze([]);
 502  var EMPTY_OBJECT = Object.freeze({});
 503  
 504  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/getStateAttributesProps.mjs
 505  function getStateAttributesProps(state, customMapping) {
 506    const props = {};
 507    for (const key in state) {
 508      const value = state[key];
 509      if (customMapping?.hasOwnProperty(key)) {
 510        const customProps = customMapping[key](value);
 511        if (customProps != null) {
 512          Object.assign(props, customProps);
 513        }
 514        continue;
 515      }
 516      if (value === true) {
 517        props[`data-$key.toLowerCase()}`] = "";
 518      } else if (value) {
 519        props[`data-$key.toLowerCase()}`] = value.toString();
 520      }
 521    }
 522    return props;
 523  }
 524  
 525  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/resolveClassName.mjs
 526  function resolveClassName(className, state) {
 527    return typeof className === "function" ? className(state) : className;
 528  }
 529  
 530  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/resolveStyle.mjs
 531  function resolveStyle(style, state) {
 532    return typeof style === "function" ? style(state) : style;
 533  }
 534  
 535  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/merge-props/mergeProps.mjs
 536  var EMPTY_PROPS = {};
 537  function mergeProps(a, b, c, d, e) {
 538    if (!c && !d && !e && !a) {
 539      return createInitialMergedProps(b);
 540    }
 541    let merged = createInitialMergedProps(a);
 542    if (b) {
 543      merged = mergeInto(merged, b);
 544    }
 545    if (c) {
 546      merged = mergeInto(merged, c);
 547    }
 548    if (d) {
 549      merged = mergeInto(merged, d);
 550    }
 551    if (e) {
 552      merged = mergeInto(merged, e);
 553    }
 554    return merged;
 555  }
 556  function mergePropsN(props) {
 557    if (props.length === 0) {
 558      return EMPTY_PROPS;
 559    }
 560    if (props.length === 1) {
 561      return createInitialMergedProps(props[0]);
 562    }
 563    let merged = createInitialMergedProps(props[0]);
 564    for (let i = 1; i < props.length; i += 1) {
 565      merged = mergeInto(merged, props[i]);
 566    }
 567    return merged;
 568  }
 569  function createInitialMergedProps(inputProps) {
 570    if (isPropsGetter(inputProps)) {
 571      return {
 572        ...inputProps(EMPTY_PROPS)
 573      };
 574    }
 575    return copyInitialProps(inputProps);
 576  }
 577  function mergeInto(merged, inputProps) {
 578    if (isPropsGetter(inputProps)) {
 579      return inputProps(merged);
 580    }
 581    return mutablyMergeInto(merged, inputProps);
 582  }
 583  function copyInitialProps(inputProps) {
 584    const copiedProps = {
 585      ...inputProps
 586    };
 587    for (const propName in copiedProps) {
 588      const propValue = copiedProps[propName];
 589      if (isEventHandler(propName, propValue)) {
 590        copiedProps[propName] = wrapEventHandler(propValue);
 591      }
 592    }
 593    return copiedProps;
 594  }
 595  function mutablyMergeInto(mergedProps, externalProps) {
 596    if (!externalProps) {
 597      return mergedProps;
 598    }
 599    for (const propName in externalProps) {
 600      const externalPropValue = externalProps[propName];
 601      switch (propName) {
 602        case "style": {
 603          mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
 604          break;
 605        }
 606        case "className": {
 607          mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
 608          break;
 609        }
 610        default: {
 611          if (isEventHandler(propName, externalPropValue)) {
 612            mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
 613          } else {
 614            mergedProps[propName] = externalPropValue;
 615          }
 616        }
 617      }
 618    }
 619    return mergedProps;
 620  }
 621  function isEventHandler(key, value) {
 622    const code0 = key.charCodeAt(0);
 623    const code1 = key.charCodeAt(1);
 624    const code2 = key.charCodeAt(2);
 625    return code0 === 111 && code1 === 110 && code2 >= 65 && code2 <= 90 && (typeof value === "function" || typeof value === "undefined");
 626  }
 627  function isPropsGetter(inputProps) {
 628    return typeof inputProps === "function";
 629  }
 630  function mergeEventHandlers(ourHandler, theirHandler) {
 631    if (!theirHandler) {
 632      return ourHandler;
 633    }
 634    if (!ourHandler) {
 635      return wrapEventHandler(theirHandler);
 636    }
 637    return (...args) => {
 638      const event = args[0];
 639      if (isSyntheticEvent(event)) {
 640        const baseUIEvent = event;
 641        makeEventPreventable(baseUIEvent);
 642        const result2 = theirHandler(...args);
 643        if (!baseUIEvent.baseUIHandlerPrevented) {
 644          ourHandler?.(...args);
 645        }
 646        return result2;
 647      }
 648      const result = theirHandler(...args);
 649      ourHandler?.(...args);
 650      return result;
 651    };
 652  }
 653  function wrapEventHandler(handler) {
 654    if (!handler) {
 655      return handler;
 656    }
 657    return (...args) => {
 658      const event = args[0];
 659      if (isSyntheticEvent(event)) {
 660        makeEventPreventable(event);
 661      }
 662      return handler(...args);
 663    };
 664  }
 665  function makeEventPreventable(event) {
 666    event.preventBaseUIHandler = () => {
 667      event.baseUIHandlerPrevented = true;
 668    };
 669    return event;
 670  }
 671  function mergeClassNames(ourClassName, theirClassName) {
 672    if (theirClassName) {
 673      if (ourClassName) {
 674        return theirClassName + " " + ourClassName;
 675      }
 676      return theirClassName;
 677    }
 678    return ourClassName;
 679  }
 680  function isSyntheticEvent(event) {
 681    return event != null && typeof event === "object" && "nativeEvent" in event;
 682  }
 683  
 684  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useRenderElement.mjs
 685  var import_react = __toESM(require_react(), 1);
 686  function useRenderElement(element, componentProps, params = {}) {
 687    let renderProp = componentProps.render;
 688    if (params.enabled !== false) {
 689      renderProp = unwrapLazyRenderProp(renderProp);
 690    }
 691    const outProps = useRenderElementProps(componentProps, params, renderProp);
 692    if (params.enabled === false) {
 693      return null;
 694    }
 695    const state = params.state ?? EMPTY_OBJECT;
 696    return evaluateRenderProp(element, renderProp, outProps, state);
 697  }
 698  function useRenderElementProps(componentProps, params, renderProp) {
 699    const {
 700      className: classNameProp,
 701      style: styleProp
 702    } = componentProps;
 703    const {
 704      state = EMPTY_OBJECT,
 705      ref,
 706      props,
 707      stateAttributesMapping,
 708      enabled = true
 709    } = params;
 710    const className = enabled ? resolveClassName(classNameProp, state) : void 0;
 711    const style = enabled ? resolveStyle(styleProp, state) : void 0;
 712    const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
 713    const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0;
 714    const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
 715    if (typeof document !== "undefined") {
 716      if (!enabled) {
 717        void useMergedRefs(null, null);
 718      } else if (Array.isArray(ref)) {
 719        outProps.ref = useMergedRefsN([outProps.ref, getReactElementRef(renderProp), ...ref]);
 720      } else {
 721        outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
 722      }
 723    }
 724    if (!enabled) {
 725      return EMPTY_OBJECT;
 726    }
 727    if (className !== void 0) {
 728      outProps.className = mergeClassNames(outProps.className, className);
 729    }
 730    if (style !== void 0) {
 731      outProps.style = mergeObjects(outProps.style, style);
 732    }
 733    return outProps;
 734  }
 735  function resolveRenderFunctionProps(props) {
 736    if (Array.isArray(props)) {
 737      return mergePropsN(props);
 738    }
 739    return mergeProps(void 0, props);
 740  }
 741  var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
 742  var COMPONENT_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9$]*$/;
 743  var LOWERCASE_CHARACTER_PATTERN = /[a-z]/;
 744  function unwrapLazyRenderProp(render) {
 745    if (render?.$$typeof !== REACT_LAZY_TYPE) {
 746      return render;
 747    }
 748    const unwrapped = React4.Children.toArray(render)[0];
 749    return /* @__PURE__ */ React4.isValidElement(unwrapped) ? unwrapped : render;
 750  }
 751  function evaluateRenderProp(element, render, props, state) {
 752    if (render) {
 753      if (typeof render === "function") {
 754        if (true) {
 755          warnIfRenderPropLooksLikeComponent(render);
 756        }
 757        return render(props, state);
 758      }
 759      const mergedProps = mergeProps(props, render.props);
 760      mergedProps.ref = props.ref;
 761      if (true) {
 762        if (!/* @__PURE__ */ React4.isValidElement(render)) {
 763          throw new Error(["Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.", "A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.", "https://base-ui.com/r/invalid-render-prop"].join("\n"));
 764        }
 765      }
 766      return /* @__PURE__ */ React4.cloneElement(render, mergedProps);
 767    }
 768    return renderTag(element, props);
 769  }
 770  function warnIfRenderPropLooksLikeComponent(renderFn) {
 771    const functionName = renderFn.name;
 772    if (functionName.length === 0) {
 773      return;
 774    }
 775    if (!COMPONENT_IDENTIFIER_PATTERN.test(functionName)) {
 776      return;
 777    }
 778    if (!LOWERCASE_CHARACTER_PATTERN.test(functionName)) {
 779      return;
 780    }
 781    warn(`The \`render\` prop received a function named \`$functionName}\` that starts with an uppercase letter.`, "This usually means a React component was passed directly as `render={Component}`.", "Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.", "If this is an intentional render callback, rename it to start with a lowercase letter.", "Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.", "https://base-ui.com/r/invalid-render-prop");
 782  }
 783  function renderTag(Tag, props) {
 784    if (Tag === "button") {
 785      return /* @__PURE__ */ (0, import_react.createElement)("button", {
 786        type: "button",
 787        ...props,
 788        key: props.key
 789      });
 790    }
 791    if (Tag === "img") {
 792      return /* @__PURE__ */ (0, import_react.createElement)("img", {
 793        alt: "",
 794        ...props,
 795        key: props.key
 796      });
 797    }
 798    return /* @__PURE__ */ React4.createElement(Tag, props);
 799  }
 800  
 801  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/safeReact.mjs
 802  var React5 = __toESM(require_react(), 1);
 803  var SafeReact = {
 804    ...React5
 805  };
 806  
 807  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useStableCallback.mjs
 808  var useInsertionEffect = SafeReact.useInsertionEffect;
 809  var useSafeInsertionEffect = (
 810    // React 17 doesn't have useInsertionEffect.
 811    useInsertionEffect && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
 812    useInsertionEffect !== SafeReact.useLayoutEffect ? useInsertionEffect : (fn) => fn()
 813  );
 814  function useStableCallback(callback) {
 815    const stable = useRefWithInit(createStableCallback).current;
 816    stable.next = callback;
 817    useSafeInsertionEffect(stable.effect);
 818    return stable.trampoline;
 819  }
 820  function createStableCallback() {
 821    const stable = {
 822      next: void 0,
 823      callback: assertNotCalled,
 824      trampoline: (...args) => stable.callback?.(...args),
 825      effect: () => {
 826        stable.callback = stable.next;
 827      }
 828    };
 829    return stable;
 830  }
 831  function assertNotCalled() {
 832    if (true) {
 833      throw (
 834        /* minify-error-disabled */
 835        new Error("Base UI: Cannot call an event handler while rendering.")
 836      );
 837    }
 838  }
 839  
 840  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useIsoLayoutEffect.mjs
 841  var React6 = __toESM(require_react(), 1);
 842  var noop = () => {
 843  };
 844  var useIsoLayoutEffect = typeof document !== "undefined" ? React6.useLayoutEffect : noop;
 845  
 846  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
 847  var React8 = __toESM(require_react(), 1);
 848  
 849  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
 850  var ReactDOM = __toESM(require_react_dom(), 1);
 851  
 852  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useOnMount.mjs
 853  var React7 = __toESM(require_react(), 1);
 854  function useOnMount(fn) {
 855    React7.useEffect(fn, EMPTY_ARRAY);
 856  }
 857  
 858  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useAnimationFrame.mjs
 859  var EMPTY = null;
 860  var LAST_RAF = globalThis.requestAnimationFrame;
 861  var Scheduler = class {
 862    /* This implementation uses an array as a backing data-structure for frame callbacks.
 863     * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
 864     * never calls the native `cancelAnimationFrame` if there are no frames left. This can
 865     * be much more efficient if there is a call pattern that alterns as
 866     * "request-cancel-request-cancel-…".
 867     * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
 868     * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
 869    callbacks = [];
 870    callbacksCount = 0;
 871    nextId = 1;
 872    startId = 1;
 873    isScheduled = false;
 874    tick = (timestamp) => {
 875      this.isScheduled = false;
 876      const currentCallbacks = this.callbacks;
 877      const currentCallbacksCount = this.callbacksCount;
 878      this.callbacks = [];
 879      this.callbacksCount = 0;
 880      this.startId = this.nextId;
 881      if (currentCallbacksCount > 0) {
 882        for (let i = 0; i < currentCallbacks.length; i += 1) {
 883          currentCallbacks[i]?.(timestamp);
 884        }
 885      }
 886    };
 887    request(fn) {
 888      const id = this.nextId;
 889      this.nextId += 1;
 890      this.callbacks.push(fn);
 891      this.callbacksCount += 1;
 892      const didRAFChange = LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);
 893      if (!this.isScheduled || didRAFChange) {
 894        requestAnimationFrame(this.tick);
 895        this.isScheduled = true;
 896      }
 897      return id;
 898    }
 899    cancel(id) {
 900      const index2 = id - this.startId;
 901      if (index2 < 0 || index2 >= this.callbacks.length) {
 902        return;
 903      }
 904      if (this.callbacks[index2] === null) {
 905        return;
 906      }
 907      this.callbacks[index2] = null;
 908      this.callbacksCount -= 1;
 909    }
 910  };
 911  var scheduler = new Scheduler();
 912  var AnimationFrame = class _AnimationFrame {
 913    static create() {
 914      return new _AnimationFrame();
 915    }
 916    static request(fn) {
 917      return scheduler.request(fn);
 918    }
 919    static cancel(id) {
 920      return scheduler.cancel(id);
 921    }
 922    currentId = EMPTY;
 923    /**
 924     * Executes `fn` after `delay`, clearing any previously scheduled call.
 925     */
 926    request(fn) {
 927      this.cancel();
 928      this.currentId = scheduler.request(() => {
 929        this.currentId = EMPTY;
 930        fn();
 931      });
 932    }
 933    cancel = () => {
 934      if (this.currentId !== EMPTY) {
 935        scheduler.cancel(this.currentId);
 936        this.currentId = EMPTY;
 937      }
 938    };
 939    disposeEffect = () => {
 940      return this.cancel;
 941    };
 942  };
 943  function useAnimationFrame() {
 944    const timeout = useRefWithInit(AnimationFrame.create).current;
 945    useOnMount(timeout.disposeEffect);
 946    return timeout;
 947  }
 948  
 949  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/resolveRef.mjs
 950  function resolveRef(maybeRef) {
 951    if (maybeRef == null) {
 952      return maybeRef;
 953    }
 954    return "current" in maybeRef ? maybeRef.current : maybeRef;
 955  }
 956  
 957  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/getFiniteAnimations.mjs
 958  function getFiniteAnimations(element, options) {
 959    return element.getAnimations(options).filter((animation) => {
 960      const timing = animation.effect?.getTiming();
 961      return timing?.duration !== Infinity && timing?.iterations !== Infinity;
 962    });
 963  }
 964  
 965  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/TransitionStatusDataAttributes.mjs
 966  var startingStyle = "data-starting-style";
 967  var endingStyle = "data-ending-style";
 968  
 969  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
 970  var pendingCallbacks = null;
 971  function flushBeforePaint(fn) {
 972    if (!pendingCallbacks) {
 973      const callbacks = [];
 974      pendingCallbacks = callbacks;
 975      queueMicrotask(() => {
 976        pendingCallbacks = null;
 977        ReactDOM.flushSync(() => {
 978          for (const callback of callbacks) {
 979            callback();
 980          }
 981        });
 982      });
 983    }
 984    pendingCallbacks.push(fn);
 985  }
 986  function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false, batch = false) {
 987    const frame = useAnimationFrame();
 988    return useStableCallback((fnToExecute, signal = null) => {
 989      frame.cancel();
 990      const element = resolveRef(elementOrRef);
 991      if (element == null) {
 992        return;
 993      }
 994      const resolvedElement = element;
 995      const done = () => {
 996        if (!batch) {
 997          ReactDOM.flushSync(fnToExecute);
 998          return;
 999        }
1000        flushBeforePaint(() => {
1001          if (!signal?.aborted) {
1002            fnToExecute();
1003          }
1004        });
1005      };
1006      if (typeof resolvedElement.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
1007        fnToExecute();
1008        return;
1009      }
1010      function exec() {
1011        Promise.all(getFiniteAnimations(resolvedElement).map((animation) => animation.finished.then(NOOP))).then(() => {
1012          if (!signal?.aborted) {
1013            done();
1014          }
1015        }, () => {
1016          if (signal?.aborted) {
1017            return;
1018          }
1019          const currentAnimations = getFiniteAnimations(resolvedElement);
1020          if (currentAnimations.some((animation) => animation.pending || animation.playState !== "finished")) {
1021            exec();
1022            return;
1023          }
1024          done();
1025        });
1026      }
1027      if (waitForStartingStyleRemoved) {
1028        const startingStyleAttribute = startingStyle;
1029        if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
1030          frame.request(exec);
1031          return;
1032        }
1033        const attributeObserver = new MutationObserver(() => {
1034          if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
1035            attributeObserver.disconnect();
1036            exec();
1037          }
1038        });
1039        attributeObserver.observe(resolvedElement, {
1040          attributes: true,
1041          attributeFilter: [startingStyleAttribute]
1042        });
1043        signal?.addEventListener("abort", () => attributeObserver.disconnect(), {
1044          once: true
1045        });
1046        return;
1047      }
1048      frame.request(exec);
1049    });
1050  }
1051  
1052  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
1053  function useOpenChangeComplete(parameters) {
1054    const {
1055      enabled = true,
1056      open: open2,
1057      ref,
1058      batch = false,
1059      onComplete: onCompleteParam
1060    } = parameters;
1061    const onComplete = useStableCallback(onCompleteParam);
1062    const runOnceAnimationsFinish = useAnimationsFinished(ref, open2, batch);
1063    React8.useEffect(() => {
1064      if (!enabled) {
1065        return void 0;
1066      }
1067      const abortController = new AbortController();
1068      runOnceAnimationsFinish(onComplete, abortController.signal);
1069      return () => {
1070        abortController.abort();
1071      };
1072    }, [enabled, open2, onComplete, runOnceAnimationsFinish]);
1073  }
1074  
1075  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/stateAttributesMapping.mjs
1076  var STARTING_HOOK = {
1077    [startingStyle]: ""
1078  };
1079  var ENDING_HOOK = {
1080    [endingStyle]: ""
1081  };
1082  var transitionStatusMapping = {
1083    transitionStatus(value) {
1084      if (value === "starting") {
1085        return STARTING_HOOK;
1086      }
1087      if (value === "ending") {
1088        return ENDING_HOOK;
1089      }
1090      return null;
1091    }
1092  };
1093  
1094  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useTransitionStatus.mjs
1095  var React9 = __toESM(require_react(), 1);
1096  function useTransitionStatus(open2, enableIdleState = false, deferEndingState = false, animateInitialOpen = false) {
1097    const [transitionStatus, setTransitionStatus] = React9.useState(open2 && enableIdleState ? "idle" : void 0);
1098    const [mounted, setMounted] = React9.useState(open2 && !animateInitialOpen);
1099    if (open2 && !mounted) {
1100      setMounted(true);
1101      setTransitionStatus("starting");
1102    }
1103    if (!open2 && mounted && transitionStatus !== "ending" && !deferEndingState) {
1104      setTransitionStatus("ending");
1105    }
1106    if (!open2 && !mounted && transitionStatus === "ending") {
1107      setTransitionStatus(void 0);
1108    }
1109    useIsoLayoutEffect(() => {
1110      if (!open2 && mounted && transitionStatus !== "ending" && deferEndingState) {
1111        const frame = AnimationFrame.request(() => {
1112          setTransitionStatus("ending");
1113        });
1114        return () => {
1115          AnimationFrame.cancel(frame);
1116        };
1117      }
1118      return void 0;
1119    }, [open2, mounted, transitionStatus, deferEndingState]);
1120    useIsoLayoutEffect(() => {
1121      if (!open2 || enableIdleState || transitionStatus === void 0) {
1122        return void 0;
1123      }
1124      const frame = AnimationFrame.request(() => {
1125        setTransitionStatus(void 0);
1126      });
1127      return () => {
1128        AnimationFrame.cancel(frame);
1129      };
1130    }, [enableIdleState, open2, transitionStatus]);
1131    useIsoLayoutEffect(() => {
1132      if (!open2 || !enableIdleState) {
1133        return void 0;
1134      }
1135      if (open2 && mounted && transitionStatus !== "idle") {
1136        setTransitionStatus("starting");
1137      }
1138      const frame = AnimationFrame.request(() => {
1139        setTransitionStatus("idle");
1140      });
1141      return () => {
1142        AnimationFrame.cancel(frame);
1143      };
1144    }, [enableIdleState, open2, mounted, transitionStatus]);
1145    return {
1146      mounted,
1147      setMounted,
1148      transitionStatus
1149    };
1150  }
1151  
1152  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useTimeout.mjs
1153  var EMPTY2 = 0;
1154  var Timeout = class _Timeout {
1155    static create() {
1156      return new _Timeout();
1157    }
1158    currentId = EMPTY2;
1159    /**
1160     * Executes `fn` after `delay`, clearing any previously scheduled call.
1161     */
1162    start(delay, fn) {
1163      this.clear();
1164      this.currentId = setTimeout(() => {
1165        this.currentId = EMPTY2;
1166        fn();
1167      }, delay);
1168    }
1169    isStarted() {
1170      return this.currentId !== EMPTY2;
1171    }
1172    clear = () => {
1173      if (this.currentId !== EMPTY2) {
1174        clearTimeout(this.currentId);
1175        this.currentId = EMPTY2;
1176      }
1177    };
1178    disposeEffect = () => {
1179      return this.clear;
1180    };
1181  };
1182  function useTimeout() {
1183    const timeout = useRefWithInit(Timeout.create).current;
1184    useOnMount(timeout.disposeEffect);
1185    return timeout;
1186  }
1187  
1188  // packages/ui/build-module/icon/icon.mjs
1189  var import_element2 = __toESM(require_element(), 1);
1190  var import_primitives6 = __toESM(require_primitives(), 1);
1191  var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
1192  var Icon = (0, import_element2.forwardRef)(
1193    function UnforwardedIcon({ icon, size: size4 = 24, style, ...restProps }, ref) {
1194      const mergedStyle = icon.props.style || style ? { ...icon.props.style, ...style } : void 0;
1195      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
1196        import_primitives6.SVG,
1197        {
1198          ref,
1199          ...icon.props,
1200          ...restProps,
1201          ...mergedStyle ? { style: mergedStyle } : {},
1202          width: size4,
1203          height: size4
1204        }
1205      );
1206    }
1207  );
1208  
1209  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useId.mjs
1210  var React11 = __toESM(require_react(), 1);
1211  
1212  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useForcedRerendering.mjs
1213  var React10 = __toESM(require_react(), 1);
1214  function useForcedRerendering() {
1215    const [, setState] = React10.useState({});
1216    return React10.useCallback(() => {
1217      setState({});
1218    }, []);
1219  }
1220  
1221  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useId.mjs
1222  var globalId = 0;
1223  function useGlobalId(idOverride, prefix = "mui") {
1224    const defaultId = React11.useRef(void 0);
1225    const forceRerender = useForcedRerendering();
1226    const id = idOverride ?? defaultId.current;
1227    React11.useEffect(() => {
1228      if (defaultId.current == null) {
1229        globalId += 1;
1230        defaultId.current = `$prefix}-$globalId}`;
1231        if (idOverride == null) {
1232          forceRerender();
1233        }
1234      }
1235    }, [idOverride, prefix, forceRerender]);
1236    return id;
1237  }
1238  var maybeReactUseId = SafeReact.useId;
1239  function useId(idOverride, prefix) {
1240    if (maybeReactUseId !== void 0) {
1241      const reactId = maybeReactUseId();
1242      return idOverride ?? (prefix ? `$prefix}-$reactId}` : reactId);
1243    }
1244    return useGlobalId(idOverride, prefix);
1245  }
1246  
1247  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useBaseUiId.mjs
1248  function useBaseUiId(idOverride) {
1249    return useId(idOverride, "base-ui");
1250  }
1251  
1252  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/createBaseUIEventDetails.mjs
1253  function createChangeEventDetails(reason, event, trigger, customProperties) {
1254    let canceled = false;
1255    let allowPropagation = false;
1256    const custom = customProperties ?? EMPTY_OBJECT;
1257    const details = {
1258      reason,
1259      event: event ?? new Event("base-ui"),
1260      cancel() {
1261        canceled = true;
1262      },
1263      allowPropagation() {
1264        allowPropagation = true;
1265      },
1266      get isCanceled() {
1267        return canceled;
1268      },
1269      get isPropagationAllowed() {
1270        return allowPropagation;
1271      },
1272      trigger,
1273      ...custom
1274    };
1275    return details;
1276  }
1277  
1278  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/reason-parts.mjs
1279  var reason_parts_exports = {};
1280  __export(reason_parts_exports, {
1281    cancelOpen: () => cancelOpen,
1282    chipRemovePress: () => chipRemovePress,
1283    clearPress: () => clearPress,
1284    closePress: () => closePress,
1285    closeWatcher: () => closeWatcher,
1286    decrementPress: () => decrementPress,
1287    disabled: () => disabled,
1288    drag: () => drag,
1289    escapeKey: () => escapeKey,
1290    focusOut: () => focusOut,
1291    imperativeAction: () => imperativeAction,
1292    incrementPress: () => incrementPress,
1293    initial: () => initial,
1294    inputBlur: () => inputBlur,
1295    inputChange: () => inputChange,
1296    inputClear: () => inputClear,
1297    inputPaste: () => inputPaste,
1298    inputPress: () => inputPress,
1299    itemPress: () => itemPress,
1300    keyboard: () => keyboard,
1301    linkPress: () => linkPress,
1302    listNavigation: () => listNavigation,
1303    missing: () => missing,
1304    none: () => none,
1305    outsidePress: () => outsidePress,
1306    pointer: () => pointer,
1307    popupClose: () => popupClose,
1308    scrub: () => scrub,
1309    siblingOpen: () => siblingOpen,
1310    swipe: () => swipe,
1311    trackPress: () => trackPress,
1312    triggerFocus: () => triggerFocus,
1313    triggerHover: () => triggerHover,
1314    triggerPress: () => triggerPress,
1315    wheel: () => wheel,
1316    windowResize: () => windowResize
1317  });
1318  var none = "none";
1319  var triggerPress = "trigger-press";
1320  var triggerHover = "trigger-hover";
1321  var triggerFocus = "trigger-focus";
1322  var outsidePress = "outside-press";
1323  var itemPress = "item-press";
1324  var closePress = "close-press";
1325  var linkPress = "link-press";
1326  var clearPress = "clear-press";
1327  var chipRemovePress = "chip-remove-press";
1328  var trackPress = "track-press";
1329  var incrementPress = "increment-press";
1330  var decrementPress = "decrement-press";
1331  var inputChange = "input-change";
1332  var inputClear = "input-clear";
1333  var inputBlur = "input-blur";
1334  var inputPaste = "input-paste";
1335  var inputPress = "input-press";
1336  var focusOut = "focus-out";
1337  var escapeKey = "escape-key";
1338  var closeWatcher = "close-watcher";
1339  var listNavigation = "list-navigation";
1340  var keyboard = "keyboard";
1341  var pointer = "pointer";
1342  var drag = "drag";
1343  var wheel = "wheel";
1344  var scrub = "scrub";
1345  var popupClose = "popup-close";
1346  var cancelOpen = "cancel-open";
1347  var siblingOpen = "sibling-open";
1348  var disabled = "disabled";
1349  var missing = "missing";
1350  var initial = "initial";
1351  var imperativeAction = "imperative-action";
1352  var swipe = "swipe";
1353  var windowResize = "window-resize";
1354  
1355  // node_modules/.store/@floating-ui/utils@0.2.12-gOxTzMf36nCrbeHpEew-rw/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
1356  function hasWindow() {
1357    return typeof window !== "undefined";
1358  }
1359  function getNodeName(node) {
1360    if (isNode(node)) {
1361      return (node.nodeName || "").toLowerCase();
1362    }
1363    return "#document";
1364  }
1365  function getWindow(node) {
1366    var _node$ownerDocument;
1367    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
1368  }
1369  function getDocumentElement(node) {
1370    var _ref;
1371    return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
1372  }
1373  function isNode(value) {
1374    if (!hasWindow()) {
1375      return false;
1376    }
1377    return value instanceof Node || value instanceof getWindow(value).Node;
1378  }
1379  function isElement(value) {
1380    if (!hasWindow()) {
1381      return false;
1382    }
1383    return value instanceof Element || value instanceof getWindow(value).Element;
1384  }
1385  function isHTMLElement(value) {
1386    if (!hasWindow()) {
1387      return false;
1388    }
1389    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
1390  }
1391  function isShadowRoot(value) {
1392    if (!hasWindow() || typeof ShadowRoot === "undefined") {
1393      return false;
1394    }
1395    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
1396  }
1397  function isOverflowElement(element) {
1398    const {
1399      overflow,
1400      overflowX,
1401      overflowY,
1402      display
1403    } = getComputedStyle2(element);
1404    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
1405  }
1406  function isTableElement(element) {
1407    return /^(table|td|th)$/.test(getNodeName(element));
1408  }
1409  function isTopLayer(element) {
1410    try {
1411      if (element.matches(":popover-open")) {
1412        return true;
1413      }
1414    } catch (_e) {
1415    }
1416    try {
1417      return element.matches(":modal");
1418    } catch (_e) {
1419      return false;
1420    }
1421  }
1422  var willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
1423  var containRe = /paint|layout|strict|content/;
1424  var isNotNone = (value) => !!value && value !== "none";
1425  var isWebKitValue;
1426  function isContainingBlock(elementOrCss) {
1427    const css = isElement(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
1428    return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
1429  }
1430  function getContainingBlock(element) {
1431    let currentNode = getParentNode(element);
1432    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
1433      if (isContainingBlock(currentNode)) {
1434        return currentNode;
1435      } else if (isTopLayer(currentNode)) {
1436        return null;
1437      }
1438      currentNode = getParentNode(currentNode);
1439    }
1440    return null;
1441  }
1442  function isWebKit() {
1443    if (isWebKitValue == null) {
1444      isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
1445    }
1446    return isWebKitValue;
1447  }
1448  function isLastTraversableNode(node) {
1449    return /^(html|body|#document)$/.test(getNodeName(node));
1450  }
1451  function getComputedStyle2(element) {
1452    return getWindow(element).getComputedStyle(element);
1453  }
1454  function getNodeScroll(element) {
1455    if (isElement(element)) {
1456      return {
1457        scrollLeft: element.scrollLeft,
1458        scrollTop: element.scrollTop
1459      };
1460    }
1461    return {
1462      scrollLeft: element.scrollX,
1463      scrollTop: element.scrollY
1464    };
1465  }
1466  function getParentNode(node) {
1467    if (getNodeName(node) === "html") {
1468      return node;
1469    }
1470    const result = (
1471      // Step into the shadow DOM of the parent of a slotted node.
1472      node.assignedSlot || // DOM Element detected.
1473      node.parentNode || // ShadowRoot detected.
1474      isShadowRoot(node) && node.host || // Fallback.
1475      getDocumentElement(node)
1476    );
1477    return isShadowRoot(result) ? result.host : result;
1478  }
1479  function getNearestOverflowAncestor(node) {
1480    const parentNode = getParentNode(node);
1481    if (isLastTraversableNode(parentNode)) {
1482      return (node.ownerDocument || node).body;
1483    }
1484    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
1485      return parentNode;
1486    }
1487    return getNearestOverflowAncestor(parentNode);
1488  }
1489  function getOverflowAncestors(node, list, traverseIframes) {
1490    var _node$ownerDocument2;
1491    if (list === void 0) {
1492      list = [];
1493    }
1494    if (traverseIframes === void 0) {
1495      traverseIframes = true;
1496    }
1497    const scrollableAncestor = getNearestOverflowAncestor(node);
1498    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
1499    const win = getWindow(scrollableAncestor);
1500    if (isBody) {
1501      const frameElement = getFrameElement(win);
1502      return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
1503    } else {
1504      return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
1505    }
1506  }
1507  function getFrameElement(win) {
1508    return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
1509  }
1510  
1511  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/owner.mjs
1512  function ownerDocument(node) {
1513    return node?.ownerDocument || document;
1514  }
1515  
1516  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/addEventListener.mjs
1517  function addEventListener(target, type, listener, options) {
1518    target.addEventListener(type, listener, options);
1519    return () => {
1520      target.removeEventListener(type, listener, options);
1521    };
1522  }
1523  
1524  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/useValueAsRef.mjs
1525  function useValueAsRef(value) {
1526    const latest = useRefWithInit(createLatestRef, value).current;
1527    latest.next = value;
1528    useIsoLayoutEffect(latest.effect);
1529    return latest;
1530  }
1531  function createLatestRef(value) {
1532    const latest = {
1533      current: value,
1534      next: value,
1535      effect: () => {
1536        latest.current = latest.next;
1537      }
1538    };
1539    return latest;
1540  }
1541  
1542  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/parts.mjs
1543  var parts_exports = {};
1544  __export(parts_exports, {
1545    engine: () => engine_exports,
1546    env: () => env_exports,
1547    mediaQuery: () => media_query_exports,
1548    os: () => os_exports,
1549    screenReader: () => screen_reader_exports
1550  });
1551  
1552  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/os.mjs
1553  var os_exports = {};
1554  __export(os_exports, {
1555    android: () => android,
1556    apple: () => apple,
1557    ios: () => ios,
1558    linux: () => linux,
1559    mac: () => mac,
1560    windows: () => windows
1561  });
1562  
1563  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/shared.mjs
1564  function readRawData() {
1565    if (typeof navigator === "undefined") {
1566      return {
1567        userAgent: "",
1568        platform: "",
1569        maxTouchPoints: 0
1570      };
1571    }
1572    if (true) {
1573      const uaData = navigator.userAgentData;
1574      if (uaData && Array.isArray(uaData.brands)) {
1575        return {
1576          userAgent: uaData.brands.map(({
1577            brand,
1578            version: version2
1579          }) => `$brand}/$version2}`).join(" "),
1580          platform: uaData.platform ?? navigator.platform ?? "",
1581          maxTouchPoints: navigator.maxTouchPoints ?? 0
1582        };
1583      }
1584    }
1585    return {
1586      userAgent: navigator.userAgent,
1587      platform: navigator.platform ?? "",
1588      maxTouchPoints: navigator.maxTouchPoints ?? 0
1589    };
1590  }
1591  var {
1592    userAgent,
1593    platform,
1594    maxTouchPoints
1595  } = readRawData();
1596  var lowerUserAgent = userAgent.toLowerCase();
1597  var lowerPlatform = platform.toLowerCase();
1598  
1599  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/os.mjs
1600  var ios = /^i(os$|p)/.test(lowerPlatform) || lowerPlatform === "macintel" && maxTouchPoints > 1;
1601  var ANDROID_STRING = "android";
1602  var android = lowerPlatform === ANDROID_STRING || lowerUserAgent.includes(ANDROID_STRING);
1603  var mac = !ios && lowerPlatform.startsWith("mac");
1604  var windows = lowerPlatform.startsWith("win");
1605  var linux = !android && /^(linux|chrome os)/.test(lowerPlatform);
1606  var apple = mac || ios;
1607  
1608  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/engine.mjs
1609  var engine_exports = {};
1610  __export(engine_exports, {
1611    blink: () => blink,
1612    gecko: () => gecko,
1613    webkit: () => webkit
1614  });
1615  var webkit = typeof CSS !== "undefined" && !!CSS.supports?.("-webkit-backdrop-filter:none");
1616  var gecko = !webkit && lowerUserAgent.includes("firefox");
1617  var blink = !webkit && lowerUserAgent.includes("chrom");
1618  
1619  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/screen-reader.mjs
1620  var screen_reader_exports = {};
1621  __export(screen_reader_exports, {
1622    voiceOver: () => voiceOver
1623  });
1624  var voiceOver = apple;
1625  
1626  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/env.mjs
1627  var env_exports = {};
1628  __export(env_exports, {
1629    jsdom: () => jsdom
1630  });
1631  var jsdom = /jsdom|happydom/.test(lowerUserAgent);
1632  
1633  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/platform/media-query.mjs
1634  var media_query_exports = {};
1635  __export(media_query_exports, {
1636    iOS: () => iOS
1637  });
1638  var iOS = "@supports (-webkit-touch-callout: none)";
1639  
1640  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/components/FloatingDelayGroup.mjs
1641  var React12 = __toESM(require_react(), 1);
1642  
1643  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/event.mjs
1644  function isReactEvent(event) {
1645    return "nativeEvent" in event;
1646  }
1647  function isVirtualClick(event) {
1648    if (event.pointerType === "" && event.isTrusted) {
1649      return true;
1650    }
1651    if (parts_exports.os.android && event.pointerType) {
1652      return event.type === "click" && event.buttons === 1;
1653    }
1654    return event.detail === 0 && !event.pointerType;
1655  }
1656  function isMouseLikePointerType(pointerType, strict) {
1657    const values = ["mouse", "pen"];
1658    if (!strict) {
1659      values.push("", void 0);
1660    }
1661    return values.includes(pointerType);
1662  }
1663  function isClickLikeEvent(event) {
1664    const type = event.type;
1665    return type === "click" || type === "mousedown" || type === "keydown" || type === "keyup";
1666  }
1667  
1668  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/shadowDom.mjs
1669  function activeElement(doc) {
1670    let element = doc.activeElement;
1671    while (element?.shadowRoot?.activeElement != null) {
1672      element = element.shadowRoot.activeElement;
1673    }
1674    return element;
1675  }
1676  function contains(parent, child) {
1677    if (!parent || !child) {
1678      return false;
1679    }
1680    const rootNode = child.getRootNode?.();
1681    if (parent.contains(child)) {
1682      return true;
1683    }
1684    if (rootNode && isShadowRoot(rootNode)) {
1685      let next = child;
1686      while (next) {
1687        if (parent === next) {
1688          return true;
1689        }
1690        next = next.parentNode || next.host;
1691      }
1692    }
1693    return false;
1694  }
1695  function closest(node, selector) {
1696    let current = node;
1697    while (current) {
1698      if (isElement(current) && current.matches(selector)) {
1699        return current;
1700      }
1701      current = current.assignedSlot ?? current.parentNode ?? (isShadowRoot(current) ? current.host : null);
1702    }
1703    return null;
1704  }
1705  function getTarget(event) {
1706    if ("composedPath" in event) {
1707      return event.composedPath()[0] ?? event.target;
1708    }
1709    return event.target;
1710  }
1711  
1712  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/constants.mjs
1713  var FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
1714  var TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
1715  
1716  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/CommonPopupDataAttributes.mjs
1717  var open = "data-open";
1718  var closed = "data-closed";
1719  var anchorHidden = "data-anchor-hidden";
1720  
1721  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/CommonTriggerDataAttributes.mjs
1722  var CommonTriggerDataAttributes_exports = {};
1723  __export(CommonTriggerDataAttributes_exports, {
1724    popupOpen: () => popupOpen,
1725    pressed: () => pressed
1726  });
1727  var popupOpen = "data-popup-open";
1728  var pressed = "data-pressed";
1729  
1730  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/popupStateMapping.mjs
1731  var TRIGGER_HOOK = {
1732    [popupOpen]: ""
1733  };
1734  var PRESSABLE_TRIGGER_HOOK = {
1735    [popupOpen]: "",
1736    [pressed]: ""
1737  };
1738  var POPUP_OPEN_HOOK = {
1739    [open]: ""
1740  };
1741  var POPUP_CLOSED_HOOK = {
1742    [closed]: ""
1743  };
1744  var ANCHOR_HIDDEN_HOOK = {
1745    [anchorHidden]: ""
1746  };
1747  var triggerOpenStateMapping = {
1748    open(value) {
1749      if (value) {
1750        return TRIGGER_HOOK;
1751      }
1752      return null;
1753    }
1754  };
1755  var popupStateMapping = {
1756    open(value) {
1757      if (value) {
1758        return POPUP_OPEN_HOOK;
1759      }
1760      return POPUP_CLOSED_HOOK;
1761    },
1762    anchorHidden(value) {
1763      if (value) {
1764        return ANCHOR_HIDDEN_HOOK;
1765      }
1766      return null;
1767    }
1768  };
1769  var popupTransitionStateMapping = {
1770    ...popupStateMapping,
1771    ...transitionStatusMapping
1772  };
1773  
1774  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/trigger/TooltipTriggerDataAttributes.mjs
1775  var popupOpen2 = CommonTriggerDataAttributes_exports.popupOpen;
1776  var triggerDisabled = "data-trigger-disabled";
1777  
1778  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/element.mjs
1779  function isTargetInsideEnabledTrigger(target, triggerElements) {
1780    if (!isElement(target)) {
1781      return false;
1782    }
1783    const targetElement = target;
1784    if (triggerElements.hasElement(targetElement)) {
1785      return !targetElement.hasAttribute(triggerDisabled);
1786    }
1787    for (const [, trigger] of triggerElements.entries()) {
1788      if (contains(trigger, targetElement)) {
1789        return !trigger.hasAttribute(triggerDisabled);
1790      }
1791    }
1792    return false;
1793  }
1794  function isEventTargetWithin(event, node) {
1795    if (node == null) {
1796      return false;
1797    }
1798    if ("composedPath" in event) {
1799      return event.composedPath().includes(node);
1800    }
1801    const eventAgain = event;
1802    return eventAgain.target != null && node.contains(eventAgain.target);
1803  }
1804  function isRootElement(element) {
1805    return element.matches("html,body");
1806  }
1807  function isTypeableElement(element) {
1808    return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
1809  }
1810  function isInteractiveElement(element) {
1811    return closest(element, `button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),$TYPEABLE_SELECTOR}`) != null;
1812  }
1813  function matchesFocusVisible(element) {
1814    if (!element || parts_exports.env.jsdom) {
1815      return true;
1816    }
1817    try {
1818      return element.matches(":focus-visible");
1819    } catch (_e) {
1820      return true;
1821    }
1822  }
1823  
1824  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useHoverShared.mjs
1825  function resolveValue(value, pointerType) {
1826    if (pointerType != null && !isMouseLikePointerType(pointerType)) {
1827      return 0;
1828    }
1829    if (typeof value === "function") {
1830      return value();
1831    }
1832    return value;
1833  }
1834  function getDelay(value, prop, pointerType) {
1835    const result = resolveValue(value, pointerType);
1836    if (typeof result === "number") {
1837      return result;
1838    }
1839    return result?.[prop];
1840  }
1841  function getRestMs(value) {
1842    if (typeof value === "function") {
1843      return value();
1844    }
1845    return value;
1846  }
1847  function isClickLikeOpenEvent(openEventType, interactedInside) {
1848    return interactedInside || openEventType === "click" || openEventType === "mousedown";
1849  }
1850  function isHoverOpenEvent(openEventType) {
1851    return openEventType?.includes("mouse") && openEventType !== "mousedown";
1852  }
1853  
1854  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/components/FloatingDelayGroup.mjs
1855  var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
1856  var FloatingDelayGroupContext = /* @__PURE__ */ React12.createContext({
1857    hasProvider: false,
1858    timeoutMs: 0,
1859    delayRef: {
1860      current: 0
1861    },
1862    initialDelayRef: {
1863      current: 0
1864    },
1865    timeout: new Timeout(),
1866    currentIdRef: {
1867      current: null
1868    },
1869    currentContextRef: {
1870      current: null
1871    }
1872  });
1873  if (true) FloatingDelayGroupContext.displayName = "FloatingDelayGroupContext";
1874  function resetDelayRef(delayRef, initialDelayRef) {
1875    delayRef.current = initialDelayRef.current;
1876  }
1877  function FloatingDelayGroup(props) {
1878    const {
1879      children,
1880      delay,
1881      timeoutMs = 0
1882    } = props;
1883    const delayRef = React12.useRef(delay);
1884    const initialDelayRef = React12.useRef(delay);
1885    const currentIdRef = React12.useRef(null);
1886    const currentContextRef = React12.useRef(null);
1887    const timeout = useTimeout();
1888    useIsoLayoutEffect(() => {
1889      initialDelayRef.current = delay;
1890      if (!currentIdRef.current) {
1891        delayRef.current = delay;
1892        return;
1893      }
1894      delayRef.current = {
1895        open: getDelay(delayRef.current, "open"),
1896        close: getDelay(delay, "close")
1897      };
1898    }, [delay, currentIdRef, delayRef, initialDelayRef]);
1899    return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(FloatingDelayGroupContext.Provider, {
1900      value: React12.useMemo(() => ({
1901        hasProvider: true,
1902        delayRef,
1903        initialDelayRef,
1904        currentIdRef,
1905        timeoutMs,
1906        currentContextRef,
1907        timeout
1908      }), [timeoutMs, timeout]),
1909      children
1910    });
1911  }
1912  function useDelayGroup(store, options = {
1913    open: false
1914  }) {
1915    const {
1916      open: open2
1917    } = options;
1918    const floatingId = store.useState("floatingId");
1919    const groupContext = React12.useContext(FloatingDelayGroupContext);
1920    const {
1921      currentIdRef,
1922      delayRef,
1923      timeoutMs,
1924      initialDelayRef,
1925      currentContextRef,
1926      hasProvider,
1927      timeout
1928    } = groupContext;
1929    const [isInstantPhase, setIsInstantPhase] = React12.useState(false);
1930    const openRef = React12.useRef(open2);
1931    useIsoLayoutEffect(() => {
1932      openRef.current = open2;
1933    }, [open2]);
1934    useIsoLayoutEffect(() => {
1935      function unset() {
1936        currentContextRef.current?.setIsInstantPhase(false);
1937        currentIdRef.current = null;
1938        currentContextRef.current = null;
1939        delayRef.current = initialDelayRef.current;
1940        timeout.clear();
1941      }
1942      if (!currentIdRef.current) {
1943        return void 0;
1944      }
1945      if (!open2 && currentIdRef.current === floatingId) {
1946        setIsInstantPhase(false);
1947        if (timeoutMs) {
1948          const closingId = floatingId;
1949          timeout.start(timeoutMs, () => {
1950            if (store.select("open") || currentIdRef.current && currentIdRef.current !== closingId) {
1951              return;
1952            }
1953            unset();
1954          });
1955          return () => {
1956            if (openRef.current || currentIdRef.current !== closingId) {
1957              timeout.clear();
1958            }
1959          };
1960        }
1961        unset();
1962      }
1963      return void 0;
1964    }, [open2, floatingId, currentIdRef, delayRef, timeoutMs, initialDelayRef, currentContextRef, timeout, store]);
1965    useIsoLayoutEffect(() => {
1966      if (!open2) {
1967        return;
1968      }
1969      const prevContext = currentContextRef.current;
1970      const prevId = currentIdRef.current;
1971      timeout.clear();
1972      currentContextRef.current = {
1973        onOpenChange: store.setOpen,
1974        setIsInstantPhase
1975      };
1976      currentIdRef.current = floatingId;
1977      delayRef.current = {
1978        open: 0,
1979        close: getDelay(initialDelayRef.current, "close")
1980      };
1981      if (prevId !== null && prevId !== floatingId) {
1982        setIsInstantPhase(true);
1983        prevContext?.setIsInstantPhase(true);
1984        prevContext?.onOpenChange(false, createChangeEventDetails(reason_parts_exports.none));
1985      } else {
1986        setIsInstantPhase(false);
1987        prevContext?.setIsInstantPhase(false);
1988      }
1989    }, [open2, floatingId, store, currentIdRef, delayRef, initialDelayRef, currentContextRef, timeout]);
1990    useIsoLayoutEffect(() => {
1991      return () => {
1992        if (currentIdRef.current === floatingId) {
1993          currentContextRef.current = null;
1994          if (!openRef.current) {
1995            return;
1996          }
1997          currentIdRef.current = null;
1998          resetDelayRef(delayRef, initialDelayRef);
1999          timeout.clear();
2000        }
2001      };
2002    }, [currentContextRef, currentIdRef, delayRef, floatingId, initialDelayRef, timeout]);
2003    return React12.useMemo(() => ({
2004      activeIdRef: currentIdRef,
2005      hasProvider,
2006      delayRef,
2007      isInstantPhase
2008    }), [currentIdRef, hasProvider, delayRef, isInstantPhase]);
2009  }
2010  
2011  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/mergeCleanups.mjs
2012  function mergeCleanups(...cleanups) {
2013    return () => {
2014      for (let i = 0; i < cleanups.length; i += 1) {
2015        const cleanup = cleanups[i];
2016        if (cleanup) {
2017          cleanup();
2018        }
2019      }
2020    };
2021  }
2022  
2023  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/FocusGuard.mjs
2024  var React13 = __toESM(require_react(), 1);
2025  
2026  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/visuallyHidden.mjs
2027  var visuallyHiddenBase = {
2028    clipPath: "inset(50%)",
2029    overflow: "hidden",
2030    whiteSpace: "nowrap",
2031    border: 0,
2032    padding: 0,
2033    width: 1,
2034    height: 1,
2035    margin: -1
2036  };
2037  var visuallyHidden = {
2038    ...visuallyHiddenBase,
2039    position: "fixed",
2040    margin: 0,
2041    top: 0,
2042    left: 0
2043  };
2044  var visuallyHiddenInput = {
2045    ...visuallyHiddenBase,
2046    position: "absolute"
2047  };
2048  
2049  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/FocusGuard.mjs
2050  var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
2051  var FocusGuard = /* @__PURE__ */ React13.forwardRef(function FocusGuard2(props, ref) {
2052    const [role, setRole] = React13.useState();
2053    useIsoLayoutEffect(() => {
2054      if (parts_exports.screenReader.voiceOver && parts_exports.engine.webkit) {
2055        setRole("button");
2056      }
2057    }, []);
2058    const restProps = {
2059      tabIndex: 0,
2060      // Role is only for VoiceOver
2061      role
2062    };
2063    return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", {
2064      ...props,
2065      ref,
2066      style: visuallyHidden,
2067      "aria-hidden": role ? void 0 : true,
2068      ...restProps,
2069      "data-base-ui-focus-guard": ""
2070    });
2071  });
2072  if (true) FocusGuard.displayName = "FocusGuard";
2073  
2074  // node_modules/.store/@floating-ui/utils@0.2.12-gOxTzMf36nCrbeHpEew-rw/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
2075  var min = Math.min;
2076  var max = Math.max;
2077  var round = Math.round;
2078  var floor = Math.floor;
2079  var createCoords = (v) => ({
2080    x: v,
2081    y: v
2082  });
2083  var oppositeSideMap = {
2084    left: "right",
2085    right: "left",
2086    bottom: "top",
2087    top: "bottom"
2088  };
2089  function clamp(start, value, end) {
2090    return max(start, min(value, end));
2091  }
2092  function evaluate(value, param) {
2093    return typeof value === "function" ? value(param) : value;
2094  }
2095  function getSide(placement) {
2096    return placement.split("-")[0];
2097  }
2098  function getAlignment(placement) {
2099    return placement.split("-")[1];
2100  }
2101  function getOppositeAxis(axis) {
2102    return axis === "x" ? "y" : "x";
2103  }
2104  function getAxisLength(axis) {
2105    return axis === "y" ? "height" : "width";
2106  }
2107  function getSideAxis(placement) {
2108    const firstChar = placement[0];
2109    return firstChar === "t" || firstChar === "b" ? "y" : "x";
2110  }
2111  function getAlignmentAxis(placement) {
2112    return getOppositeAxis(getSideAxis(placement));
2113  }
2114  function getAlignmentSides(placement, rects, rtl) {
2115    if (rtl === void 0) {
2116      rtl = false;
2117    }
2118    const alignment = getAlignment(placement);
2119    const alignmentAxis = getAlignmentAxis(placement);
2120    const length = getAxisLength(alignmentAxis);
2121    let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
2122    if (rects.reference[length] > rects.floating[length]) {
2123      mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
2124    }
2125    return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
2126  }
2127  function getExpandedPlacements(placement) {
2128    const oppositePlacement = getOppositePlacement(placement);
2129    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
2130  }
2131  function getOppositeAlignmentPlacement(placement) {
2132    return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
2133  }
2134  var lrPlacement = ["left", "right"];
2135  var rlPlacement = ["right", "left"];
2136  var tbPlacement = ["top", "bottom"];
2137  var btPlacement = ["bottom", "top"];
2138  function getSideList(side, isStart, rtl) {
2139    switch (side) {
2140      case "top":
2141      case "bottom":
2142        if (rtl) return isStart ? rlPlacement : lrPlacement;
2143        return isStart ? lrPlacement : rlPlacement;
2144      case "left":
2145      case "right":
2146        return isStart ? tbPlacement : btPlacement;
2147      default:
2148        return [];
2149    }
2150  }
2151  function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
2152    const alignment = getAlignment(placement);
2153    let list = getSideList(getSide(placement), direction === "start", rtl);
2154    if (alignment) {
2155      list = list.map((side) => side + "-" + alignment);
2156      if (flipAlignment) {
2157        list = list.concat(list.map(getOppositeAlignmentPlacement));
2158      }
2159    }
2160    return list;
2161  }
2162  function getOppositePlacement(placement) {
2163    const side = getSide(placement);
2164    return oppositeSideMap[side] + placement.slice(side.length);
2165  }
2166  function expandPaddingObject(padding) {
2167    var _padding$top, _padding$right, _padding$bottom, _padding$left;
2168    return {
2169      top: (_padding$top = padding.top) != null ? _padding$top : 0,
2170      right: (_padding$right = padding.right) != null ? _padding$right : 0,
2171      bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
2172      left: (_padding$left = padding.left) != null ? _padding$left : 0
2173    };
2174  }
2175  function getPaddingObject(padding) {
2176    return typeof padding !== "number" ? expandPaddingObject(padding) : {
2177      top: padding,
2178      right: padding,
2179      bottom: padding,
2180      left: padding
2181    };
2182  }
2183  function rectToClientRect(rect) {
2184    const {
2185      x,
2186      y,
2187      width,
2188      height
2189    } = rect;
2190    return {
2191      width,
2192      height,
2193      top: y,
2194      left: x,
2195      right: x + width,
2196      bottom: y + height,
2197      x,
2198      y
2199    };
2200  }
2201  
2202  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/composite.mjs
2203  function isHiddenByStyles(styles) {
2204    return styles.visibility === "hidden" || styles.visibility === "collapse";
2205  }
2206  function isElementVisible(element, styles = element ? getComputedStyle2(element) : null) {
2207    if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) {
2208      return false;
2209    }
2210    if (typeof element.checkVisibility === "function") {
2211      return element.checkVisibility();
2212    }
2213    return styles.display !== "none" && styles.display !== "contents";
2214  }
2215  
2216  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/tabbable.mjs
2217  var CANDIDATE_SELECTOR = 'a[href],button,input,select,textarea,summary,details,iframe,object,embed,[tabindex],[contenteditable]:not([contenteditable="false"]),audio[controls],video[controls]';
2218  function getParentElement(element) {
2219    const assignedSlot = element.assignedSlot;
2220    if (assignedSlot) {
2221      return assignedSlot;
2222    }
2223    if (element.parentElement) {
2224      return element.parentElement;
2225    }
2226    const rootNode = element.getRootNode();
2227    return isShadowRoot(rootNode) ? rootNode.host : null;
2228  }
2229  function getDetailsSummary(details) {
2230    for (const child of Array.from(details.children)) {
2231      if (getNodeName(child) === "summary") {
2232        return child;
2233      }
2234    }
2235    return null;
2236  }
2237  function isWithinOpenDetailsSummary(element, details) {
2238    const summary = getDetailsSummary(details);
2239    return !!summary && (element === summary || contains(summary, element));
2240  }
2241  function isFocusableCandidate(element) {
2242    const nodeName = element ? getNodeName(element) : "";
2243    return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== "summary" || element.parentElement != null && getNodeName(element.parentElement) === "details" && getDetailsSummary(element.parentElement) === element) && (nodeName !== "details" || getDetailsSummary(element) == null) && (nodeName !== "input" || element.type !== "hidden");
2244  }
2245  function isFocusableElement(element) {
2246    if (!isFocusableCandidate(element) || !element.isConnected || element.matches(":disabled")) {
2247      return false;
2248    }
2249    for (let current = element; current; current = getParentElement(current)) {
2250      const isAncestor = current !== element;
2251      const isSlot = getNodeName(current) === "slot";
2252      if (current.hasAttribute("inert")) {
2253        return false;
2254      }
2255      if (isAncestor && getNodeName(current) === "details" && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute("hidden") || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) {
2256        return false;
2257      }
2258    }
2259    return true;
2260  }
2261  function isVisibleInTabbableTree(element, isAncestor) {
2262    const styles = getComputedStyle2(element);
2263    if (!isAncestor) {
2264      return isElementVisible(element, styles);
2265    }
2266    return styles.display !== "none";
2267  }
2268  function getTabIndex(element) {
2269    const tabIndex = element.tabIndex;
2270    if (tabIndex < 0) {
2271      const nodeName = getNodeName(element);
2272      if (nodeName === "details" || nodeName === "audio" || nodeName === "video" || isHTMLElement(element) && element.isContentEditable) {
2273        return 0;
2274      }
2275    }
2276    return tabIndex;
2277  }
2278  function getNamedRadioInput(element) {
2279    if (getNodeName(element) !== "input") {
2280      return null;
2281    }
2282    const input = element;
2283    return input.type === "radio" && input.name !== "" ? input : null;
2284  }
2285  function isTabbableRadio(element, candidates) {
2286    const input = getNamedRadioInput(element);
2287    if (!input) {
2288      return true;
2289    }
2290    const checkedRadio = candidates.find((candidate) => {
2291      const radio = getNamedRadioInput(candidate);
2292      return radio?.name === input.name && radio.form === input.form && radio.checked;
2293    });
2294    if (checkedRadio) {
2295      return checkedRadio === input;
2296    }
2297    return candidates.find((candidate) => {
2298      const radio = getNamedRadioInput(candidate);
2299      return radio?.name === input.name && radio.form === input.form;
2300    }) === input;
2301  }
2302  function getComposedChildren(container) {
2303    if (isHTMLElement(container) && getNodeName(container) === "slot") {
2304      const assignedElements = container.assignedElements({
2305        flatten: true
2306      });
2307      if (assignedElements.length > 0) {
2308        return assignedElements;
2309      }
2310    }
2311    if (isHTMLElement(container) && container.shadowRoot) {
2312      return Array.from(container.shadowRoot.children);
2313    }
2314    return Array.from(container.children);
2315  }
2316  function appendCandidates(container, list) {
2317    getComposedChildren(container).forEach((child) => {
2318      if (isFocusableCandidate(child)) {
2319        list.push(child);
2320      }
2321      appendCandidates(child, list);
2322    });
2323  }
2324  function appendMatchingElements(container, selector, list) {
2325    getComposedChildren(container).forEach((child) => {
2326      if (isHTMLElement(child) && child.matches(selector)) {
2327        list.push(child);
2328      }
2329      appendMatchingElements(child, selector, list);
2330    });
2331  }
2332  function focusable(container) {
2333    const candidates = [];
2334    appendCandidates(container, candidates);
2335    return candidates.filter(isFocusableElement);
2336  }
2337  function tabbable(container) {
2338    const candidates = focusable(container);
2339    return candidates.filter((element) => getTabIndex(element) >= 0 && isTabbableRadio(element, candidates));
2340  }
2341  function getTabbableIn(container, dir) {
2342    const list = tabbable(container);
2343    const len = list.length;
2344    if (len === 0) {
2345      return void 0;
2346    }
2347    const active = activeElement(ownerDocument(container));
2348    const index2 = list.indexOf(active);
2349    const nextIndex = index2 === -1 ? dir === 1 ? 0 : len - 1 : index2 + dir;
2350    return list[nextIndex];
2351  }
2352  function getNextTabbable(referenceElement) {
2353    return getTabbableIn(ownerDocument(referenceElement).body, 1) || referenceElement;
2354  }
2355  function getPreviousTabbable(referenceElement) {
2356    return getTabbableIn(ownerDocument(referenceElement).body, -1) || referenceElement;
2357  }
2358  function isOutsideEvent(event, container) {
2359    const containerElement = container || event.currentTarget;
2360    const relatedTarget = event.relatedTarget;
2361    return !relatedTarget || !contains(containerElement, relatedTarget);
2362  }
2363  function disableFocusInside(container) {
2364    const tabbableElements = tabbable(container);
2365    tabbableElements.forEach((element) => {
2366      element.dataset.tabindex = element.getAttribute("tabindex") || "";
2367      element.setAttribute("tabindex", "-1");
2368    });
2369  }
2370  function enableFocusInside(container) {
2371    const elements = [];
2372    appendMatchingElements(container, "[data-tabindex]", elements);
2373    elements.forEach((element) => {
2374      const tabindex = element.dataset.tabindex;
2375      delete element.dataset.tabindex;
2376      if (tabindex) {
2377        element.setAttribute("tabindex", tabindex);
2378      } else {
2379        element.removeAttribute("tabindex");
2380      }
2381    });
2382  }
2383  
2384  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/nodes.mjs
2385  function getNodeChildren(nodes, id, onlyOpenChildren = true) {
2386    const directChildren = nodes.filter((node) => node.parentId === id);
2387    return directChildren.flatMap((child) => [...!onlyOpenChildren || child.context?.open ? [child] : [], ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
2388  }
2389  
2390  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/createAttribute.mjs
2391  function createAttribute(name) {
2392    return `data-base-ui-$name}`;
2393  }
2394  
2395  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/components/FloatingPortal.mjs
2396  var React14 = __toESM(require_react(), 1);
2397  var ReactDOM2 = __toESM(require_react_dom(), 1);
2398  
2399  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/constants.mjs
2400  var DISABLED_TRANSITIONS_STYLE = {
2401    style: {
2402      transition: "none"
2403    }
2404  };
2405  var BASE_UI_SWIPE_IGNORE_ATTRIBUTE = "data-base-ui-swipe-ignore";
2406  var LEGACY_SWIPE_IGNORE_ATTRIBUTE = "data-swipe-ignore";
2407  var BASE_UI_SWIPE_IGNORE_SELECTOR = `[$BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
2408  var LEGACY_SWIPE_IGNORE_SELECTOR = `[$LEGACY_SWIPE_IGNORE_ATTRIBUTE}]`;
2409  var POPUP_COLLISION_AVOIDANCE = {
2410    fallbackAxisSide: "end"
2411  };
2412  var ownerVisuallyHidden = {
2413    clipPath: "inset(50%)",
2414    position: "fixed",
2415    top: 0,
2416    left: 0
2417  };
2418  
2419  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/components/FloatingPortal.mjs
2420  var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
2421  var PortalContext = /* @__PURE__ */ React14.createContext(null);
2422  if (true) PortalContext.displayName = "PortalContext";
2423  var usePortalContext = () => React14.useContext(PortalContext);
2424  var attr = createAttribute("portal");
2425  function useFloatingPortalNode(props = {}) {
2426    const {
2427      ref,
2428      container: containerProp,
2429      componentProps = EMPTY_OBJECT,
2430      elementProps
2431    } = props;
2432    const uniqueId = useId();
2433    const portalContext = usePortalContext();
2434    const parentPortalNode = portalContext?.portalNode;
2435    const [containerElement, setContainerElement] = React14.useState(null);
2436    const [portalNode, setPortalNode] = React14.useState(null);
2437    const setPortalNodeRef = useStableCallback((node) => {
2438      if (node !== null) {
2439        setPortalNode(node);
2440      }
2441    });
2442    const containerRef = React14.useRef(null);
2443    useIsoLayoutEffect(() => {
2444      if (containerProp === null) {
2445        if (containerRef.current) {
2446          containerRef.current = null;
2447          setPortalNode(null);
2448          setContainerElement(null);
2449        }
2450        return;
2451      }
2452      const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
2453      if (resolvedContainer == null) {
2454        if (containerRef.current) {
2455          containerRef.current = null;
2456          setPortalNode(null);
2457          setContainerElement(null);
2458        }
2459        return;
2460      }
2461      if (containerRef.current !== resolvedContainer) {
2462        containerRef.current = resolvedContainer;
2463        setPortalNode(null);
2464        setContainerElement(resolvedContainer);
2465      }
2466    }, [containerProp, parentPortalNode]);
2467    const portalElement = useRenderElement("div", componentProps, {
2468      ref: [ref, setPortalNodeRef],
2469      props: [{
2470        id: uniqueId,
2471        [attr]: ""
2472      }, elementProps]
2473    });
2474    const portalSubtree = containerElement && portalElement ? /* @__PURE__ */ ReactDOM2.createPortal(portalElement, containerElement) : null;
2475    return {
2476      node: portalNode,
2477      // `id` and `render` props can override or remove the generated ID. Use the exact
2478      // rendered value so `aria-owns` never points at an ID absent from the DOM.
2479      nodeId: /* @__PURE__ */ React14.isValidElement(portalElement) ? portalElement.props.id : void 0,
2480      subtree: portalSubtree
2481    };
2482  }
2483  var FloatingPortal = /* @__PURE__ */ React14.forwardRef(function FloatingPortal2(componentProps, forwardedRef) {
2484    const {
2485      render,
2486      className,
2487      style,
2488      children,
2489      container,
2490      portalOwnerRole,
2491      ...elementProps
2492    } = componentProps;
2493    const {
2494      node: portalNode,
2495      nodeId: portalNodeId,
2496      subtree: portalSubtree
2497    } = useFloatingPortalNode({
2498      container,
2499      ref: forwardedRef,
2500      componentProps,
2501      elementProps
2502    });
2503    const beforeOutsideRef = React14.useRef(null);
2504    const afterOutsideRef = React14.useRef(null);
2505    const beforeInsideRef = React14.useRef(null);
2506    const afterInsideRef = React14.useRef(null);
2507    const [focusManagerState, setFocusManagerState] = React14.useState(null);
2508    const focusInsideDisabledRef = React14.useRef(false);
2509    const modal = focusManagerState?.modal;
2510    const open2 = focusManagerState?.open;
2511    const shouldRenderGuards = !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
2512    React14.useEffect(() => {
2513      if (!portalNode || modal) {
2514        return void 0;
2515      }
2516      function onFocus(event) {
2517        if (portalNode && event.relatedTarget && isOutsideEvent(event)) {
2518          if (event.type === "focusin") {
2519            if (focusInsideDisabledRef.current) {
2520              enableFocusInside(portalNode);
2521              focusInsideDisabledRef.current = false;
2522            }
2523          } else {
2524            disableFocusInside(portalNode);
2525            focusInsideDisabledRef.current = true;
2526          }
2527        }
2528      }
2529      return mergeCleanups(addEventListener(portalNode, "focusin", onFocus, true), addEventListener(portalNode, "focusout", onFocus, true));
2530    }, [portalNode, modal]);
2531    useIsoLayoutEffect(() => {
2532      if (!portalNode || open2 !== true || !focusInsideDisabledRef.current) {
2533        return;
2534      }
2535      enableFocusInside(portalNode);
2536      focusInsideDisabledRef.current = false;
2537    }, [open2, portalNode]);
2538    const portalContextValue = React14.useMemo(() => ({
2539      beforeOutsideRef,
2540      afterOutsideRef,
2541      beforeInsideRef,
2542      afterInsideRef,
2543      portalNode,
2544      setFocusManagerState
2545    }), [portalNode]);
2546    return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(React14.Fragment, {
2547      children: [portalSubtree, /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(PortalContext.Provider, {
2548        value: portalContextValue,
2549        children: [shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(FocusGuard, {
2550          "data-type": "outside",
2551          ref: beforeOutsideRef,
2552          onFocus: (event) => {
2553            if (isOutsideEvent(event, portalNode)) {
2554              beforeInsideRef.current?.focus();
2555            } else {
2556              const domReference = focusManagerState ? focusManagerState.domReference : null;
2557              const prevTabbable = getPreviousTabbable(domReference);
2558              prevTabbable?.focus();
2559            }
2560          }
2561        }), shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", {
2562          role: portalOwnerRole,
2563          "aria-owns": portalNodeId,
2564          style: ownerVisuallyHidden
2565        }), portalNode && /* @__PURE__ */ ReactDOM2.createPortal(children, portalNode), shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(FocusGuard, {
2566          "data-type": "outside",
2567          ref: afterOutsideRef,
2568          onFocus: (event) => {
2569            if (isOutsideEvent(event, portalNode)) {
2570              afterInsideRef.current?.focus();
2571            } else {
2572              const domReference = focusManagerState ? focusManagerState.domReference : null;
2573              const nextTabbable = getNextTabbable(domReference);
2574              nextTabbable?.focus();
2575              if (focusManagerState?.closeOnFocusOut) {
2576                focusManagerState?.onOpenChange(false, createChangeEventDetails(reason_parts_exports.focusOut, event.nativeEvent));
2577              }
2578            }
2579          }
2580        })]
2581      })]
2582    });
2583  });
2584  if (true) FloatingPortal.displayName = "FloatingPortal";
2585  
2586  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/components/FloatingTree.mjs
2587  var React15 = __toESM(require_react(), 1);
2588  
2589  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/utils/createEventEmitter.mjs
2590  function createEventEmitter() {
2591    const map = /* @__PURE__ */ new Map();
2592    return {
2593      emit(event, data) {
2594        map.get(event)?.forEach((listener) => listener(data));
2595      },
2596      on(event, listener) {
2597        if (!map.has(event)) {
2598          map.set(event, /* @__PURE__ */ new Set());
2599        }
2600        map.get(event).add(listener);
2601      },
2602      off(event, listener) {
2603        map.get(event)?.delete(listener);
2604      }
2605    };
2606  }
2607  
2608  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/components/FloatingTree.mjs
2609  var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
2610  var FloatingNodeContext = /* @__PURE__ */ React15.createContext(null);
2611  if (true) FloatingNodeContext.displayName = "FloatingNodeContext";
2612  var FloatingTreeContext = /* @__PURE__ */ React15.createContext(null);
2613  if (true) FloatingTreeContext.displayName = "FloatingTreeContext";
2614  var useFloatingParentNodeId = () => React15.useContext(FloatingNodeContext)?.id || null;
2615  var useFloatingTree = (externalTree) => {
2616    const contextTree = React15.useContext(FloatingTreeContext);
2617    return externalTree ?? contextTree;
2618  };
2619  
2620  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useClientPoint.mjs
2621  var React16 = __toESM(require_react(), 1);
2622  function createVirtualElement(domElement, data) {
2623    let offsetX = null;
2624    let offsetY = null;
2625    let isAutoUpdateEvent = false;
2626    return {
2627      contextElement: domElement || void 0,
2628      getBoundingClientRect() {
2629        const domRect = domElement?.getBoundingClientRect() || {
2630          width: 0,
2631          height: 0,
2632          x: 0,
2633          y: 0
2634        };
2635        const isXAxis = data.axis === "x" || data.axis === "both";
2636        const isYAxis = data.axis === "y" || data.axis === "both";
2637        const canTrackCursorOnAutoUpdate = ["mouseenter", "mousemove"].includes(data.dataRef.current.openEvent?.type || "") && data.pointerType !== "touch";
2638        const width = data.axis === "y" ? domRect.width : 0;
2639        const height = data.axis === "x" ? domRect.height : 0;
2640        let x = domRect.x;
2641        let y = domRect.y;
2642        if (offsetX == null && data.x && isXAxis) {
2643          offsetX = domRect.x - data.x;
2644        }
2645        if (offsetY == null && data.y && isYAxis) {
2646          offsetY = domRect.y - data.y;
2647        }
2648        x -= offsetX || 0;
2649        y -= offsetY || 0;
2650        if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {
2651          x = isXAxis && data.x != null ? data.x : x;
2652          y = isYAxis && data.y != null ? data.y : y;
2653        }
2654        isAutoUpdateEvent = true;
2655        return {
2656          width,
2657          height,
2658          x,
2659          y,
2660          top: y,
2661          right: x + width,
2662          bottom: y + height,
2663          left: x
2664        };
2665      }
2666    };
2667  }
2668  function isMouseBasedEvent(event) {
2669    return event != null && event.clientX != null;
2670  }
2671  function useClientPoint(store, props = {}) {
2672    const {
2673      enabled = true,
2674      axis = "both"
2675    } = props;
2676    const open2 = store.useState("open");
2677    const floating = store.useState("floatingElement");
2678    const domReference = store.useState("domReferenceElement");
2679    const dataRef = store.context.dataRef;
2680    const initialRef = React16.useRef(false);
2681    const cleanupListenerRef = React16.useRef(null);
2682    const [pointerType, setPointerType] = React16.useState();
2683    const [reactive, setReactive] = React16.useState([]);
2684    const resetReference = useStableCallback((reference2) => {
2685      store.set("positionReference", reference2);
2686    });
2687    const setReference = useStableCallback((newX, newY, referenceElement) => {
2688      if (initialRef.current) {
2689        return;
2690      }
2691      if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) {
2692        return;
2693      }
2694      store.set("positionReference", createVirtualElement(referenceElement ?? domReference, {
2695        x: newX,
2696        y: newY,
2697        axis,
2698        dataRef,
2699        pointerType
2700      }));
2701    });
2702    const handleReferenceEnterOrMove = useStableCallback((event) => {
2703      if (!open2) {
2704        setReference(event.clientX, event.clientY, event.currentTarget);
2705      } else if (!cleanupListenerRef.current) {
2706        setReference(event.clientX, event.clientY, event.currentTarget);
2707        setReactive([]);
2708      }
2709    });
2710    const openCheck = isMouseLikePointerType(pointerType) ? floating : open2;
2711    React16.useEffect(() => {
2712      if (!enabled) {
2713        resetReference(domReference);
2714        return void 0;
2715      }
2716      if (!openCheck) {
2717        return void 0;
2718      }
2719      function cleanupListener() {
2720        cleanupListenerRef.current?.();
2721        cleanupListenerRef.current = null;
2722      }
2723      const win = getWindow(floating);
2724      function handleMouseMove(event) {
2725        const target = getTarget(event);
2726        if (!contains(floating, target)) {
2727          setReference(event.clientX, event.clientY);
2728        } else {
2729          cleanupListener();
2730        }
2731      }
2732      if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {
2733        cleanupListenerRef.current = addEventListener(win, "mousemove", handleMouseMove);
2734      } else {
2735        resetReference(domReference);
2736      }
2737      return cleanupListener;
2738    }, [openCheck, enabled, floating, dataRef, domReference, store, setReference, resetReference, reactive]);
2739    React16.useEffect(() => () => {
2740      store.set("positionReference", null);
2741    }, [store]);
2742    React16.useEffect(() => {
2743      if (enabled && !floating) {
2744        initialRef.current = false;
2745      }
2746    }, [enabled, floating]);
2747    React16.useEffect(() => {
2748      if (!enabled && open2) {
2749        initialRef.current = true;
2750      }
2751    }, [enabled, open2]);
2752    const reference = React16.useMemo(() => {
2753      function setPointerTypeRef(event) {
2754        setPointerType(event.pointerType);
2755      }
2756      return {
2757        onPointerDown: setPointerTypeRef,
2758        onPointerEnter: setPointerTypeRef,
2759        onMouseMove: handleReferenceEnterOrMove,
2760        onMouseEnter: handleReferenceEnterOrMove
2761      };
2762    }, [handleReferenceEnterOrMove]);
2763    return React16.useMemo(() => enabled ? {
2764      reference,
2765      trigger: reference
2766    } : {}, [enabled, reference]);
2767  }
2768  
2769  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useDismiss.mjs
2770  var React17 = __toESM(require_react(), 1);
2771  function alwaysFalse() {
2772    return false;
2773  }
2774  function normalizeProp(normalizable) {
2775    return {
2776      escapeKey: typeof normalizable === "boolean" ? normalizable : normalizable?.escapeKey ?? false,
2777      outsidePress: typeof normalizable === "boolean" ? normalizable : normalizable?.outsidePress ?? true
2778    };
2779  }
2780  function useDismiss(store, props = {}) {
2781    const {
2782      enabled = true,
2783      escapeKey: escapeKey2 = true,
2784      outsidePress: outsidePressProp = true,
2785      outsidePressEvent = "sloppy",
2786      referencePress = alwaysFalse,
2787      bubbles,
2788      externalTree
2789    } = props;
2790    const open2 = store.useState("open");
2791    const floatingElement = store.useState("floatingElement");
2792    const {
2793      dataRef,
2794      events
2795    } = store.context;
2796    const tree = useFloatingTree(externalTree);
2797    const outsidePressFn = useStableCallback(typeof outsidePressProp === "function" ? outsidePressProp : () => false);
2798    const outsidePress2 = typeof outsidePressProp === "function" ? outsidePressFn : outsidePressProp;
2799    const outsidePressEnabled = outsidePress2 !== false;
2800    const getOutsidePressEventProp = useStableCallback(() => outsidePressEvent);
2801    const {
2802      escapeKey: escapeKeyBubbles,
2803      outsidePress: outsidePressBubbles
2804    } = normalizeProp(bubbles);
2805    const pressStartedInsideRef = React17.useRef(false);
2806    const pressStartPreventedRef = React17.useRef(false);
2807    const suppressNextOutsideClickRef = React17.useRef(false);
2808    const sawPressWhileOpenRef = React17.useRef(false);
2809    const isComposingRef = React17.useRef(false);
2810    const currentPointerTypeRef = React17.useRef("");
2811    const touchStateRef = React17.useRef(null);
2812    const cancelDismissOnEndTimeout = useTimeout();
2813    const clearInsideReactTreeTimeout = useTimeout();
2814    const compositionTimeout = useTimeout();
2815    const clearInsideReactTree = useStableCallback(() => {
2816      clearInsideReactTreeTimeout.clear();
2817      dataRef.current.insideReactTree = false;
2818    });
2819    const hasBlockingChild = useStableCallback((bubbleKey) => {
2820      const nodeId = dataRef.current.floatingContext?.nodeId;
2821      const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
2822      return children.some((child) => child.context?.open && !child.context.dataRef.current[bubbleKey]);
2823    });
2824    const isEventWithinOwnElements = useStableCallback((event) => {
2825      return isEventTargetWithin(event, store.select("floatingElement")) || isEventTargetWithin(event, store.select("domReferenceElement"));
2826    });
2827    const closeOnReferencePress = useStableCallback((event) => {
2828      if (!referencePress()) {
2829        return;
2830      }
2831      store.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerPress, event.nativeEvent));
2832    });
2833    const closeOnEscapeKeyDown = useStableCallback((event) => {
2834      if (!open2 || !enabled || !escapeKey2 || event.key !== "Escape") {
2835        return;
2836      }
2837      const native = isReactEvent(event) ? event.nativeEvent : event;
2838      if (isComposingRef.current || native.isComposing) {
2839        return;
2840      }
2841      if (!escapeKeyBubbles && hasBlockingChild("__escapeKeyBubbles")) {
2842        return;
2843      }
2844      const eventDetails = createChangeEventDetails(reason_parts_exports.escapeKey, native);
2845      store.setOpen(false, eventDetails);
2846      if (!eventDetails.isCanceled) {
2847        event.preventDefault();
2848      }
2849      if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) {
2850        event.stopPropagation();
2851      }
2852    });
2853    const markInsideReactTree = useStableCallback(() => {
2854      dataRef.current.insideReactTree = true;
2855      clearInsideReactTreeTimeout.start(0, clearInsideReactTree);
2856    });
2857    const markPressStartedInsideReactTree = useStableCallback((event) => {
2858      if (!open2 || !enabled || event.button !== 0) {
2859        return;
2860      }
2861      const target = getTarget(event.nativeEvent);
2862      if (!contains(store.select("floatingElement"), target)) {
2863        return;
2864      }
2865      if (!pressStartedInsideRef.current) {
2866        pressStartedInsideRef.current = true;
2867        pressStartPreventedRef.current = false;
2868      }
2869    });
2870    const markInsidePressStartPrevented = useStableCallback((event) => {
2871      if (!open2 || !enabled) {
2872        return;
2873      }
2874      if (!(event.defaultPrevented || event.nativeEvent.defaultPrevented)) {
2875        return;
2876      }
2877      if (pressStartedInsideRef.current) {
2878        pressStartPreventedRef.current = true;
2879      }
2880    });
2881    React17.useEffect(() => {
2882      function handleOpenChange(details) {
2883        if (!details.open) {
2884          sawPressWhileOpenRef.current = false;
2885        }
2886      }
2887      events.on("openchange", handleOpenChange);
2888      return () => {
2889        events.off("openchange", handleOpenChange);
2890      };
2891    }, [events]);
2892    React17.useEffect(() => clearInsideReactTree, [clearInsideReactTree]);
2893    React17.useEffect(() => {
2894      if (!open2 || !enabled) {
2895        if (!open2) {
2896          sawPressWhileOpenRef.current = false;
2897          isComposingRef.current = false;
2898          currentPointerTypeRef.current = "";
2899          touchStateRef.current = null;
2900        }
2901        return clearInsideReactTree;
2902      }
2903      dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
2904      dataRef.current.__outsidePressBubbles = outsidePressBubbles;
2905      const preventedPressSuppressionTimeout = new Timeout();
2906      const doc = ownerDocument(floatingElement);
2907      function handleCompositionStart() {
2908        compositionTimeout.clear();
2909        isComposingRef.current = true;
2910      }
2911      function handleCompositionEnd() {
2912        isComposingRef.current = true;
2913        compositionTimeout.start(
2914          // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
2915          // Only apply to WebKit for the test to remain 0ms.
2916          parts_exports.engine.webkit ? 5 : 0,
2917          () => {
2918            isComposingRef.current = false;
2919          }
2920        );
2921      }
2922      function suppressImmediateOutsideClickAfterPreventedStart() {
2923        suppressNextOutsideClickRef.current = true;
2924        preventedPressSuppressionTimeout.start(0, () => {
2925          suppressNextOutsideClickRef.current = false;
2926        });
2927      }
2928      function resetPressStartState() {
2929        pressStartedInsideRef.current = false;
2930        pressStartPreventedRef.current = false;
2931      }
2932      function getOutsidePressEvent() {
2933        const type = currentPointerTypeRef.current;
2934        const computedType = type === "pen" || !type ? "mouse" : type;
2935        const outsidePressEventValue = getOutsidePressEventProp();
2936        const resolved = typeof outsidePressEventValue === "function" ? outsidePressEventValue() : outsidePressEventValue;
2937        if (typeof resolved === "string") {
2938          return resolved;
2939        }
2940        return resolved[computedType];
2941      }
2942      function shouldIgnoreEvent(event) {
2943        const computedOutsidePressEvent = getOutsidePressEvent();
2944        return computedOutsidePressEvent === "intentional" && event.type !== "click" || computedOutsidePressEvent === "sloppy" && event.type === "click";
2945      }
2946      function isEventWithinFloatingTree(event) {
2947        const nodeId = dataRef.current.floatingContext?.nodeId;
2948        const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some((node) => isEventTargetWithin(event, node.context?.elements.floating));
2949        return isEventWithinOwnElements(event) || targetIsInsideChildren;
2950      }
2951      function closeOnPressOutside(event) {
2952        if (shouldIgnoreEvent(event)) {
2953          if (event.type !== "click" && !isEventWithinOwnElements(event)) {
2954            preventedPressSuppressionTimeout.clear();
2955            suppressNextOutsideClickRef.current = false;
2956          }
2957          clearInsideReactTree();
2958          return;
2959        }
2960        if (dataRef.current.insideReactTree) {
2961          clearInsideReactTree();
2962          return;
2963        }
2964        const target = getTarget(event);
2965        const inertSelector = `[$createAttribute("inert")}]`;
2966        const targetRoot = isElement(target) ? target.getRootNode() : null;
2967        const markers = Array.from((isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store.select("floatingElement"))).querySelectorAll(inertSelector));
2968        const triggers = store.context.triggerElements;
2969        if (target && (triggers.hasElement(target) || triggers.hasMatchingElement((trigger) => contains(trigger, target)))) {
2970          return;
2971        }
2972        let targetRootAncestor = isElement(target) ? target : null;
2973        while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
2974          const nextParent = getParentNode(targetRootAncestor);
2975          if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {
2976            break;
2977          }
2978          targetRootAncestor = nextParent;
2979        }
2980        if (markers.length && isElement(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
2981        !contains(target, store.select("floatingElement")) && // If the target root element contains none of the markers, then the
2982        // element was injected after the floating element rendered.
2983        markers.every((marker) => !contains(targetRootAncestor, marker))) {
2984          return;
2985        }
2986        if (isHTMLElement(target) && !("touches" in event)) {
2987          const lastTraversableNode = isLastTraversableNode(target);
2988          const style = getComputedStyle2(target);
2989          const scrollRe = /auto|scroll/;
2990          const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
2991          const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
2992          const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
2993          const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
2994          const isRTL3 = style.direction === "rtl";
2995          const pressedVerticalScrollbar = canScrollY && (isRTL3 ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
2996          const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
2997          if (pressedVerticalScrollbar || pressedHorizontalScrollbar) {
2998            return;
2999          }
3000        }
3001        if (isEventWithinFloatingTree(event)) {
3002          return;
3003        }
3004        if (getOutsidePressEvent() === "intentional") {
3005          if (event.detail !== 0 && !isVirtualClick(event) && !sawPressWhileOpenRef.current) {
3006            return;
3007          }
3008          if (suppressNextOutsideClickRef.current) {
3009            preventedPressSuppressionTimeout.clear();
3010            suppressNextOutsideClickRef.current = false;
3011            return;
3012          }
3013        }
3014        if (typeof outsidePress2 === "function" && !outsidePress2(event)) {
3015          return;
3016        }
3017        if (hasBlockingChild("__outsidePressBubbles")) {
3018          return;
3019        }
3020        store.setOpen(false, createChangeEventDetails(reason_parts_exports.outsidePress, event));
3021        clearInsideReactTree();
3022      }
3023      function handlePointerDown(event) {
3024        if (getOutsidePressEvent() !== "sloppy" || event.pointerType === "touch" || !store.select("open") || !enabled || isEventWithinOwnElements(event)) {
3025          return;
3026        }
3027        closeOnPressOutside(event);
3028      }
3029      function handleTouchStart(event) {
3030        if (getOutsidePressEvent() !== "sloppy" || !store.select("open") || !enabled || isEventWithinOwnElements(event)) {
3031          return;
3032        }
3033        const touch = event.touches[0];
3034        if (touch) {
3035          touchStateRef.current = {
3036            startTime: Date.now(),
3037            startX: touch.clientX,
3038            startY: touch.clientY,
3039            dismissOnTouchEnd: false,
3040            dismissOnMouseDown: true
3041          };
3042          cancelDismissOnEndTimeout.start(1e3, () => {
3043            if (touchStateRef.current) {
3044              touchStateRef.current.dismissOnTouchEnd = false;
3045              touchStateRef.current.dismissOnMouseDown = false;
3046            }
3047          });
3048        }
3049      }
3050      function addTargetEventListenerOnce(event, listener) {
3051        const target = getTarget(event);
3052        if (!target) {
3053          return;
3054        }
3055        const unsubscribe2 = addEventListener(target, event.type, () => {
3056          listener(event);
3057          unsubscribe2();
3058        });
3059      }
3060      function handleTouchStartCapture(event) {
3061        currentPointerTypeRef.current = "touch";
3062        addTargetEventListenerOnce(event, handleTouchStart);
3063      }
3064      function closeOnPressOutsideCapture(event) {
3065        cancelDismissOnEndTimeout.clear();
3066        if (event.type === "pointerdown") {
3067          if (event.button === 0) {
3068            sawPressWhileOpenRef.current = true;
3069          }
3070          currentPointerTypeRef.current = event.pointerType;
3071        }
3072        if (event.type === "mousedown" && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) {
3073          return;
3074        }
3075        addTargetEventListenerOnce(event, (targetEvent) => {
3076          if (targetEvent.type === "pointerdown") {
3077            handlePointerDown(targetEvent);
3078          } else {
3079            closeOnPressOutside(targetEvent);
3080          }
3081        });
3082      }
3083      function handlePressEndCapture(event) {
3084        if (event.type === "pointercancel") {
3085          sawPressWhileOpenRef.current = false;
3086        }
3087        if (!pressStartedInsideRef.current) {
3088          return;
3089        }
3090        const pressStartedInsideDefaultPrevented = pressStartPreventedRef.current;
3091        resetPressStartState();
3092        if (getOutsidePressEvent() !== "intentional") {
3093          return;
3094        }
3095        if (event.type === "pointercancel") {
3096          if (pressStartedInsideDefaultPrevented) {
3097            suppressImmediateOutsideClickAfterPreventedStart();
3098          }
3099          return;
3100        }
3101        if (isEventWithinFloatingTree(event)) {
3102          return;
3103        }
3104        if (pressStartedInsideDefaultPrevented) {
3105          suppressImmediateOutsideClickAfterPreventedStart();
3106          return;
3107        }
3108        if (typeof outsidePress2 === "function" && !outsidePress2(event)) {
3109          return;
3110        }
3111        preventedPressSuppressionTimeout.clear();
3112        suppressNextOutsideClickRef.current = true;
3113        clearInsideReactTree();
3114      }
3115      function handleTouchMove(event) {
3116        if (getOutsidePressEvent() !== "sloppy" || !touchStateRef.current || isEventWithinOwnElements(event)) {
3117          return;
3118        }
3119        const touch = event.touches[0];
3120        if (!touch) {
3121          return;
3122        }
3123        const deltaX = Math.abs(touch.clientX - touchStateRef.current.startX);
3124        const deltaY = Math.abs(touch.clientY - touchStateRef.current.startY);
3125        const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
3126        if (distance > 5) {
3127          touchStateRef.current.dismissOnTouchEnd = true;
3128        }
3129        if (distance > 10) {
3130          closeOnPressOutside(event);
3131          cancelDismissOnEndTimeout.clear();
3132          touchStateRef.current = null;
3133        }
3134      }
3135      function handleTouchMoveCapture(event) {
3136        addTargetEventListenerOnce(event, handleTouchMove);
3137      }
3138      function handleTouchEnd(event) {
3139        if (getOutsidePressEvent() !== "sloppy" || !touchStateRef.current || isEventWithinOwnElements(event)) {
3140          return;
3141        }
3142        if (touchStateRef.current.dismissOnTouchEnd) {
3143          closeOnPressOutside(event);
3144        }
3145        cancelDismissOnEndTimeout.clear();
3146        touchStateRef.current = null;
3147      }
3148      function handleTouchEndCapture(event) {
3149        addTargetEventListenerOnce(event, handleTouchEnd);
3150      }
3151      const unsubscribe = mergeCleanups(escapeKey2 && mergeCleanups(addEventListener(doc, "keydown", closeOnEscapeKeyDown), addEventListener(doc, "compositionstart", handleCompositionStart), addEventListener(doc, "compositionend", handleCompositionEnd)), outsidePressEnabled && mergeCleanups(addEventListener(doc, "click", closeOnPressOutsideCapture, true), addEventListener(doc, "pointerdown", closeOnPressOutsideCapture, true), addEventListener(doc, "pointerup", handlePressEndCapture, true), addEventListener(doc, "pointercancel", handlePressEndCapture, true), addEventListener(doc, "mousedown", closeOnPressOutsideCapture, true), addEventListener(doc, "mouseup", handlePressEndCapture, true), addEventListener(doc, "touchstart", handleTouchStartCapture, {
3152        capture: true,
3153        passive: true
3154      }), addEventListener(doc, "touchmove", handleTouchMoveCapture, {
3155        capture: true,
3156        passive: true
3157      }), addEventListener(doc, "touchend", handleTouchEndCapture, {
3158        capture: true,
3159        passive: true
3160      })));
3161      return () => {
3162        unsubscribe();
3163        preventedPressSuppressionTimeout.clear();
3164        resetPressStartState();
3165        suppressNextOutsideClickRef.current = false;
3166      };
3167    }, [dataRef, floatingElement, escapeKey2, outsidePressEnabled, outsidePress2, open2, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, hasBlockingChild, isEventWithinOwnElements, tree, store, cancelDismissOnEndTimeout, compositionTimeout]);
3168    const reference = React17.useMemo(() => ({
3169      onKeyDown: closeOnEscapeKeyDown,
3170      onPointerDown: closeOnReferencePress,
3171      onClick: closeOnReferencePress
3172    }), [closeOnEscapeKeyDown, closeOnReferencePress]);
3173    const floating = React17.useMemo(() => ({
3174      onKeyDown: closeOnEscapeKeyDown,
3175      // `onMouseDown` may be blocked if `event.preventDefault()` is called in
3176      // `onPointerDown`, such as with <NumberField.ScrubArea>.
3177      // See https://github.com/mui/base-ui/pull/3379
3178      onPointerDown: markInsidePressStartPrevented,
3179      onMouseDown: markInsidePressStartPrevented,
3180      onClickCapture: markInsideReactTree,
3181      onMouseDownCapture(event) {
3182        markInsideReactTree();
3183        markPressStartedInsideReactTree(event);
3184      },
3185      onPointerDownCapture(event) {
3186        markInsideReactTree();
3187        markPressStartedInsideReactTree(event);
3188      },
3189      onMouseUpCapture: markInsideReactTree,
3190      onTouchEndCapture: markInsideReactTree,
3191      onTouchMoveCapture: markInsideReactTree
3192    }), [closeOnEscapeKeyDown, markInsideReactTree, markPressStartedInsideReactTree, markInsidePressStartPrevented]);
3193    return React17.useMemo(() => enabled ? {
3194      reference,
3195      floating,
3196      trigger: reference
3197    } : {}, [enabled, reference, floating]);
3198  }
3199  
3200  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/popups/popupHandle.mjs
3201  var BasePopupHandle = class {
3202    /**
3203     * Stores of every root currently using this handle, in attach order. A handle is meant to be used
3204     * by a single mounted root, but roots can transiently overlap (e.g. during an animated route
3205     * transition), so this stack lets `attachStore`'s cleanup restore the previous root instead of
3206     * leaving a still-mounted root uncontrollable when a newer overlapping root detaches first.
3207     */
3208    attachedStores = [];
3209    /**
3210     * Store of the root that currently controls the handle: the most recently attached one still
3211     * mounted, or `null` when no root is attached. Imperative methods are no-ops while this is `null`.
3212     */
3213    attachedStoreValue = null;
3214    /**
3215     * Listeners notified when `attachedStore` changes, so detached triggers can follow the store pointer.
3216     */
3217    storeListeners = /* @__PURE__ */ new Set();
3218    /**
3219     * Creates a handle backed by the store used while no root is attached.
3220     *
3221     * @param fallbackStore Inert, closed store handed to detached triggers while no root is attached,
3222     * so they can render and register without a mounted root. Triggers register into whichever store
3223     * `store` currently resolves to, so while detached they live in this store's trigger map and
3224     * migrate themselves to the root's store (and back) as it attaches/detaches.
3225     * @param componentName Component name used to prefix dev warnings, e.g. `'Menu'` produces
3226     * `MenuHandle.open()` in warning text.
3227     * @param throwOnMissingTrigger Whether `open(triggerId)` throws when no trigger with that id is
3228     * registered. Anchored popups (Menu, Popover, Tooltip, PreviewCard) need a trigger to anchor to,
3229     * so they throw; Dialog is not anchored and instead opens unassociated with a dev warning.
3230     */
3231    constructor(fallbackStore, componentName, throwOnMissingTrigger = true) {
3232      this.fallbackStore = fallbackStore;
3233      this.componentName = componentName;
3234      this.throwOnMissingTrigger = throwOnMissingTrigger;
3235    }
3236    get attachedStore() {
3237      return this.attachedStoreValue;
3238    }
3239    /**
3240     * Store that detached triggers read from: the attached root's store, or an inert fallback store
3241     * used while no root is attached.
3242     * @internal
3243     */
3244    get store() {
3245      return this.attachedStoreValue ?? this.fallbackStore;
3246    }
3247    /**
3248     * Stable fallback store used for server rendering and hydration. Root stores cannot be recorded on
3249     * the handle during render because a handle can be shared by concurrent server-rendered requests.
3250     * @internal
3251     */
3252    get serverStore() {
3253      return this.fallbackStore;
3254    }
3255    /**
3256     * Subscribes to changes of the attached store pointer so detached triggers re-render and re-bind
3257     * when a root attaches or detaches. Returns a function that removes the listener.
3258     * @internal
3259     */
3260    subscribeStore(listener) {
3261      this.storeListeners.add(listener);
3262      return () => {
3263        this.storeListeners.delete(listener);
3264      };
3265    }
3266    /**
3267     * Points the handle at a root's store and notifies subscribers so detached triggers re-render and
3268     * re-register into it (their registration effect migrates them when the store pointer changes).
3269     * Returns a cleanup function that detaches the store again.
3270     * @internal
3271     */
3272    attachStore(newStore) {
3273      this.attachedStores.push(newStore);
3274      this.setActiveStore(newStore);
3275      if (true) {
3276        if (this.attachedStores.length > 1) {
3277          const dev = this;
3278          (dev.overlapWarningFrame ??= AnimationFrame.create()).request(() => {
3279            if (this.attachedStores.length > 1) {
3280              console.warn("Base UI: A handle is attached to more than one mounted root at the same time. The most recently mounted root takes over and the previous one stops being controlled by the handle. A handle should be used by a single root that stays mounted for the lifetime of the handle.");
3281            }
3282          });
3283        }
3284      }
3285      return () => {
3286        const index2 = this.attachedStores.lastIndexOf(newStore);
3287        if (index2 !== -1) {
3288          this.attachedStores.splice(index2, 1);
3289        }
3290        this.setActiveStore(this.attachedStores[this.attachedStores.length - 1] ?? null);
3291      };
3292    }
3293    /**
3294     * Sets the store that currently controls the handle and notifies subscribers when it changes, so
3295     * detached triggers re-render and migrate their registration to the new store.
3296     */
3297    setActiveStore(store) {
3298      if (this.attachedStoreValue !== store) {
3299        this.attachedStoreValue = store;
3300        this.storeListeners.forEach((listener) => {
3301          listener();
3302        });
3303      }
3304    }
3305    /**
3306     * Opens the attached root's store and associates it with the trigger with the given id, or a
3307     * no-op (with a dev warning) while no root is attached. Shared by every concrete handle's public
3308     * `open()` method, which only narrows the parameter type.
3309     *
3310     * When a trigger id is given but no matching trigger is registered, anchored popups throw (see
3311     * `throwOnMissingTrigger`); Dialog opens unassociated with a dev warning instead.
3312     *
3313     * This method should only be called in an event handler or an effect (not during rendering).
3314     *
3315     * @param triggerId ID of the trigger to associate with the popup, or `null`/`undefined` to open
3316     * without associating any trigger.
3317     */
3318    openByTrigger(triggerId) {
3319      const attachedStore = this.attachedStore;
3320      if (attachedStore === null) {
3321        if (true) {
3322          console.warn(`Base UI: $this.componentName}Handle.open() was called while no root using this handle is mounted. The call was ignored; mount a root with this handle before opening it imperatively.`);
3323        }
3324        return;
3325      }
3326      let triggerElement;
3327      if (triggerId) {
3328        for (let i = this.attachedStores.length - 1; i >= 0 && !triggerElement; i -= 1) {
3329          triggerElement = this.attachedStores[i].context.triggerElements.getById(triggerId);
3330        }
3331        triggerElement ??= this.fallbackStore.context.triggerElements.getById(triggerId);
3332      }
3333      if (triggerId && !triggerElement) {
3334        if (this.throwOnMissingTrigger) {
3335          throw new Error(true ? `Base UI: $this.componentName}Handle.open() was called with the trigger id "$triggerId}", but no matching trigger is registered with this handle. An anchored popup cannot open without a trigger to anchor to. Pass the id of a mounted $this.componentName}.Trigger that has this handle set on its "handle" prop.` : formatErrorMessage_default(99, this.componentName, triggerId, this.componentName));
3336        }
3337        if (true) {
3338          console.warn(`Base UI: $this.componentName}Handle.open: No trigger found with id "$triggerId}". The popup will open, but the trigger will not be associated with it.`);
3339        }
3340      }
3341      attachedStore.setOpen(true, createChangeEventDetails(reason_parts_exports.imperativeAction, void 0, triggerElement));
3342    }
3343    /**
3344     * Closes the popup by setting the attached root's store to closed, or a no-op (with a dev warning)
3345     * while no root is attached. Shared by every concrete handle's public `close()` method.
3346     *
3347     * This method should only be called in an event handler or an effect (not during rendering).
3348     */
3349    closePopup() {
3350      const attachedStore = this.attachedStore;
3351      if (attachedStore === null) {
3352        if (true) {
3353          console.warn(`Base UI: $this.componentName}Handle.close() was called while no root using this handle is mounted. The call was ignored.`);
3354        }
3355        return;
3356      }
3357      attachedStore.setOpen(false, createChangeEventDetails(reason_parts_exports.imperativeAction));
3358    }
3359  };
3360  
3361  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/popups/popupStoreUtils.mjs
3362  var React19 = __toESM(require_react(), 1);
3363  var ReactDOM3 = __toESM(require_react_dom(), 1);
3364  
3365  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useSyncedFloatingRootContext.mjs
3366  function useSyncedFloatingRootContext(options) {
3367    const {
3368      popupStore,
3369      treatPopupAsFloatingElement = false,
3370      floatingRootContext: store,
3371      floatingId,
3372      nested,
3373      onOpenChange
3374    } = options;
3375    const open2 = popupStore.useState("open");
3376    const referenceElement = popupStore.useState("activeTriggerElement");
3377    const floatingElement = popupStore.useState(treatPopupAsFloatingElement ? "popupElement" : "positionerElement");
3378    const handleOpenChange = onOpenChange;
3379    popupStore.useSyncedValue("floatingId", floatingId);
3380    useIsoLayoutEffect(() => {
3381      const valuesToSync = {
3382        open: open2,
3383        floatingId,
3384        referenceElement,
3385        floatingElement
3386      };
3387      if (isElement(referenceElement)) {
3388        valuesToSync.domReferenceElement = referenceElement;
3389      }
3390      if (store.state.positionReference === store.state.referenceElement) {
3391        valuesToSync.positionReference = referenceElement;
3392      }
3393      store.update(valuesToSync);
3394    }, [open2, floatingId, referenceElement, floatingElement, store]);
3395    store.context.onOpenChange = handleOpenChange;
3396    store.context.nested = nested;
3397    return store;
3398  }
3399  
3400  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useUnmountAfterClose.mjs
3401  var React18 = __toESM(require_react(), 1);
3402  function useUnmountAfterClose(parameters) {
3403    const {
3404      open: open2,
3405      ref,
3406      preventUnmountOnClose,
3407      setPreventUnmountOnClose: setPreventUnmountOnCloseParam,
3408      onUnmount,
3409      animateInitialOpen
3410    } = parameters;
3411    const setPreventUnmountOnClose = useStableCallback(setPreventUnmountOnCloseParam);
3412    const {
3413      mounted,
3414      setMounted,
3415      transitionStatus
3416    } = useTransitionStatus(open2, false, false, animateInitialOpen);
3417    const preventUnmountingOnClose = open2 ? false : preventUnmountOnClose;
3418    useIsoLayoutEffect(() => {
3419      if (open2) {
3420        setPreventUnmountOnClose(false);
3421      }
3422    }, [open2, setPreventUnmountOnClose]);
3423    const mountedRef = React18.useRef(mounted);
3424    const pendingUnmountRef = React18.useRef(false);
3425    const rerender = useForcedRerendering();
3426    const unmount = () => {
3427      mountedRef.current = false;
3428      setMounted(false);
3429      onUnmount();
3430    };
3431    useIsoLayoutEffect(() => {
3432      mountedRef.current = mounted;
3433      if (pendingUnmountRef.current) {
3434        pendingUnmountRef.current = false;
3435        if (!open2 && mounted) {
3436          unmount();
3437        }
3438      }
3439    });
3440    const forceUnmount = useStableCallback(() => {
3441      if (!mountedRef.current) {
3442        return;
3443      }
3444      if (open2) {
3445        pendingUnmountRef.current = true;
3446        rerender();
3447        return;
3448      }
3449      unmount();
3450    });
3451    useOpenChangeComplete({
3452      enabled: mounted && !open2 && !preventUnmountingOnClose,
3453      open: open2,
3454      ref,
3455      onComplete() {
3456        if (!open2) {
3457          forceUnmount();
3458        }
3459      }
3460    });
3461    return {
3462      mounted,
3463      transitionStatus,
3464      preventUnmountingOnClose,
3465      forceUnmount
3466    };
3467  }
3468  
3469  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/popups/popupStoreUtils.mjs
3470  var FOCUSABLE_POPUP_PROPS = {
3471    tabIndex: -1,
3472    [FOCUSABLE_ATTRIBUTE]: ""
3473  };
3474  function usePopupRootStore(createStore, treatPopupAsFloatingElement = false) {
3475    const floatingId = useId();
3476    const nested = useFloatingParentNodeId() != null;
3477    const store = useRefWithInit(() => createStore(floatingId, nested)).current;
3478    useSyncedFloatingRootContext({
3479      popupStore: store,
3480      treatPopupAsFloatingElement,
3481      floatingRootContext: store.state.floatingRootContext,
3482      floatingId,
3483      nested,
3484      onOpenChange: store.setOpen
3485    });
3486    return store;
3487  }
3488  function PopupHandleAttachment({
3489    handle,
3490    store
3491  }) {
3492    useIsoLayoutEffect(() => {
3493      return handle.attachStore(store);
3494    }, [handle, store]);
3495    return null;
3496  }
3497  function syncTriggerCount(store) {
3498    const triggerCount = store.context.triggerElements.size;
3499    if (store.select("open") && store.state.triggerCount !== triggerCount) {
3500      store.set("triggerCount", triggerCount);
3501    }
3502  }
3503  function useTriggerRegistration(id, store) {
3504    const registrationRef = React19.useRef(null);
3505    return useStableCallback((element) => {
3506      const registration = registrationRef.current;
3507      if (registration !== null) {
3508        if (registration.element === element && registration.store === store && registration.id === id) {
3509          return;
3510        }
3511        registrationRef.current = null;
3512        const registeredStore = registration.store;
3513        if (registeredStore.context.triggerElements.getById(registration.id) === registration.element) {
3514          registeredStore.context.triggerElements.delete(registration.id);
3515          syncTriggerCount(registeredStore);
3516        }
3517      }
3518      if (element !== null && id !== void 0) {
3519        registrationRef.current = {
3520          store,
3521          id,
3522          element
3523        };
3524        store.context.triggerElements.add(id, element);
3525        syncTriggerCount(store);
3526      }
3527    });
3528  }
3529  function createPopupOpenState(state, open2, trigger, preventUnmountOnClose = false) {
3530    let preventUnmountingOnClose = state.preventUnmountingOnClose;
3531    if (open2) {
3532      preventUnmountingOnClose = false;
3533    } else if (preventUnmountOnClose) {
3534      preventUnmountingOnClose = true;
3535    }
3536    const triggerId = trigger?.id ?? null;
3537    let activeTriggerId = state.activeTriggerId;
3538    let activeTriggerElement = state.activeTriggerElement;
3539    if (triggerId || open2) {
3540      activeTriggerId = triggerId;
3541      activeTriggerElement = trigger ?? null;
3542    }
3543    return {
3544      open: open2,
3545      preventUnmountingOnClose,
3546      activeTriggerId,
3547      activeTriggerElement,
3548      // An open request without a trigger (a handle's `open(null)` or `openWithPayload()`) must not
3549      // be reassociated with a lone registered trigger later on. Controlled and default opens never
3550      // pass through here, so they keep claiming a lone trigger. A close request keeps the flag: a
3551      // controlled root may decline it and stay open, so the Root clears the flag only once the
3552      // popup is effectively closed.
3553      openedWithoutTrigger: open2 ? trigger == null : state.openedWithoutTrigger
3554    };
3555  }
3556  function attachPreventUnmountOnClose(eventDetails) {
3557    let preventUnmountOnClose = false;
3558    eventDetails.preventUnmountOnClose = () => {
3559      preventUnmountOnClose = true;
3560    };
3561    return () => preventUnmountOnClose;
3562  }
3563  function applyPopupOpenChange(store, nextOpen, eventDetails, options = {}) {
3564    const reason = eventDetails.reason;
3565    const isHover = reason === reason_parts_exports.triggerHover;
3566    const isFocusOpen = nextOpen && reason === reason_parts_exports.triggerFocus;
3567    const isDismissClose = !nextOpen && (reason === reason_parts_exports.triggerPress || reason === reason_parts_exports.escapeKey);
3568    const shouldPreventUnmountOnClose = attachPreventUnmountOnClose(eventDetails);
3569    store.context.onOpenChange?.(nextOpen, eventDetails);
3570    if (eventDetails.isCanceled) {
3571      return;
3572    }
3573    options.onBeforeDispatch?.();
3574    store.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
3575    const changeState = () => {
3576      const popupOpenState = createPopupOpenState(store.state, nextOpen, eventDetails.trigger, shouldPreventUnmountOnClose());
3577      const updatedState = {
3578        ...options.extraState,
3579        ...popupOpenState
3580      };
3581      if (isFocusOpen) {
3582        updatedState.instantType = "focus";
3583      } else if (isDismissClose) {
3584        updatedState.instantType = "dismiss";
3585      } else if (isHover) {
3586        updatedState.instantType = void 0;
3587      }
3588      store.update(updatedState);
3589    };
3590    if (isHover) {
3591      ReactDOM3.flushSync(changeState);
3592    } else {
3593      changeState();
3594    }
3595  }
3596  function useTriggerDataForwarding(triggerId, triggerElementRef, store, stateUpdates) {
3597    const isMountedByThisTrigger = store.useState("isMountedByTrigger", triggerId);
3598    const baseRegisterTrigger = useTriggerRegistration(triggerId, store);
3599    const applyTriggerData = useStableCallback((element) => {
3600      const open2 = store.select("open");
3601      const activeTriggerId = store.select("activeTriggerId");
3602      if (activeTriggerId === triggerId) {
3603        const changes = {
3604          activeTriggerElement: element,
3605          ...open2 ? stateUpdates : null
3606        };
3607        store.update(changes);
3608        return;
3609      }
3610      if (activeTriggerId == null && open2 && !store.state.openedWithoutTrigger) {
3611        const changes = {
3612          activeTriggerId: triggerId ?? null,
3613          activeTriggerElement: element,
3614          ...stateUpdates
3615        };
3616        store.update(changes);
3617      }
3618    });
3619    const registerTrigger = useStableCallback((element) => {
3620      baseRegisterTrigger(element);
3621      if (element) {
3622        applyTriggerData(element);
3623      }
3624    });
3625    useIsoLayoutEffect(() => {
3626      registerTrigger(triggerElementRef.current);
3627      return () => registerTrigger(null);
3628    }, [registerTrigger, triggerElementRef, store, triggerId]);
3629    useIsoLayoutEffect(() => {
3630      if (isMountedByThisTrigger) {
3631        const changes = {
3632          activeTriggerElement: triggerElementRef.current,
3633          ...stateUpdates
3634        };
3635        store.update(changes);
3636      }
3637    }, [isMountedByThisTrigger, store, triggerElementRef, ...Object.values(stateUpdates)]);
3638    return {
3639      registerTrigger,
3640      isMountedByThisTrigger
3641    };
3642  }
3643  function useImplicitActiveTrigger(store, options = {}) {
3644    const {
3645      closeOnActiveTriggerUnmount = false
3646    } = options;
3647    const resolvedActiveTriggerIdRef = React19.useRef(null);
3648    const open2 = store.useState("open");
3649    const reactiveTriggerCount = store.useState("triggerCount");
3650    const activeTriggerId = store.useState("activeTriggerId");
3651    const reactiveActiveTriggerElement = store.useState("activeTriggerElement");
3652    useIsoLayoutEffect(() => {
3653      if (!open2) {
3654        resolvedActiveTriggerIdRef.current = null;
3655        if (store.state.triggerCount !== 0) {
3656          store.set("triggerCount", 0);
3657        }
3658        if (store.state.openedWithoutTrigger) {
3659          store.set("openedWithoutTrigger", false);
3660        }
3661        return;
3662      }
3663      const triggerCount = store.context.triggerElements.size;
3664      const stateUpdates = {};
3665      if (store.state.triggerCount !== triggerCount) {
3666        stateUpdates.triggerCount = triggerCount;
3667      }
3668      const currentActiveTriggerId = store.select("activeTriggerId");
3669      let lostActiveTriggerId = null;
3670      if (currentActiveTriggerId) {
3671        const activeTriggerElement = store.context.triggerElements.getById(currentActiveTriggerId);
3672        if (!activeTriggerElement) {
3673          for (const [triggerId, triggerElement] of store.context.triggerElements.entries()) {
3674            if (triggerElement === store.state.activeTriggerElement) {
3675              stateUpdates.activeTriggerId = triggerId;
3676              stateUpdates.activeTriggerElement = triggerElement;
3677              resolvedActiveTriggerIdRef.current = triggerId;
3678              break;
3679            }
3680          }
3681          if (stateUpdates.activeTriggerId === void 0) {
3682            if (resolvedActiveTriggerIdRef.current === currentActiveTriggerId) {
3683              lostActiveTriggerId = currentActiveTriggerId;
3684            } else {
3685              resolvedActiveTriggerIdRef.current = null;
3686            }
3687          }
3688        } else {
3689          resolvedActiveTriggerIdRef.current = currentActiveTriggerId;
3690          if (activeTriggerElement !== store.state.activeTriggerElement) {
3691            stateUpdates.activeTriggerElement = activeTriggerElement;
3692          }
3693        }
3694      } else {
3695        resolvedActiveTriggerIdRef.current = null;
3696      }
3697      if (!lostActiveTriggerId && !currentActiveTriggerId && !store.state.openedWithoutTrigger && triggerCount === 1) {
3698        const iteratorResult = store.context.triggerElements.entries().next();
3699        if (!iteratorResult.done) {
3700          const [implicitTriggerId, implicitTriggerElement] = iteratorResult.value;
3701          stateUpdates.activeTriggerId = implicitTriggerId;
3702          stateUpdates.activeTriggerElement = implicitTriggerElement;
3703          resolvedActiveTriggerIdRef.current = implicitTriggerId;
3704        }
3705      }
3706      if (stateUpdates.triggerCount !== void 0 || stateUpdates.activeTriggerId !== void 0 || stateUpdates.activeTriggerElement !== void 0) {
3707        store.update(stateUpdates);
3708      }
3709      if (lostActiveTriggerId) {
3710        if (closeOnActiveTriggerUnmount) {
3711          queueMicrotask(() => {
3712            if (store.select("open") && store.select("activeTriggerId") === lostActiveTriggerId && !store.context.triggerElements.getById(lostActiveTriggerId)) {
3713              const eventDetails = createChangeEventDetails(reason_parts_exports.none);
3714              store.setOpen(false, eventDetails);
3715              if (!eventDetails.isCanceled) {
3716                store.update({
3717                  activeTriggerId: null,
3718                  activeTriggerElement: null
3719                });
3720              }
3721            }
3722          });
3723        }
3724      }
3725    }, [open2, store, reactiveTriggerCount, activeTriggerId, reactiveActiveTriggerElement, closeOnActiveTriggerUnmount]);
3726  }
3727  function useOpenStateTransitions(open2, store, onUnmount, animateInitialOpen) {
3728    const {
3729      mounted,
3730      transitionStatus,
3731      forceUnmount
3732    } = useUnmountAfterClose({
3733      open: open2,
3734      ref: store.context.popupRef,
3735      preventUnmountOnClose: store.useState("preventUnmountingOnClose"),
3736      setPreventUnmountOnClose: (preventUnmountOnClose) => store.set("preventUnmountingOnClose", preventUnmountOnClose),
3737      animateInitialOpen,
3738      onUnmount() {
3739        store.update({
3740          activeTriggerId: null,
3741          activeTriggerElement: null,
3742          mounted: false,
3743          preventUnmountingOnClose: false
3744        });
3745        onUnmount?.();
3746        store.context.onOpenChangeComplete?.(false);
3747      }
3748    });
3749    useRefWithInit(() => {
3750      store.set("mounted", mounted);
3751      return null;
3752    });
3753    store.useSyncedValues({
3754      mounted,
3755      transitionStatus
3756    });
3757    return {
3758      forceUnmount,
3759      transitionStatus
3760    };
3761  }
3762  function usePopupInteractionProps(store, statePart) {
3763    store.useSyncedValues(statePart);
3764    useIsoLayoutEffect(() => () => {
3765      store.update({
3766        activeTriggerProps: EMPTY_OBJECT,
3767        inactiveTriggerProps: EMPTY_OBJECT,
3768        popupProps: EMPTY_OBJECT
3769      });
3770    }, [store]);
3771  }
3772  
3773  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/popups/popupTriggerMap.mjs
3774  var devElementIdsByMap;
3775  function getDevElementIds(map) {
3776    devElementIdsByMap ??= /* @__PURE__ */ new WeakMap();
3777    let elementIds = devElementIdsByMap.get(map);
3778    if (!elementIds) {
3779      elementIds = /* @__PURE__ */ new WeakMap();
3780      devElementIdsByMap.set(map, elementIds);
3781    }
3782    return elementIds;
3783  }
3784  var PopupTriggerMap = class {
3785    idMap = /* @__PURE__ */ new Map();
3786    /**
3787     * Adds a trigger element with the given ID.
3788     *
3789     * Note: The provided element is assumed to not be registered under multiple IDs.
3790     */
3791    add(id, element) {
3792      if (true) {
3793        const elementIds = getDevElementIds(this);
3794        const existingId = elementIds.get(element);
3795        if (existingId !== void 0 && existingId !== id) {
3796          throw new Error("Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.");
3797        }
3798        const previousElement = this.idMap.get(id);
3799        if (previousElement !== void 0 && previousElement !== element) {
3800          elementIds.delete(previousElement);
3801        }
3802        elementIds.set(element, id);
3803      }
3804      this.idMap.set(id, element);
3805    }
3806    /**
3807     * Removes the trigger element with the given ID.
3808     */
3809    delete(id) {
3810      if (true) {
3811        const element = this.idMap.get(id);
3812        if (element !== void 0) {
3813          devElementIdsByMap?.get(this)?.delete(element);
3814        }
3815      }
3816      this.idMap.delete(id);
3817    }
3818    /**
3819     * Whether the given element is registered as a trigger.
3820     */
3821    hasElement(element) {
3822      for (const registered of this.idMap.values()) {
3823        if (registered === element) {
3824          return true;
3825        }
3826      }
3827      return false;
3828    }
3829    /**
3830     * Whether there is a registered trigger element matching the given predicate.
3831     */
3832    hasMatchingElement(predicate) {
3833      for (const element of this.idMap.values()) {
3834        if (predicate(element)) {
3835          return true;
3836        }
3837      }
3838      return false;
3839    }
3840    /**
3841     * Returns the trigger element associated with the given ID, or undefined if no such element exists.
3842     */
3843    getById(id) {
3844      return this.idMap.get(id);
3845    }
3846    /**
3847     * Returns an iterable of all registered trigger entries, where each entry is a tuple of [id, element].
3848     */
3849    entries() {
3850      return this.idMap.entries();
3851    }
3852    /**
3853     * Returns an iterable of all registered trigger elements.
3854     */
3855    elements() {
3856      return this.idMap.values();
3857    }
3858    /**
3859     * Returns the number of registered trigger elements.
3860     */
3861    get size() {
3862      return this.idMap.size;
3863    }
3864  };
3865  
3866  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/store/useStore.mjs
3867  var React21 = __toESM(require_react(), 1);
3868  var import_shim = __toESM(require_shim(), 1);
3869  var import_with_selector = __toESM(require_with_selector(), 1);
3870  
3871  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/fastHooks.mjs
3872  var React20 = __toESM(require_react(), 1);
3873  var hooks = [];
3874  var currentInstance = void 0;
3875  function getInstance() {
3876    return currentInstance;
3877  }
3878  function register(hook) {
3879    hooks.push(hook);
3880  }
3881  function fastComponent(fn) {
3882    const FastComponent = (props, forwardedRef) => {
3883      const instance = useRefWithInit(createInstance).current;
3884      let result;
3885      try {
3886        currentInstance = instance;
3887        for (const hook of hooks) {
3888          hook.before(instance);
3889        }
3890        result = fn(props, forwardedRef);
3891        for (const hook of hooks) {
3892          hook.after(instance);
3893        }
3894        instance.didInitialize = true;
3895      } finally {
3896        currentInstance = void 0;
3897      }
3898      return result;
3899    };
3900    FastComponent.displayName = fn.displayName || fn.name;
3901    return FastComponent;
3902  }
3903  function fastComponentRef(fn) {
3904    return /* @__PURE__ */ React20.forwardRef(fastComponent(fn));
3905  }
3906  function createInstance() {
3907    return {
3908      didInitialize: false
3909    };
3910  }
3911  
3912  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/store/useStore.mjs
3913  var canUseRawUseSyncExternalStore = isReactVersionAtLeast(19);
3914  var useStoreImplementation = canUseRawUseSyncExternalStore ? useStoreFast : useStoreLegacy;
3915  function useStore(store, selector, a1, a2, a3) {
3916    return useStoreImplementation(store, selector, a1, a2, a3);
3917  }
3918  function useStoreR19(store, selector, a1, a2, a3) {
3919    const getSelection = React21.useCallback(() => selector(store.getSnapshot(), a1, a2, a3), [store, selector, a1, a2, a3]);
3920    return (0, import_shim.useSyncExternalStore)(store.subscribe, getSelection, getSelection);
3921  }
3922  register({
3923    before(instance) {
3924      instance.syncIndex = 0;
3925      if (!instance.didInitialize) {
3926        instance.syncTick = 1;
3927        instance.syncHooks = [];
3928        instance.didChangeStore = true;
3929        instance.getSnapshot = () => {
3930          let didChange2 = false;
3931          for (let i = 0; i < instance.syncHooks.length; i += 1) {
3932            const hook = instance.syncHooks[i];
3933            const value = hook.selector(hook.store.state, hook.a1, hook.a2, hook.a3);
3934            if (!Object.is(hook.value, value)) {
3935              didChange2 = true;
3936              hook.value = value;
3937            }
3938          }
3939          if (didChange2) {
3940            instance.syncTick += 1;
3941          }
3942          return instance.syncTick;
3943        };
3944      }
3945    },
3946    after(instance) {
3947      if (instance.syncHooks.length > 0) {
3948        if (instance.didChangeStore) {
3949          instance.didChangeStore = false;
3950          instance.subscribe = (onStoreChange) => {
3951            const stores = /* @__PURE__ */ new Set();
3952            for (const hook of instance.syncHooks) {
3953              stores.add(hook.store);
3954            }
3955            const unsubscribes = [];
3956            for (const store of stores) {
3957              unsubscribes.push(store.subscribe(onStoreChange));
3958            }
3959            return () => {
3960              for (const unsubscribe of unsubscribes) {
3961                unsubscribe();
3962              }
3963            };
3964          };
3965        }
3966        (0, import_shim.useSyncExternalStore)(instance.subscribe, instance.getSnapshot, instance.getSnapshot);
3967      }
3968    }
3969  });
3970  function useStoreFast(store, selector, a1, a2, a3) {
3971    const instance = getInstance();
3972    if (!instance) {
3973      return useStoreR19(store, selector, a1, a2, a3);
3974    }
3975    const index2 = instance.syncIndex;
3976    instance.syncIndex += 1;
3977    let hook;
3978    if (!instance.didInitialize) {
3979      hook = {
3980        store,
3981        selector,
3982        a1,
3983        a2,
3984        a3,
3985        value: selector(store.getSnapshot(), a1, a2, a3)
3986      };
3987      instance.syncHooks.push(hook);
3988    } else {
3989      hook = instance.syncHooks[index2];
3990      if (hook.store !== store || hook.selector !== selector || !Object.is(hook.a1, a1) || !Object.is(hook.a2, a2) || !Object.is(hook.a3, a3)) {
3991        if (hook.store !== store) {
3992          instance.didChangeStore = true;
3993        }
3994        hook.store = store;
3995        hook.selector = selector;
3996        hook.a1 = a1;
3997        hook.a2 = a2;
3998        hook.a3 = a3;
3999        hook.value = selector(store.getSnapshot(), a1, a2, a3);
4000      }
4001    }
4002    return hook.value;
4003  }
4004  function useStoreLegacy(store, selector, a1, a2, a3) {
4005    return (0, import_with_selector.useSyncExternalStoreWithSelector)(store.subscribe, store.getSnapshot, store.getSnapshot, (state) => selector(state, a1, a2, a3));
4006  }
4007  
4008  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/store/Store.mjs
4009  var Store = class {
4010    /**
4011     * Creates a store with the given initial state, constructing the class it is called on.
4012     * Calling it on a generic base class (e.g. `ReactStore.create(...)`) constructs that
4013     * class but degrades the inferred instance type to `Store`; use `new` there instead.
4014     */
4015    static create(state) {
4016      return new this(state);
4017    }
4018    /**
4019     * The current state of the store.
4020     * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
4021     * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
4022     * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
4023     *
4024     * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
4025     */
4026    // Internal state to handle recursive `setState()` calls
4027    constructor(state) {
4028      this.state = state;
4029      this.listeners = /* @__PURE__ */ new Set();
4030      this.updateTick = 0;
4031    }
4032    /**
4033     * Registers a listener that will be called whenever the store's state changes.
4034     *
4035     * @param fn The listener function to be called on state changes.
4036     * @returns A function to unsubscribe the listener.
4037     */
4038    subscribe = (fn) => {
4039      this.listeners.add(fn);
4040      return () => {
4041        this.listeners.delete(fn);
4042      };
4043    };
4044    /**
4045     * Returns the current state of the store.
4046     */
4047    getSnapshot = () => {
4048      return this.state;
4049    };
4050    /**
4051     * Updates the entire store's state and notifies all registered listeners.
4052     *
4053     * @param newState The new state to set for the store.
4054     */
4055    setState(newState) {
4056      if (this.state === newState) {
4057        return;
4058      }
4059      this.state = newState;
4060      this.updateTick += 1;
4061      const currentTick = this.updateTick;
4062      for (const listener of this.listeners) {
4063        if (currentTick !== this.updateTick) {
4064          return;
4065        }
4066        listener(newState);
4067      }
4068    }
4069    /**
4070     * Merges the provided changes into the current state and notifies listeners if there are changes.
4071     * Each value must match its state key. Pass an exact known subset rather than a broad
4072     * `Partial<State>`, which may contain `undefined` for required state fields.
4073     *
4074     * @param changes An object containing the changes to apply to the current state.
4075     */
4076    update(changes) {
4077      for (const key in changes) {
4078        if (!Object.is(this.state[key], changes[key])) {
4079          this.setState({
4080            ...this.state,
4081            ...changes
4082          });
4083          return;
4084        }
4085      }
4086    }
4087    /**
4088     * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
4089     *
4090     * @param key The key in the store's state to update.
4091     * @param value The new value to set for the specified key.
4092     */
4093    set(key, value) {
4094      if (!Object.is(this.state[key], value)) {
4095        this.setState({
4096          ...this.state,
4097          [key]: value
4098        });
4099      }
4100    }
4101    /**
4102     * Gives the state a new reference and updates all registered listeners.
4103     */
4104    notifyAll() {
4105      const newState = {
4106        ...this.state
4107      };
4108      this.setState(newState);
4109    }
4110    use(selector, a1, a2, a3) {
4111      return useStore(this, selector, a1, a2, a3);
4112    }
4113  };
4114  
4115  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/store/ReactStore.mjs
4116  var React22 = __toESM(require_react(), 1);
4117  var ReactStore = class extends Store {
4118    /**
4119     * Creates a new ReactStore instance.
4120     *
4121     * @param state Initial state of the store.
4122     * @param context Non-reactive context values.
4123     * @param selectors Optional selectors for use with `useState`.
4124     */
4125    constructor(state, context = {}, selectors3) {
4126      super(state);
4127      this.context = context;
4128      this.selectors = selectors3;
4129    }
4130    /**
4131     * Non-reactive values such as refs, callbacks, etc.
4132     */
4133    /**
4134     * Synchronizes a single external value into the store.
4135     *
4136     * Note that the while the value in `state` is updated immediately, the value returned
4137     * by `useState` is updated before the next render (similarly to React's `useState`).
4138     */
4139    useSyncedValue(key, value) {
4140      React22.useDebugValue(key);
4141      const store = this;
4142      useIsoLayoutEffect(() => {
4143        if (store.state[key] !== value) {
4144          store.set(key, value);
4145        }
4146      }, [store, key, value]);
4147    }
4148    /**
4149     * Synchronizes a single external value into the store and
4150     * cleans it up (sets to `undefined`) on unmount.
4151     *
4152     * Note that the while the value in `state` is updated immediately, the value returned
4153     * by `useState` is updated before the next render (similarly to React's `useState`).
4154     */
4155    useSyncedValueWithCleanup(key, value) {
4156      const store = this;
4157      useIsoLayoutEffect(() => {
4158        if (store.state[key] !== value) {
4159          store.set(key, value);
4160        }
4161        return () => {
4162          store.set(key, void 0);
4163        };
4164      }, [store, key, value]);
4165    }
4166    /**
4167     * Synchronizes multiple external values into the store.
4168     * Each value must match its state key. Pass an exact known subset rather than a broad
4169     * `Partial<State>`, which may contain `undefined` for required state fields.
4170     *
4171     * Note that the while the values in `state` are updated immediately, the values returned
4172     * by `useState` are updated before the next render (similarly to React's `useState`).
4173     *
4174     * @param statePart An exact subset of state fields to synchronize. Unknown keys are not accepted.
4175     */
4176    useSyncedValues(statePart) {
4177      const store = this;
4178      if (true) {
4179        React22.useDebugValue(statePart, (p) => Object.keys(p));
4180        const keys = React22.useRef(Object.keys(statePart)).current;
4181        const nextKeys = Object.keys(statePart);
4182        if (keys.length !== nextKeys.length || keys.some((key, index2) => key !== nextKeys[index2])) {
4183          console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
4184        }
4185      }
4186      const dependencies = Object.values(statePart);
4187      useIsoLayoutEffect(() => {
4188        store.update(statePart);
4189      }, [store, ...dependencies]);
4190    }
4191    /**
4192     * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
4193     * is non-undefined, the store's state at `key` is updated to match `controlled`.
4194     */
4195    useControlledProp(key, controlled) {
4196      React22.useDebugValue(key);
4197      const store = this;
4198      const isControlled = controlled !== void 0;
4199      useIsoLayoutEffect(() => {
4200        if (isControlled && !Object.is(store.state[key], controlled)) {
4201          store.setState({
4202            ...store.state,
4203            [key]: controlled
4204          });
4205        }
4206      }, [store, key, controlled, isControlled]);
4207      if (true) {
4208        const cache = this.controlledValues ??= /* @__PURE__ */ new Map();
4209        if (!cache.has(key)) {
4210          cache.set(key, isControlled);
4211        }
4212        const previouslyControlled = cache.get(key);
4213        if (previouslyControlled !== void 0 && previouslyControlled !== isControlled) {
4214          console.error(`A component is changing the $previouslyControlled ? "" : "un"}controlled state of $key.toString()} to be $previouslyControlled ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
4215        }
4216      }
4217    }
4218    /** Gets the current value from the store using a selector with the provided key.
4219     *
4220     * @param key Key of the selector to use.
4221     */
4222    select(key, a1, a2, a3) {
4223      const selector = this.selectors[key];
4224      return selector(this.state, a1, a2, a3);
4225    }
4226    /**
4227     * Returns a value from the store's state using a selector function.
4228     * Used to subscribe to specific parts of the state.
4229     * This methods causes a rerender whenever the selected state changes.
4230     *
4231     * @param key Key of the selector to use.
4232     */
4233    useState(key, a1, a2, a3) {
4234      React22.useDebugValue(key);
4235      return useStore(this, this.selectors[key], a1, a2, a3);
4236    }
4237    /**
4238     * Wraps a function with `useStableCallback` to ensure it has a stable reference
4239     * and assigns it to the context.
4240     *
4241     * @param key Key of the event callback. Must be a function in the context.
4242     * @param fn Function to assign.
4243     */
4244    useContextCallback(key, fn) {
4245      React22.useDebugValue(key);
4246      const stableFunction = useStableCallback(fn ?? NOOP);
4247      this.context[key] = stableFunction;
4248    }
4249    /**
4250     * Returns a stable setter function for a specific key in the store's state.
4251     * It's commonly used to pass as a ref callback to React elements.
4252     *
4253     * @param key Key of the state to set.
4254     */
4255    useStateSetter(key) {
4256      const ref = React22.useRef(void 0);
4257      if (ref.current === void 0) {
4258        ref.current = (value) => {
4259          this.set(key, value);
4260        };
4261      }
4262      return ref.current;
4263    }
4264    /**
4265     * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
4266     *
4267     * @param key Key of the selector to observe.
4268     * @param listener Listener function called when the selector result changes.
4269     */
4270    observe(selector, listener) {
4271      let selectFn;
4272      if (typeof selector === "function") {
4273        selectFn = selector;
4274      } else {
4275        selectFn = this.selectors[selector];
4276      }
4277      let prevValue = selectFn(this.state);
4278      listener(prevValue, prevValue, this);
4279      return this.subscribe((nextState) => {
4280        const nextValue = selectFn(nextState);
4281        if (!Object.is(prevValue, nextValue)) {
4282          const oldValue = prevValue;
4283          prevValue = nextValue;
4284          listener(nextValue, oldValue, this);
4285        }
4286      });
4287    }
4288  };
4289  
4290  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/components/FloatingRootStore.mjs
4291  var selectors = {
4292    open: (state) => state.open,
4293    transitionStatus: (state) => state.transitionStatus,
4294    domReferenceElement: (state) => state.domReferenceElement,
4295    referenceElement: (state) => state.positionReference ?? state.referenceElement,
4296    floatingElement: (state) => state.floatingElement,
4297    floatingId: (state) => state.floatingId
4298  };
4299  var FloatingRootStore = class extends ReactStore {
4300    constructor(options) {
4301      const {
4302        syncOnly,
4303        nested,
4304        onOpenChange,
4305        triggerElements,
4306        ...initialState
4307      } = options;
4308      super({
4309        ...initialState,
4310        positionReference: initialState.referenceElement,
4311        domReferenceElement: initialState.referenceElement
4312      }, {
4313        onOpenChange,
4314        dataRef: {
4315          current: {}
4316        },
4317        events: createEventEmitter(),
4318        nested,
4319        triggerElements
4320      }, selectors);
4321      this.syncOnly = syncOnly;
4322    }
4323    /**
4324     * Syncs the event used by hover logic to distinguish hover-open from click-like interaction.
4325     */
4326    syncOpenEvent = (newOpen, event) => {
4327      if (!newOpen || !this.state.open || // Prevent a pending hover-open from overwriting a click-open event, while allowing
4328      // click events to upgrade a hover-open.
4329      event != null && isClickLikeEvent(event)) {
4330        this.context.dataRef.current.openEvent = newOpen ? event : void 0;
4331      }
4332    };
4333    /**
4334     * Runs the root-owned side effects for an open state change.
4335     */
4336    dispatchOpenChange = (newOpen, eventDetails) => {
4337      this.syncOpenEvent(newOpen, eventDetails.event);
4338      const details = {
4339        open: newOpen,
4340        reason: eventDetails.reason,
4341        nativeEvent: eventDetails.event,
4342        nested: this.context.nested,
4343        triggerElement: eventDetails.trigger
4344      };
4345      this.context.events.emit("openchange", details);
4346    };
4347    /**
4348     * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
4349     *
4350     * @param newOpen The new open state.
4351     * @param eventDetails Details about the event that triggered the open state change.
4352     */
4353    setOpen = (newOpen, eventDetails) => {
4354      if (this.syncOnly) {
4355        this.context.onOpenChange?.(newOpen, eventDetails);
4356        return;
4357      }
4358      this.dispatchOpenChange(newOpen, eventDetails);
4359      this.context.onOpenChange?.(newOpen, eventDetails);
4360    };
4361  };
4362  
4363  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/popups/store.mjs
4364  function createInitialPopupStoreState(triggerElements, floatingId, nested = false) {
4365    return {
4366      open: false,
4367      openProp: void 0,
4368      mounted: false,
4369      transitionStatus: void 0,
4370      floatingRootContext: new FloatingRootStore({
4371        open: false,
4372        transitionStatus: void 0,
4373        floatingElement: null,
4374        referenceElement: null,
4375        triggerElements,
4376        floatingId,
4377        syncOnly: true,
4378        nested,
4379        onOpenChange: void 0
4380      }),
4381      floatingId,
4382      triggerCount: 0,
4383      preventUnmountingOnClose: false,
4384      payload: void 0,
4385      activeTriggerId: null,
4386      activeTriggerElement: null,
4387      openedWithoutTrigger: false,
4388      triggerIdProp: void 0,
4389      popupElement: null,
4390      positionerElement: null,
4391      activeTriggerProps: EMPTY_OBJECT,
4392      inactiveTriggerProps: EMPTY_OBJECT,
4393      popupProps: EMPTY_OBJECT
4394    };
4395  }
4396  var activeTriggerIdSelector = (state) => state.triggerIdProp ?? state.activeTriggerId;
4397  var openSelector = (state) => state.openProp ?? state.open;
4398  var popupIdSelector = (state) => {
4399    const popupId = state.popupElement?.id ?? state.floatingId;
4400    return popupId || void 0;
4401  };
4402  function triggerOwnsOpenPopup(state, triggerId) {
4403    return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) === triggerId;
4404  }
4405  function triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) {
4406    if (triggerOwnsOpenPopup(state, triggerId)) {
4407      return true;
4408    }
4409    return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) == null && !state.openedWithoutTrigger && state.triggerCount === 1;
4410  }
4411  var popupStoreSelectors = {
4412    open: openSelector,
4413    mounted: (state) => state.mounted,
4414    // `open` is written synchronously on an open change; `mounted`/`transitionStatus` sync in a
4415    // layout effect. Match useTransitionStatus so a retained popup does not miss its starting phase.
4416    transitionStatus: (state) => openSelector(state) && !state.mounted ? "starting" : state.transitionStatus,
4417    floatingRootContext: (state) => state.floatingRootContext,
4418    triggerCount: (state) => state.triggerCount,
4419    preventUnmountingOnClose: (state) => state.preventUnmountingOnClose,
4420    payload: (state) => state.payload,
4421    activeTriggerId: activeTriggerIdSelector,
4422    activeTriggerElement: (state) => state.mounted ? state.activeTriggerElement : null,
4423    popupId: popupIdSelector,
4424    /**
4425     * Whether the trigger with the given ID was used to open the popup.
4426     */
4427    isTriggerActive: (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId,
4428    /**
4429     * Whether the popup is open and was activated by a trigger with the given ID.
4430     */
4431    isOpenedByTrigger: (state, triggerId) => triggerOwnsOpenPopup(state, triggerId),
4432    /**
4433     * Whether the popup is mounted and was activated by a trigger with the given ID.
4434     */
4435    isMountedByTrigger: (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId && state.mounted,
4436    triggerProps: (state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps,
4437    /**
4438     * Popup id for the trigger that currently owns the open popup.
4439     */
4440    triggerPopupId: (state, triggerId) => triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : void 0,
4441    popupProps: (state) => state.popupProps,
4442    popupElement: (state) => state.popupElement,
4443    positionerElement: (state) => state.positionerElement
4444  };
4445  
4446  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/popups/usePopupHandleStore.mjs
4447  var React23 = __toESM(require_react(), 1);
4448  var import_shim2 = __toESM(require_shim(), 1);
4449  function usePopupHandleStore(handle) {
4450    const subscribe = React23.useCallback((listener) => {
4451      if (handle === void 0) {
4452        return NOOP;
4453      }
4454      return handle.subscribeStore(listener);
4455    }, [handle]);
4456    const getSnapshot = React23.useCallback(() => {
4457      return handle === void 0 ? void 0 : handle.store;
4458    }, [handle]);
4459    return (0, import_shim2.useSyncExternalStore)(subscribe, getSnapshot, () => handle?.serverStore);
4460  }
4461  
4462  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useFocus.mjs
4463  var React24 = __toESM(require_react(), 1);
4464  var isMacSafari = parts_exports.os.mac && parts_exports.engine.webkit;
4465  function useFocus(store, props = {}) {
4466    const {
4467      enabled = true,
4468      delay
4469    } = props;
4470    const {
4471      events,
4472      dataRef
4473    } = store.context;
4474    const blockFocusRef = React24.useRef(false);
4475    const blockedReferenceRef = React24.useRef(null);
4476    const keyboardModalityRef = React24.useRef(true);
4477    const timeout = useTimeout();
4478    React24.useEffect(() => {
4479      const domReference = store.select("domReferenceElement");
4480      if (!enabled) {
4481        return void 0;
4482      }
4483      const win = getWindow(domReference);
4484      function onBlur() {
4485        const currentDomReference = store.select("domReferenceElement");
4486        if (!store.select("open") && isHTMLElement(currentDomReference) && currentDomReference === activeElement(ownerDocument(currentDomReference))) {
4487          blockFocusRef.current = true;
4488          blockedReferenceRef.current = currentDomReference;
4489        }
4490      }
4491      function onKeyDown() {
4492        keyboardModalityRef.current = true;
4493      }
4494      function onPointerDown() {
4495        keyboardModalityRef.current = false;
4496      }
4497      return mergeCleanups(addEventListener(win, "blur", onBlur), isMacSafari && addEventListener(win, "keydown", onKeyDown, true), isMacSafari && addEventListener(win, "pointerdown", onPointerDown, true));
4498    }, [store, enabled]);
4499    React24.useEffect(() => {
4500      if (!enabled) {
4501        return void 0;
4502      }
4503      function onOpenChangeLocal(details) {
4504        if (details.reason === reason_parts_exports.triggerPress || details.reason === reason_parts_exports.escapeKey) {
4505          const referenceElement = store.select("domReferenceElement");
4506          if (isElement(referenceElement)) {
4507            blockedReferenceRef.current = referenceElement;
4508            blockFocusRef.current = true;
4509          }
4510        }
4511      }
4512      events.on("openchange", onOpenChangeLocal);
4513      return () => {
4514        events.off("openchange", onOpenChangeLocal);
4515      };
4516    }, [events, enabled, store]);
4517    const reference = React24.useMemo(() => {
4518      function resetBlockedFocus() {
4519        blockFocusRef.current = false;
4520        blockedReferenceRef.current = null;
4521      }
4522      return {
4523        onMouseLeave() {
4524          resetBlockedFocus();
4525        },
4526        onFocus(event) {
4527          const focusTarget = event.currentTarget;
4528          if (blockFocusRef.current) {
4529            if (blockedReferenceRef.current === focusTarget) {
4530              return;
4531            }
4532            resetBlockedFocus();
4533          }
4534          const target = getTarget(event.nativeEvent);
4535          if (isElement(target)) {
4536            if (isMacSafari && !event.relatedTarget) {
4537              if (!keyboardModalityRef.current && !isTypeableElement(target)) {
4538                return;
4539              }
4540            } else if (!matchesFocusVisible(target)) {
4541              return;
4542            }
4543          }
4544          const movedFromOtherEnabledTrigger = isTargetInsideEnabledTrigger(event.relatedTarget, store.context.triggerElements);
4545          const {
4546            nativeEvent,
4547            currentTarget
4548          } = event;
4549          if (store.select("open") && movedFromOtherEnabledTrigger || !delay) {
4550            store.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerFocus, nativeEvent, currentTarget));
4551            return;
4552          }
4553          timeout.start(delay, () => {
4554            if (blockFocusRef.current) {
4555              return;
4556            }
4557            store.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerFocus, nativeEvent, currentTarget));
4558          });
4559        },
4560        onBlur(event) {
4561          resetBlockedFocus();
4562          const relatedTarget = event.relatedTarget;
4563          const nativeEvent = event.nativeEvent;
4564          const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
4565          timeout.start(0, () => {
4566            const domReference = store.select("domReferenceElement");
4567            const activeEl = activeElement(ownerDocument(domReference));
4568            if (!relatedTarget && activeEl === domReference) {
4569              return;
4570            }
4571            if (contains(dataRef.current.floatingContext?.refs.floating.current, activeEl) || contains(domReference, activeEl) || movedToFocusGuard) {
4572              return;
4573            }
4574            const nextFocusedElement = relatedTarget ?? activeEl;
4575            if (isTargetInsideEnabledTrigger(nextFocusedElement, store.context.triggerElements)) {
4576              return;
4577            }
4578            store.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerFocus, nativeEvent));
4579          });
4580        }
4581      };
4582    }, [dataRef, delay, store, timeout]);
4583    return React24.useMemo(() => enabled ? {
4584      reference,
4585      trigger: reference
4586    } : {}, [enabled, reference]);
4587  }
4588  
4589  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useHoverFloatingInteraction.mjs
4590  var React25 = __toESM(require_react(), 1);
4591  
4592  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useHoverInteractionSharedState.mjs
4593  var HoverInteraction = class _HoverInteraction {
4594    pointerType = void 0;
4595    interactedInside = false;
4596    handler = void 0;
4597    blockMouseMove = true;
4598    performedPointerEventsMutation = false;
4599    pointerEventsScopeElement = null;
4600    pointerEventsReferenceElement = null;
4601    pointerEventsFloatingElement = null;
4602    restTimeoutPending = false;
4603    openChangeTimeout = new Timeout();
4604    restTimeout = new Timeout();
4605    handleCloseOptions = void 0;
4606    static create() {
4607      return new _HoverInteraction();
4608    }
4609    dispose = () => {
4610      this.openChangeTimeout.clear();
4611      this.restTimeout.clear();
4612    };
4613    disposeEffect = () => {
4614      return this.dispose;
4615    };
4616  };
4617  var pointerEventsMutationOwnerByScopeElement = /* @__PURE__ */ new WeakMap();
4618  function clearSafePolygonPointerEventsMutation(instance) {
4619    if (!instance.performedPointerEventsMutation) {
4620      return;
4621    }
4622    const scopeElement = instance.pointerEventsScopeElement;
4623    if (scopeElement && pointerEventsMutationOwnerByScopeElement.get(scopeElement) === instance) {
4624      instance.pointerEventsScopeElement?.style.removeProperty("pointer-events");
4625      instance.pointerEventsReferenceElement?.style.removeProperty("pointer-events");
4626      instance.pointerEventsFloatingElement?.style.removeProperty("pointer-events");
4627      pointerEventsMutationOwnerByScopeElement.delete(scopeElement);
4628    }
4629    instance.performedPointerEventsMutation = false;
4630    instance.pointerEventsScopeElement = null;
4631    instance.pointerEventsReferenceElement = null;
4632    instance.pointerEventsFloatingElement = null;
4633  }
4634  function applySafePolygonPointerEventsMutation(instance, options) {
4635    const {
4636      scopeElement,
4637      referenceElement,
4638      floatingElement
4639    } = options;
4640    const existingOwner = pointerEventsMutationOwnerByScopeElement.get(scopeElement);
4641    if (existingOwner && existingOwner !== instance) {
4642      clearSafePolygonPointerEventsMutation(existingOwner);
4643    }
4644    clearSafePolygonPointerEventsMutation(instance);
4645    instance.performedPointerEventsMutation = true;
4646    instance.pointerEventsScopeElement = scopeElement;
4647    instance.pointerEventsReferenceElement = referenceElement;
4648    instance.pointerEventsFloatingElement = floatingElement;
4649    pointerEventsMutationOwnerByScopeElement.set(scopeElement, instance);
4650    scopeElement.style.pointerEvents = "none";
4651    referenceElement.style.pointerEvents = "auto";
4652    floatingElement.style.pointerEvents = "auto";
4653  }
4654  function useHoverInteractionSharedState(store) {
4655    const data = store.context.dataRef.current;
4656    const instance = useRefWithInit(() => data.hoverInteractionState ?? HoverInteraction.create()).current;
4657    if (!data.hoverInteractionState) {
4658      data.hoverInteractionState = instance;
4659    }
4660    useOnMount(data.hoverInteractionState.disposeEffect);
4661    return data.hoverInteractionState;
4662  }
4663  
4664  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useHoverFloatingInteraction.mjs
4665  function useHoverFloatingInteraction(store, parameters = {}) {
4666    const {
4667      enabled = true,
4668      closeDelay: closeDelayProp = 0,
4669      nodeId: nodeIdProp
4670    } = parameters;
4671    const open2 = store.useState("open");
4672    const floatingElement = store.useState("floatingElement");
4673    const domReferenceElement = store.useState("domReferenceElement");
4674    const {
4675      dataRef
4676    } = store.context;
4677    const tree = useFloatingTree();
4678    const parentId = useFloatingParentNodeId();
4679    const instance = useHoverInteractionSharedState(store);
4680    const childClosedTimeout = useTimeout();
4681    const isClickLikeOpenEvent2 = useStableCallback(() => {
4682      return isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside);
4683    });
4684    const isHoverOpen = useStableCallback(() => {
4685      return isHoverOpenEvent(dataRef.current.openEvent?.type);
4686    });
4687    const clearPointerEvents = useStableCallback(() => {
4688      clearSafePolygonPointerEventsMutation(instance);
4689    });
4690    useIsoLayoutEffect(() => {
4691      if (!open2) {
4692        instance.pointerType = void 0;
4693        instance.restTimeoutPending = false;
4694        instance.interactedInside = false;
4695        clearPointerEvents();
4696      }
4697    }, [open2, instance, clearPointerEvents]);
4698    React25.useEffect(() => {
4699      return clearPointerEvents;
4700    }, [clearPointerEvents]);
4701    useIsoLayoutEffect(() => {
4702      if (!enabled) {
4703        return void 0;
4704      }
4705      if (open2 && instance.handleCloseOptions?.blockPointerEvents && isHoverOpen() && isElement(domReferenceElement) && floatingElement) {
4706        const ref = domReferenceElement;
4707        const floatingEl = floatingElement;
4708        const doc = ownerDocument(floatingElement);
4709        const parentFloating = tree?.nodesRef.current.find((node) => node.id === parentId)?.context?.elements.floating;
4710        if (parentFloating) {
4711          parentFloating.style.pointerEvents = "";
4712        }
4713        const cachedScopeElement = instance.pointerEventsScopeElement !== floatingEl ? instance.pointerEventsScopeElement : null;
4714        const parentScopeElement = parentFloating !== floatingEl ? parentFloating : null;
4715        const scopeElement = instance.handleCloseOptions?.getScope?.() ?? cachedScopeElement ?? parentScopeElement ?? closest(ref, "[data-rootownerid]") ?? doc.body;
4716        applySafePolygonPointerEventsMutation(instance, {
4717          scopeElement,
4718          referenceElement: ref,
4719          floatingElement: floatingEl
4720        });
4721        return () => {
4722          clearPointerEvents();
4723        };
4724      }
4725      return void 0;
4726    }, [enabled, open2, domReferenceElement, floatingElement, instance, isHoverOpen, tree, parentId, clearPointerEvents]);
4727    React25.useEffect(() => {
4728      if (!enabled) {
4729        return void 0;
4730      }
4731      function hasParentChildren() {
4732        return !!(tree && parentId && getNodeChildren(tree.nodesRef.current, parentId).length > 0);
4733      }
4734      function closeWithDelay(event) {
4735        const closeDelay = getDelay(closeDelayProp, "close", instance.pointerType);
4736        const close = () => {
4737          store.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
4738          tree?.events.emit("floating.closed", event);
4739        };
4740        if (closeDelay) {
4741          instance.openChangeTimeout.start(closeDelay, close);
4742        } else {
4743          instance.openChangeTimeout.clear();
4744          close();
4745        }
4746      }
4747      function handleInteractInside(event) {
4748        const target = getTarget(event);
4749        if (!isInteractiveElement(target)) {
4750          instance.interactedInside = false;
4751          return;
4752        }
4753        instance.interactedInside = closest(target, "[aria-haspopup]") != null;
4754      }
4755      function onFloatingMouseEnter() {
4756        instance.openChangeTimeout.clear();
4757        childClosedTimeout.clear();
4758        tree?.events.off("floating.closed", onNodeClosed);
4759        clearPointerEvents();
4760      }
4761      function onFloatingMouseLeave(event) {
4762        if (hasParentChildren() && tree) {
4763          tree.events.on("floating.closed", onNodeClosed);
4764          return;
4765        }
4766        if (isTargetInsideEnabledTrigger(event.relatedTarget, store.context.triggerElements)) {
4767          return;
4768        }
4769        const currentNodeId = dataRef.current.floatingContext?.nodeId ?? nodeIdProp;
4770        const relatedTarget = event.relatedTarget;
4771        const isMovingIntoDescendantFloating = tree && currentNodeId && isElement(relatedTarget) && getNodeChildren(tree.nodesRef.current, currentNodeId, false).some((node) => contains(node.context?.elements.floating, relatedTarget));
4772        if (isMovingIntoDescendantFloating) {
4773          return;
4774        }
4775        if (instance.handler) {
4776          instance.handler(event);
4777          return;
4778        }
4779        clearPointerEvents();
4780        if (isHoverOpen() && !isClickLikeOpenEvent2()) {
4781          closeWithDelay(event);
4782        }
4783      }
4784      function onNodeClosed(event) {
4785        if (!tree || !parentId || hasParentChildren()) {
4786          return;
4787        }
4788        childClosedTimeout.start(0, () => {
4789          tree.events.off("floating.closed", onNodeClosed);
4790          store.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
4791          tree.events.emit("floating.closed", event);
4792        });
4793      }
4794      const floating = floatingElement;
4795      return mergeCleanups(floating && addEventListener(floating, "mouseenter", onFloatingMouseEnter), floating && addEventListener(floating, "mouseleave", onFloatingMouseLeave), floating && addEventListener(floating, "pointerdown", handleInteractInside, true), () => {
4796        tree?.events.off("floating.closed", onNodeClosed);
4797      });
4798    }, [enabled, floatingElement, store, dataRef, closeDelayProp, nodeIdProp, isHoverOpen, isClickLikeOpenEvent2, clearPointerEvents, instance, tree, parentId, childClosedTimeout]);
4799  }
4800  
4801  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useHoverReferenceInteraction.mjs
4802  var React26 = __toESM(require_react(), 1);
4803  var ReactDOM4 = __toESM(require_react_dom(), 1);
4804  var EMPTY_REF = {
4805    current: null
4806  };
4807  function useHoverReferenceInteraction(store, props = {}) {
4808    const {
4809      enabled = true,
4810      delay = 0,
4811      handleClose = null,
4812      mouseOnly = false,
4813      restMs = 0,
4814      move = true,
4815      triggerElementRef = EMPTY_REF,
4816      externalTree,
4817      isActiveTrigger = true,
4818      getHandleCloseContext,
4819      isClosing,
4820      shouldOpen: shouldOpenProp,
4821      guardStaleOpen = false
4822    } = props;
4823    const {
4824      dataRef,
4825      events
4826    } = store.context;
4827    const tree = useFloatingTree(externalTree);
4828    const instance = useHoverInteractionSharedState(store);
4829    const isHoverCloseActiveRef = React26.useRef(false);
4830    const handleCloseRef = useValueAsRef(handleClose);
4831    const delayRef = useValueAsRef(delay);
4832    const restMsRef = useValueAsRef(restMs);
4833    const enabledRef = useValueAsRef(enabled);
4834    const shouldOpenRef = useValueAsRef(shouldOpenProp);
4835    const isClosingRef = useValueAsRef(isClosing);
4836    const isClickLikeOpenEvent2 = useStableCallback(() => {
4837      return isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside);
4838    });
4839    const checkShouldOpen = useStableCallback(() => {
4840      return shouldOpenRef.current?.() !== false;
4841    });
4842    const isOverInactiveTrigger = useStableCallback((currentDomReference, currentTarget, target) => {
4843      const allTriggers = store.context.triggerElements;
4844      if (allTriggers.hasElement(currentTarget)) {
4845        return !currentDomReference || !contains(currentDomReference, currentTarget);
4846      }
4847      if (!isElement(target)) {
4848        return false;
4849      }
4850      const targetElement = target;
4851      return allTriggers.hasMatchingElement((trigger) => contains(trigger, targetElement)) && (!currentDomReference || !contains(currentDomReference, targetElement));
4852    });
4853    const cleanupMouseMoveHandler = useStableCallback(() => {
4854      if (!instance.handler) {
4855        return;
4856      }
4857      const doc = ownerDocument(store.select("domReferenceElement"));
4858      doc.removeEventListener("mousemove", instance.handler);
4859      instance.handler = void 0;
4860    });
4861    const clearPointerEvents = useStableCallback(() => {
4862      clearSafePolygonPointerEventsMutation(instance);
4863    });
4864    if (isActiveTrigger) {
4865      instance.handleCloseOptions = handleClose?.__options;
4866    }
4867    React26.useEffect(() => cleanupMouseMoveHandler, [cleanupMouseMoveHandler]);
4868    React26.useEffect(() => {
4869      if (!enabled) {
4870        return void 0;
4871      }
4872      function onOpenChangeLocal(details) {
4873        if (!details.open) {
4874          isHoverCloseActiveRef.current = details.reason === reason_parts_exports.triggerHover;
4875          cleanupMouseMoveHandler();
4876          instance.openChangeTimeout.clear();
4877          instance.restTimeout.clear();
4878          instance.blockMouseMove = true;
4879          instance.restTimeoutPending = false;
4880        } else {
4881          isHoverCloseActiveRef.current = false;
4882        }
4883      }
4884      events.on("openchange", onOpenChangeLocal);
4885      return () => {
4886        events.off("openchange", onOpenChangeLocal);
4887      };
4888    }, [enabled, events, instance, cleanupMouseMoveHandler]);
4889    React26.useEffect(() => {
4890      if (!enabled) {
4891        return void 0;
4892      }
4893      function closeWithDelay(event, runElseBranch = true) {
4894        const closeDelay = getDelay(delayRef.current, "close", instance.pointerType);
4895        if (closeDelay) {
4896          instance.openChangeTimeout.start(closeDelay, () => {
4897            store.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
4898            tree?.events.emit("floating.closed", event);
4899          });
4900        } else if (runElseBranch) {
4901          instance.openChangeTimeout.clear();
4902          store.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
4903          tree?.events.emit("floating.closed", event);
4904        }
4905      }
4906      const trigger = triggerElementRef.current ?? (isActiveTrigger ? store.select("domReferenceElement") : null);
4907      if (!isElement(trigger)) {
4908        return void 0;
4909      }
4910      function onMouseEnter(event) {
4911        instance.openChangeTimeout.clear();
4912        instance.blockMouseMove = false;
4913        if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
4914          return;
4915        }
4916        const restMsValue = getRestMs(restMsRef.current);
4917        const openDelay = getDelay(delayRef.current, "open", instance.pointerType);
4918        const eventTarget = getTarget(event);
4919        const currentTarget = event.currentTarget ?? null;
4920        const currentDomReference = store.select("domReferenceElement");
4921        let triggerNode = currentTarget;
4922        if (isElement(eventTarget) && !store.context.triggerElements.hasElement(eventTarget)) {
4923          for (const triggerElement of store.context.triggerElements.elements()) {
4924            if (contains(triggerElement, eventTarget)) {
4925              triggerNode = triggerElement;
4926              break;
4927            }
4928          }
4929        }
4930        if (isElement(currentTarget) && isElement(currentDomReference) && !store.context.triggerElements.hasElement(currentTarget) && contains(currentTarget, currentDomReference)) {
4931          triggerNode = currentDomReference;
4932        }
4933        const isOverInactive = triggerNode == null ? false : isOverInactiveTrigger(currentDomReference, triggerNode, eventTarget);
4934        const isOpen = store.select("open");
4935        const isInClosingTransition = isClosingRef.current?.() ?? store.select("transitionStatus") === "ending";
4936        const isHoverCloseTransition = !isOpen && isInClosingTransition && isHoverCloseActiveRef.current;
4937        const isReenteringSameTriggerDuringCloseTransition = !isOverInactive && isElement(triggerNode) && isElement(currentDomReference) && contains(currentDomReference, triggerNode) && isHoverCloseTransition;
4938        const isRestOnlyDelay = restMsValue > 0 && !openDelay;
4939        const shouldOpenImmediately = isOverInactive && (isOpen || isHoverCloseTransition) || isReenteringSameTriggerDuringCloseTransition;
4940        const shouldOpen = !isOpen || isOverInactive;
4941        if (shouldOpenImmediately) {
4942          if (checkShouldOpen()) {
4943            store.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerNode));
4944          }
4945          return;
4946        }
4947        if (isRestOnlyDelay) {
4948          return;
4949        }
4950        if (openDelay) {
4951          instance.openChangeTimeout.start(openDelay, () => {
4952            if (shouldOpen && checkShouldOpen()) {
4953              store.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerNode));
4954            }
4955          });
4956        } else if (shouldOpen) {
4957          if (checkShouldOpen()) {
4958            store.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerNode));
4959          }
4960        }
4961      }
4962      function onMouseLeave(event) {
4963        if (isClickLikeOpenEvent2()) {
4964          clearPointerEvents();
4965          return;
4966        }
4967        cleanupMouseMoveHandler();
4968        const domReferenceElement = store.select("domReferenceElement");
4969        const doc = ownerDocument(domReferenceElement);
4970        instance.restTimeout.clear();
4971        instance.restTimeoutPending = false;
4972        const handleCloseContextBase = dataRef.current.floatingContext ?? getHandleCloseContext?.();
4973        if (isTargetInsideEnabledTrigger(event.relatedTarget, store.context.triggerElements)) {
4974          return;
4975        }
4976        if (handleCloseRef.current && handleCloseContextBase) {
4977          if (!store.select("open")) {
4978            instance.openChangeTimeout.clear();
4979          }
4980          const currentTrigger = triggerElementRef.current;
4981          instance.handler = handleCloseRef.current({
4982            ...handleCloseContextBase,
4983            tree,
4984            x: event.clientX,
4985            y: event.clientY,
4986            onClose() {
4987              clearPointerEvents();
4988              cleanupMouseMoveHandler();
4989              if (enabledRef.current && !isClickLikeOpenEvent2() && currentTrigger === store.select("domReferenceElement")) {
4990                closeWithDelay(event, true);
4991              }
4992            }
4993          });
4994          doc.addEventListener("mousemove", instance.handler);
4995          instance.handler(event);
4996          return;
4997        }
4998        const shouldClose = instance.pointerType === "touch" ? !contains(store.select("floatingElement"), event.relatedTarget) : true;
4999        if (shouldClose) {
5000          closeWithDelay(event);
5001        }
5002      }
5003      function onMouseOut(event) {
5004        if (contains(trigger, event.relatedTarget)) {
5005          return;
5006        }
5007        instance.openChangeTimeout.clear();
5008        instance.restTimeout.clear();
5009        instance.restTimeoutPending = false;
5010      }
5011      const staleOpenGuard = guardStaleOpen ? addEventListener(trigger, "mouseout", onMouseOut) : void 0;
5012      if (move) {
5013        return mergeCleanups(addEventListener(trigger, "mousemove", onMouseEnter, {
5014          once: true
5015        }), addEventListener(trigger, "mouseenter", onMouseEnter), addEventListener(trigger, "mouseleave", onMouseLeave), staleOpenGuard);
5016      }
5017      return mergeCleanups(addEventListener(trigger, "mouseenter", onMouseEnter), addEventListener(trigger, "mouseleave", onMouseLeave), staleOpenGuard);
5018    }, [cleanupMouseMoveHandler, clearPointerEvents, dataRef, delayRef, store, enabled, handleCloseRef, instance, isActiveTrigger, isOverInactiveTrigger, isClickLikeOpenEvent2, mouseOnly, move, restMsRef, triggerElementRef, tree, enabledRef, getHandleCloseContext, isClosingRef, checkShouldOpen, guardStaleOpen]);
5019    return React26.useMemo(() => {
5020      if (!enabled) {
5021        return void 0;
5022      }
5023      function setPointerRef(event) {
5024        instance.pointerType = event.pointerType;
5025      }
5026      return {
5027        onPointerDown: setPointerRef,
5028        onPointerEnter: setPointerRef,
5029        onMouseMove(event) {
5030          const {
5031            nativeEvent
5032          } = event;
5033          const trigger = event.currentTarget;
5034          const currentDomReference = store.select("domReferenceElement");
5035          const currentOpen = store.select("open");
5036          const isOverInactive = isOverInactiveTrigger(currentDomReference, trigger, event.target);
5037          if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
5038            return;
5039          }
5040          if (currentOpen && isOverInactive && instance.handleCloseOptions?.blockPointerEvents) {
5041            const floatingElement = store.select("floatingElement");
5042            if (floatingElement) {
5043              const scopeElement = instance.handleCloseOptions?.getScope?.() ?? trigger.ownerDocument.body;
5044              applySafePolygonPointerEventsMutation(instance, {
5045                scopeElement,
5046                referenceElement: trigger,
5047                floatingElement
5048              });
5049            }
5050          }
5051          const restMsValue = getRestMs(restMsRef.current);
5052          if (currentOpen && !isOverInactive || restMsValue === 0) {
5053            return;
5054          }
5055          if (!isOverInactive && instance.restTimeoutPending && event.movementX ** 2 + event.movementY ** 2 < 2) {
5056            return;
5057          }
5058          instance.restTimeout.clear();
5059          function handleMouseMove() {
5060            instance.restTimeoutPending = false;
5061            if (isClickLikeOpenEvent2()) {
5062              return;
5063            }
5064            const latestOpen = store.select("open");
5065            if (!instance.blockMouseMove && (!latestOpen || isOverInactive) && checkShouldOpen()) {
5066              store.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, nativeEvent, trigger));
5067            }
5068          }
5069          if (instance.pointerType === "touch") {
5070            ReactDOM4.flushSync(() => {
5071              handleMouseMove();
5072            });
5073          } else if (isOverInactive && currentOpen) {
5074            handleMouseMove();
5075          } else {
5076            instance.restTimeoutPending = true;
5077            instance.restTimeout.start(restMsValue, handleMouseMove);
5078          }
5079        }
5080      };
5081    }, [enabled, instance, isClickLikeOpenEvent2, isOverInactiveTrigger, mouseOnly, store, restMsRef, checkShouldOpen]);
5082  }
5083  
5084  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/safePolygon.mjs
5085  var CURSOR_SPEED_THRESHOLD = 0.1;
5086  var CURSOR_SPEED_THRESHOLD_SQUARED = CURSOR_SPEED_THRESHOLD * CURSOR_SPEED_THRESHOLD;
5087  var POLYGON_BUFFER = 0.5;
5088  function hasIntersectingEdge(pointX, pointY, xi, yi, xj, yj) {
5089    return yi >= pointY !== yj >= pointY && pointX <= (xj - xi) * (pointY - yi) / (yj - yi) + xi;
5090  }
5091  function isPointInQuadrilateral(pointX, pointY, x1, y1, x2, y2, x3, y3, x4, y4) {
5092    let isInsideValue = false;
5093    if (hasIntersectingEdge(pointX, pointY, x1, y1, x2, y2)) {
5094      isInsideValue = !isInsideValue;
5095    }
5096    if (hasIntersectingEdge(pointX, pointY, x2, y2, x3, y3)) {
5097      isInsideValue = !isInsideValue;
5098    }
5099    if (hasIntersectingEdge(pointX, pointY, x3, y3, x4, y4)) {
5100      isInsideValue = !isInsideValue;
5101    }
5102    if (hasIntersectingEdge(pointX, pointY, x4, y4, x1, y1)) {
5103      isInsideValue = !isInsideValue;
5104    }
5105    return isInsideValue;
5106  }
5107  function isInsideRect(pointX, pointY, rect) {
5108    return pointX >= rect.x && pointX <= rect.x + rect.width && pointY >= rect.y && pointY <= rect.y + rect.height;
5109  }
5110  function isInsideAxisAlignedRect(pointX, pointY, x1, y1, x2, y2) {
5111    const minX = Math.min(x1, x2);
5112    const maxX = Math.max(x1, x2);
5113    const minY = Math.min(y1, y2);
5114    const maxY = Math.max(y1, y2);
5115    return pointX >= minX && pointX <= maxX && pointY >= minY && pointY <= maxY;
5116  }
5117  function safePolygon(options = {}) {
5118    const {
5119      blockPointerEvents = false
5120    } = options;
5121    const timeout = new Timeout();
5122    const fn = ({
5123      x,
5124      y,
5125      placement,
5126      elements,
5127      onClose,
5128      nodeId,
5129      tree
5130    }) => {
5131      const side = placement?.split("-")[0];
5132      let hasLanded = false;
5133      let lastX = null;
5134      let lastY = null;
5135      let lastCursorTime = typeof performance !== "undefined" ? performance.now() : 0;
5136      function isCursorMovingSlowly(nextX, nextY) {
5137        const currentTime = performance.now();
5138        const elapsedTime = currentTime - lastCursorTime;
5139        if (lastX === null || lastY === null || elapsedTime === 0) {
5140          lastX = nextX;
5141          lastY = nextY;
5142          lastCursorTime = currentTime;
5143          return false;
5144        }
5145        const deltaX = nextX - lastX;
5146        const deltaY = nextY - lastY;
5147        const distanceSquared = deltaX * deltaX + deltaY * deltaY;
5148        const thresholdSquared = elapsedTime * elapsedTime * CURSOR_SPEED_THRESHOLD_SQUARED;
5149        lastX = nextX;
5150        lastY = nextY;
5151        lastCursorTime = currentTime;
5152        return distanceSquared < thresholdSquared;
5153      }
5154      function close() {
5155        timeout.clear();
5156        onClose();
5157      }
5158      return function onMouseMove(event) {
5159        timeout.clear();
5160        const domReference = elements.domReference;
5161        const floating = elements.floating;
5162        if (!domReference || !floating || side == null || x == null || y == null) {
5163          return void 0;
5164        }
5165        const {
5166          clientX,
5167          clientY
5168        } = event;
5169        const target = getTarget(event);
5170        const isLeave = event.type === "mouseleave";
5171        const isOverFloatingEl = contains(floating, target);
5172        const isOverReferenceEl = contains(domReference, target);
5173        if (isOverFloatingEl) {
5174          hasLanded = true;
5175          if (!isLeave) {
5176            return void 0;
5177          }
5178        }
5179        if (isOverReferenceEl) {
5180          hasLanded = false;
5181          if (!isLeave) {
5182            hasLanded = true;
5183            return void 0;
5184          }
5185        }
5186        if (isLeave && isElement(event.relatedTarget) && contains(floating, event.relatedTarget)) {
5187          return void 0;
5188        }
5189        function hasOpenChildNode() {
5190          return Boolean(tree && getNodeChildren(tree.nodesRef.current, nodeId).length > 0);
5191        }
5192        function closeIfNoOpenChild() {
5193          if (!hasOpenChildNode()) {
5194            close();
5195          }
5196        }
5197        if (hasOpenChildNode()) {
5198          return void 0;
5199        }
5200        const refRect = domReference.getBoundingClientRect();
5201        const rect = floating.getBoundingClientRect();
5202        const cursorLeaveFromRight = x > rect.right - rect.width / 2;
5203        const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;
5204        const isFloatingWider = rect.width > refRect.width;
5205        const isFloatingTaller = rect.height > refRect.height;
5206        const left = (isFloatingWider ? refRect : rect).left;
5207        const right = (isFloatingWider ? refRect : rect).right;
5208        const top = (isFloatingTaller ? refRect : rect).top;
5209        const bottom = (isFloatingTaller ? refRect : rect).bottom;
5210        if (side === "top" && y >= refRect.bottom - 1 || side === "bottom" && y <= refRect.top + 1 || side === "left" && x >= refRect.right - 1 || side === "right" && x <= refRect.left + 1) {
5211          closeIfNoOpenChild();
5212          return void 0;
5213        }
5214        let isInsideTroughRect = false;
5215        switch (side) {
5216          case "top":
5217            isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, left, refRect.top + 1, right, rect.bottom - 1);
5218            break;
5219          case "bottom":
5220            isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, left, rect.top + 1, right, refRect.bottom - 1);
5221            break;
5222          case "left":
5223            isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, rect.right - 1, bottom, refRect.left + 1, top);
5224            break;
5225          case "right":
5226            isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, refRect.right - 1, bottom, rect.left + 1, top);
5227            break;
5228          default:
5229        }
5230        if (isInsideTroughRect) {
5231          return void 0;
5232        }
5233        if (hasLanded && !isInsideRect(clientX, clientY, refRect)) {
5234          closeIfNoOpenChild();
5235          return void 0;
5236        }
5237        if (!isLeave && isCursorMovingSlowly(clientX, clientY)) {
5238          closeIfNoOpenChild();
5239          return void 0;
5240        }
5241        let isInsidePolygon = false;
5242        switch (side) {
5243          case "top": {
5244            const cursorXOffset = isFloatingWider ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
5245            const cursorPointOneX = isFloatingWider ? x + cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
5246            const cursorPointTwoX = isFloatingWider ? x - cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
5247            const cursorPointY = y + POLYGON_BUFFER + 1;
5248            const commonYLeft = cursorLeaveFromRight ? rect.bottom - POLYGON_BUFFER : isFloatingWider ? rect.bottom - POLYGON_BUFFER : rect.top;
5249            const commonYRight = cursorLeaveFromRight ? isFloatingWider ? rect.bottom - POLYGON_BUFFER : rect.top : rect.bottom - POLYGON_BUFFER;
5250            isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointOneX, cursorPointY, cursorPointTwoX, cursorPointY, rect.left, commonYLeft, rect.right, commonYRight);
5251            break;
5252          }
5253          case "bottom": {
5254            const cursorXOffset = isFloatingWider ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
5255            const cursorPointOneX = isFloatingWider ? x + cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
5256            const cursorPointTwoX = isFloatingWider ? x - cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
5257            const cursorPointY = y - POLYGON_BUFFER;
5258            const commonYLeft = cursorLeaveFromRight ? rect.top + POLYGON_BUFFER : isFloatingWider ? rect.top + POLYGON_BUFFER : rect.bottom;
5259            const commonYRight = cursorLeaveFromRight ? isFloatingWider ? rect.top + POLYGON_BUFFER : rect.bottom : rect.top + POLYGON_BUFFER;
5260            isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointOneX, cursorPointY, cursorPointTwoX, cursorPointY, rect.left, commonYLeft, rect.right, commonYRight);
5261            break;
5262          }
5263          case "left": {
5264            const cursorYOffset = isFloatingTaller ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
5265            const cursorPointOneY = isFloatingTaller ? y + cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
5266            const cursorPointTwoY = isFloatingTaller ? y - cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
5267            const cursorPointX = x + POLYGON_BUFFER + 1;
5268            const commonXTop = cursorLeaveFromBottom ? rect.right - POLYGON_BUFFER : isFloatingTaller ? rect.right - POLYGON_BUFFER : rect.left;
5269            const commonXBottom = cursorLeaveFromBottom ? isFloatingTaller ? rect.right - POLYGON_BUFFER : rect.left : rect.right - POLYGON_BUFFER;
5270            isInsidePolygon = isPointInQuadrilateral(clientX, clientY, commonXTop, rect.top, commonXBottom, rect.bottom, cursorPointX, cursorPointOneY, cursorPointX, cursorPointTwoY);
5271            break;
5272          }
5273          case "right": {
5274            const cursorYOffset = isFloatingTaller ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
5275            const cursorPointOneY = isFloatingTaller ? y + cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
5276            const cursorPointTwoY = isFloatingTaller ? y - cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
5277            const cursorPointX = x - POLYGON_BUFFER;
5278            const commonXTop = cursorLeaveFromBottom ? rect.left + POLYGON_BUFFER : isFloatingTaller ? rect.left + POLYGON_BUFFER : rect.right;
5279            const commonXBottom = cursorLeaveFromBottom ? isFloatingTaller ? rect.left + POLYGON_BUFFER : rect.right : rect.left + POLYGON_BUFFER;
5280            isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointX, cursorPointOneY, cursorPointX, cursorPointTwoY, commonXTop, rect.top, commonXBottom, rect.bottom);
5281            break;
5282          }
5283          default:
5284        }
5285        if (!isInsidePolygon) {
5286          closeIfNoOpenChild();
5287        } else if (!hasLanded) {
5288          timeout.start(40, closeIfNoOpenChild);
5289        }
5290        return void 0;
5291      };
5292    };
5293    fn.__options = {
5294      ...options,
5295      blockPointerEvents
5296    };
5297    return fn;
5298  }
5299  
5300  // node_modules/.store/@floating-ui/core@1.8.0-3V8aS7jJHHGcsCINjP9-5A/node_modules/@floating-ui/core/dist/floating-ui.core.mjs
5301  function computeCoordsFromPlacement(_ref, placement, rtl) {
5302    let {
5303      reference,
5304      floating
5305    } = _ref;
5306    const sideAxis = getSideAxis(placement);
5307    const alignmentAxis = getAlignmentAxis(placement);
5308    const alignLength = getAxisLength(alignmentAxis);
5309    const side = getSide(placement);
5310    const isVertical = sideAxis === "y";
5311    const commonX = reference.x + reference.width / 2 - floating.width / 2;
5312    const commonY = reference.y + reference.height / 2 - floating.height / 2;
5313    const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
5314    let coords;
5315    switch (side) {
5316      case "top":
5317        coords = {
5318          x: commonX,
5319          y: reference.y - floating.height
5320        };
5321        break;
5322      case "bottom":
5323        coords = {
5324          x: commonX,
5325          y: reference.y + reference.height
5326        };
5327        break;
5328      case "right":
5329        coords = {
5330          x: reference.x + reference.width,
5331          y: commonY
5332        };
5333        break;
5334      case "left":
5335        coords = {
5336          x: reference.x - floating.width,
5337          y: commonY
5338        };
5339        break;
5340      default:
5341        coords = {
5342          x: reference.x,
5343          y: reference.y
5344        };
5345    }
5346    const alignment = getAlignment(placement);
5347    if (alignment) {
5348      coords[alignmentAxis] += commonAlign * (alignment === "end" ? 1 : -1) * (rtl && isVertical ? -1 : 1);
5349    }
5350    return coords;
5351  }
5352  async function detectOverflow(state, options) {
5353    var _await$platform$isEle;
5354    if (options === void 0) {
5355      options = {};
5356    }
5357    const {
5358      x,
5359      y,
5360      platform: platform3,
5361      rects,
5362      elements,
5363      strategy
5364    } = state;
5365    const {
5366      boundary = "clippingAncestors",
5367      rootBoundary = "viewport",
5368      elementContext = "floating",
5369      altBoundary = false,
5370      padding = 0
5371    } = evaluate(options, state);
5372    const paddingObject = getPaddingObject(padding);
5373    const altContext = elementContext === "floating" ? "reference" : "floating";
5374    const element = elements[altBoundary ? altContext : elementContext];
5375    const clippingClientRect = rectToClientRect(await platform3.getClippingRect({
5376      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(elements.floating)),
5377      boundary,
5378      rootBoundary,
5379      strategy
5380    }));
5381    const rect = elementContext === "floating" ? {
5382      x,
5383      y,
5384      width: rects.floating.width,
5385      height: rects.floating.height
5386    } : rects.reference;
5387    const offsetParent = await (platform3.getOffsetParent == null ? void 0 : platform3.getOffsetParent(elements.floating));
5388    const offsetScale = await (platform3.isElement == null ? void 0 : platform3.isElement(offsetParent)) && await (platform3.getScale == null ? void 0 : platform3.getScale(offsetParent)) || {
5389      x: 1,
5390      y: 1
5391    };
5392    const elementClientRect = rectToClientRect(platform3.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform3.convertOffsetParentRelativeRectToViewportRelativeRect({
5393      elements,
5394      rect,
5395      offsetParent,
5396      strategy
5397    }) : rect);
5398    return {
5399      top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
5400      bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
5401      left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
5402      right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
5403    };
5404  }
5405  var MAX_RESET_COUNT = 50;
5406  var computePosition = async (reference, floating, config) => {
5407    const {
5408      placement = "bottom",
5409      strategy = "absolute",
5410      middleware = [],
5411      platform: platform3
5412    } = config;
5413    const platformWithDetectOverflow = platform3.detectOverflow ? platform3 : {
5414      ...platform3,
5415      detectOverflow
5416    };
5417    const rtl = await (platform3.isRTL == null ? void 0 : platform3.isRTL(floating));
5418    let rects = await platform3.getElementRects({
5419      reference,
5420      floating,
5421      strategy
5422    });
5423    let {
5424      x,
5425      y
5426    } = computeCoordsFromPlacement(rects, placement, rtl);
5427    let statefulPlacement = placement;
5428    let resetCount = 0;
5429    const middlewareData = {};
5430    for (let i = 0; i < middleware.length; i++) {
5431      const currentMiddleware = middleware[i];
5432      if (!currentMiddleware) {
5433        continue;
5434      }
5435      const {
5436        name,
5437        fn
5438      } = currentMiddleware;
5439      const {
5440        x: nextX,
5441        y: nextY,
5442        data,
5443        reset
5444      } = await fn({
5445        x,
5446        y,
5447        initialPlacement: placement,
5448        placement: statefulPlacement,
5449        strategy,
5450        middlewareData,
5451        rects,
5452        platform: platformWithDetectOverflow,
5453        elements: {
5454          reference,
5455          floating
5456        }
5457      });
5458      x = nextX != null ? nextX : x;
5459      y = nextY != null ? nextY : y;
5460      middlewareData[name] = {
5461        ...middlewareData[name],
5462        ...data
5463      };
5464      if (reset && resetCount < MAX_RESET_COUNT) {
5465        resetCount++;
5466        if (typeof reset === "object") {
5467          if (reset.placement) {
5468            statefulPlacement = reset.placement;
5469          }
5470          if (reset.rects) {
5471            rects = reset.rects === true ? await platform3.getElementRects({
5472              reference,
5473              floating,
5474              strategy
5475            }) : reset.rects;
5476          }
5477          ({
5478            x,
5479            y
5480          } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
5481        }
5482        i = -1;
5483      }
5484    }
5485    return {
5486      x,
5487      y,
5488      placement: statefulPlacement,
5489      strategy,
5490      middlewareData
5491    };
5492  };
5493  var flip = function(options) {
5494    if (options === void 0) {
5495      options = {};
5496    }
5497    return {
5498      name: "flip",
5499      options,
5500      async fn(state) {
5501        var _middlewareData$arrow, _middlewareData$flip;
5502        const {
5503          placement,
5504          middlewareData,
5505          rects,
5506          initialPlacement,
5507          platform: platform3,
5508          elements
5509        } = state;
5510        const {
5511          mainAxis: checkMainAxis = true,
5512          crossAxis: checkCrossAxis = true,
5513          fallbackPlacements: specifiedFallbackPlacements,
5514          fallbackStrategy = "bestFit",
5515          fallbackAxisSideDirection = "none",
5516          flipAlignment = true,
5517          ...detectOverflowOptions
5518        } = evaluate(options, state);
5519        if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
5520          return {};
5521        }
5522        const side = getSide(placement);
5523        const initialSideAxis = getSideAxis(initialPlacement);
5524        const isBasePlacement = getSide(initialPlacement) === initialPlacement;
5525        const rtl = await (platform3.isRTL == null ? void 0 : platform3.isRTL(elements.floating));
5526        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
5527        const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
5528        if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
5529          fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
5530        }
5531        const placements2 = [initialPlacement, ...fallbackPlacements];
5532        const overflow = await platform3.detectOverflow(state, detectOverflowOptions);
5533        const overflows = [];
5534        let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
5535        if (checkMainAxis) {
5536          overflows.push(overflow[side]);
5537        }
5538        if (checkCrossAxis) {
5539          const sides2 = getAlignmentSides(placement, rects, rtl);
5540          overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
5541        }
5542        overflowsData = [...overflowsData, {
5543          placement,
5544          overflows
5545        }];
5546        if (!overflows.every((side2) => side2 <= 0)) {
5547          var _middlewareData$flip2, _overflowsData$filter;
5548          const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
5549          const nextPlacement = placements2[nextIndex];
5550          if (nextPlacement) {
5551            const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
5552            if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
5553            // overflows the main axis.
5554            overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
5555              return {
5556                data: {
5557                  index: nextIndex,
5558                  overflows: overflowsData
5559                },
5560                reset: {
5561                  placement: nextPlacement
5562                }
5563              };
5564            }
5565          }
5566          let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
5567          if (!resetPlacement) {
5568            switch (fallbackStrategy) {
5569              case "bestFit": {
5570                var _overflowsData$filter2;
5571                const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
5572                  if (hasFallbackAxisSideDirection) {
5573                    const currentSideAxis = getSideAxis(d.placement);
5574                    return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
5575                    // reading directions favoring greater width.
5576                    currentSideAxis === "y";
5577                  }
5578                  return true;
5579                }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
5580                if (placement2) {
5581                  resetPlacement = placement2;
5582                }
5583                break;
5584              }
5585              case "initialPlacement":
5586                resetPlacement = initialPlacement;
5587                break;
5588            }
5589          }
5590          if (placement !== resetPlacement) {
5591            return {
5592              reset: {
5593                placement: resetPlacement
5594              }
5595            };
5596          }
5597        }
5598        return {};
5599      }
5600    };
5601  };
5602  var originSides = /* @__PURE__ */ new Set(["left", "top"]);
5603  async function convertValueToCoords(state, options) {
5604    const {
5605      placement,
5606      platform: platform3,
5607      elements
5608    } = state;
5609    const rtl = await (platform3.isRTL == null ? void 0 : platform3.isRTL(elements.floating));
5610    const side = getSide(placement);
5611    const alignment = getAlignment(placement);
5612    const isVertical = getSideAxis(placement) === "y";
5613    const mainAxisMulti = originSides.has(side) ? -1 : 1;
5614    const crossAxisMulti = rtl && isVertical ? -1 : 1;
5615    const rawValue = evaluate(options, state);
5616    let {
5617      mainAxis,
5618      crossAxis,
5619      alignmentAxis
5620    } = typeof rawValue === "number" ? {
5621      mainAxis: rawValue,
5622      crossAxis: 0,
5623      alignmentAxis: null
5624    } : {
5625      mainAxis: rawValue.mainAxis || 0,
5626      crossAxis: rawValue.crossAxis || 0,
5627      alignmentAxis: rawValue.alignmentAxis
5628    };
5629    if (alignment && typeof alignmentAxis === "number") {
5630      crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
5631    }
5632    return isVertical ? {
5633      x: crossAxis * crossAxisMulti,
5634      y: mainAxis * mainAxisMulti
5635    } : {
5636      x: mainAxis * mainAxisMulti,
5637      y: crossAxis * crossAxisMulti
5638    };
5639  }
5640  var offset = function(options) {
5641    if (options === void 0) {
5642      options = 0;
5643    }
5644    return {
5645      name: "offset",
5646      options,
5647      async fn(state) {
5648        var _middlewareData$offse, _middlewareData$arrow;
5649        const {
5650          x,
5651          y,
5652          placement,
5653          middlewareData
5654        } = state;
5655        const diffCoords = await convertValueToCoords(state, options);
5656        if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
5657          return {};
5658        }
5659        return {
5660          x: x + diffCoords.x,
5661          y: y + diffCoords.y,
5662          data: {
5663            ...diffCoords,
5664            placement
5665          }
5666        };
5667      }
5668    };
5669  };
5670  var shift = function(options) {
5671    if (options === void 0) {
5672      options = {};
5673    }
5674    return {
5675      name: "shift",
5676      options,
5677      async fn(state) {
5678        const {
5679          x,
5680          y,
5681          placement,
5682          platform: platform3
5683        } = state;
5684        const {
5685          mainAxis: checkMainAxis = true,
5686          crossAxis: checkCrossAxis = false,
5687          limiter = {
5688            fn: (_ref) => {
5689              let {
5690                x: x2,
5691                y: y2
5692              } = _ref;
5693              return {
5694                x: x2,
5695                y: y2
5696              };
5697            }
5698          },
5699          ...detectOverflowOptions
5700        } = evaluate(options, state);
5701        const coords = {
5702          x,
5703          y
5704        };
5705        const overflow = await platform3.detectOverflow(state, detectOverflowOptions);
5706        const crossAxis = getSideAxis(placement);
5707        const mainAxis = getOppositeAxis(crossAxis);
5708        let mainAxisCoord = coords[mainAxis];
5709        let crossAxisCoord = coords[crossAxis];
5710        const clampCoord = (axis, coord) => clamp(coord + overflow[axis === "y" ? "top" : "left"], coord, coord - overflow[axis === "y" ? "bottom" : "right"]);
5711        if (checkMainAxis) {
5712          mainAxisCoord = clampCoord(mainAxis, mainAxisCoord);
5713        }
5714        if (checkCrossAxis) {
5715          crossAxisCoord = clampCoord(crossAxis, crossAxisCoord);
5716        }
5717        const limitedCoords = limiter.fn({
5718          ...state,
5719          [mainAxis]: mainAxisCoord,
5720          [crossAxis]: crossAxisCoord
5721        });
5722        return {
5723          ...limitedCoords,
5724          data: {
5725            x: limitedCoords.x - x,
5726            y: limitedCoords.y - y,
5727            enabled: {
5728              [mainAxis]: checkMainAxis,
5729              [crossAxis]: checkCrossAxis
5730            }
5731          }
5732        };
5733      }
5734    };
5735  };
5736  var limitShift = function(options) {
5737    if (options === void 0) {
5738      options = {};
5739    }
5740    return {
5741      options,
5742      fn(state) {
5743        var _rawOffset$mainAxis, _rawOffset$crossAxis;
5744        const {
5745          x,
5746          y,
5747          placement,
5748          rects,
5749          middlewareData
5750        } = state;
5751        const {
5752          offset: offset4 = 0,
5753          mainAxis: checkMainAxis = true,
5754          crossAxis: checkCrossAxis = true
5755        } = evaluate(options, state);
5756        const coords = {
5757          x,
5758          y
5759        };
5760        const crossAxis = getSideAxis(placement);
5761        const mainAxis = getOppositeAxis(crossAxis);
5762        let mainAxisCoord = coords[mainAxis];
5763        let crossAxisCoord = coords[crossAxis];
5764        const rawOffset = evaluate(offset4, state);
5765        const computedOffset = typeof rawOffset === "number" ? {
5766          mainAxis: rawOffset,
5767          crossAxis: 0
5768        } : {
5769          mainAxis: (_rawOffset$mainAxis = rawOffset.mainAxis) != null ? _rawOffset$mainAxis : 0,
5770          crossAxis: (_rawOffset$crossAxis = rawOffset.crossAxis) != null ? _rawOffset$crossAxis : 0
5771        };
5772        if (checkMainAxis) {
5773          const len = mainAxis === "y" ? "height" : "width";
5774          const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
5775          const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
5776          if (mainAxisCoord < limitMin) {
5777            mainAxisCoord = limitMin;
5778          } else if (mainAxisCoord > limitMax) {
5779            mainAxisCoord = limitMax;
5780          }
5781        }
5782        if (checkCrossAxis) {
5783          var _middlewareData$offse, _middlewareData$offse2;
5784          const len = mainAxis === "y" ? "width" : "height";
5785          const isOriginSide = originSides.has(getSide(placement));
5786          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);
5787          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);
5788          if (crossAxisCoord < limitMin) {
5789            crossAxisCoord = limitMin;
5790          } else if (crossAxisCoord > limitMax) {
5791            crossAxisCoord = limitMax;
5792          }
5793        }
5794        return {
5795          [mainAxis]: mainAxisCoord,
5796          [crossAxis]: crossAxisCoord
5797        };
5798      }
5799    };
5800  };
5801  var size = function(options) {
5802    if (options === void 0) {
5803      options = {};
5804    }
5805    return {
5806      name: "size",
5807      options,
5808      async fn(state) {
5809        const {
5810          placement,
5811          rects,
5812          platform: platform3,
5813          elements
5814        } = state;
5815        const {
5816          apply = () => {
5817          },
5818          ...detectOverflowOptions
5819        } = evaluate(options, state);
5820        const overflow = await platform3.detectOverflow(state, detectOverflowOptions);
5821        const side = getSide(placement);
5822        const alignment = getAlignment(placement);
5823        const isYAxis = getSideAxis(placement) === "y";
5824        const {
5825          width,
5826          height
5827        } = rects.floating;
5828        let heightSide;
5829        let widthSide;
5830        if (side === "top" || side === "bottom") {
5831          heightSide = side;
5832          widthSide = alignment === (await (platform3.isRTL == null ? void 0 : platform3.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
5833        } else {
5834          widthSide = side;
5835          heightSide = alignment === "end" ? "top" : "bottom";
5836        }
5837        const maximumClippingHeight = height - overflow.top - overflow.bottom;
5838        const maximumClippingWidth = width - overflow.left - overflow.right;
5839        const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
5840        const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
5841        const shiftData = state.middlewareData.shift;
5842        const noShift = !shiftData;
5843        let availableHeight2 = overflowAvailableHeight;
5844        let availableWidth2 = overflowAvailableWidth;
5845        if (shiftData != null && shiftData.enabled.x) {
5846          availableWidth2 = maximumClippingWidth;
5847        }
5848        if (shiftData != null && shiftData.enabled.y) {
5849          availableHeight2 = maximumClippingHeight;
5850        }
5851        if (noShift && !alignment) {
5852          if (isYAxis) {
5853            availableWidth2 = width - 2 * max(overflow.left, overflow.right);
5854          } else {
5855            availableHeight2 = height - 2 * max(overflow.top, overflow.bottom);
5856          }
5857        }
5858        await apply({
5859          ...state,
5860          availableWidth: availableWidth2,
5861          availableHeight: availableHeight2
5862        });
5863        const nextDimensions = await platform3.getDimensions(elements.floating);
5864        if (width !== nextDimensions.width || height !== nextDimensions.height) {
5865          return {
5866            reset: {
5867              rects: true
5868            }
5869          };
5870        }
5871        return {};
5872      }
5873    };
5874  };
5875  
5876  // node_modules/.store/@floating-ui/dom@1.8.0-vHXcr4FgWneV0cgwFw-d7A/node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
5877  function getCssDimensions(element) {
5878    const css = getComputedStyle2(element);
5879    let width = parseFloat(css.width) || 0;
5880    let height = parseFloat(css.height) || 0;
5881    const hasOffset = isHTMLElement(element);
5882    const offsetWidth = hasOffset ? element.offsetWidth : width;
5883    const offsetHeight = hasOffset ? element.offsetHeight : height;
5884    const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
5885    if (shouldFallback) {
5886      width = offsetWidth;
5887      height = offsetHeight;
5888    }
5889    return {
5890      width,
5891      height,
5892      $: shouldFallback
5893    };
5894  }
5895  function unwrapElement(element) {
5896    return !isElement(element) ? element.contextElement : element;
5897  }
5898  function getScale(element) {
5899    const domElement = unwrapElement(element);
5900    if (!isHTMLElement(domElement)) {
5901      return createCoords(1);
5902    }
5903    const rect = domElement.getBoundingClientRect();
5904    const {
5905      width,
5906      height,
5907      $
5908    } = getCssDimensions(domElement);
5909    let x = ($ ? round(rect.width) : rect.width) / width;
5910    let y = ($ ? round(rect.height) : rect.height) / height;
5911    if (!x || !Number.isFinite(x)) {
5912      x = 1;
5913    }
5914    if (!y || !Number.isFinite(y)) {
5915      y = 1;
5916    }
5917    return {
5918      x,
5919      y
5920    };
5921  }
5922  var noOffsets = /* @__PURE__ */ createCoords(0);
5923  function getVisualOffsets(element) {
5924    const win = getWindow(element);
5925    if (!isWebKit() || !win.visualViewport) {
5926      return noOffsets;
5927    }
5928    return {
5929      x: win.visualViewport.offsetLeft,
5930      y: win.visualViewport.offsetTop
5931    };
5932  }
5933  function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
5934    if (isFixed === void 0) {
5935      isFixed = false;
5936    }
5937    return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow(element);
5938  }
5939  function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
5940    if (includeScale === void 0) {
5941      includeScale = false;
5942    }
5943    if (isFixedStrategy === void 0) {
5944      isFixedStrategy = false;
5945    }
5946    const clientRect = element.getBoundingClientRect();
5947    const domElement = unwrapElement(element);
5948    let scale = createCoords(1);
5949    if (includeScale) {
5950      if (offsetParent) {
5951        if (isElement(offsetParent)) {
5952          scale = getScale(offsetParent);
5953        }
5954      } else {
5955        scale = getScale(element);
5956      }
5957    }
5958    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
5959    let x = (clientRect.left + visualOffsets.x) / scale.x;
5960    let y = (clientRect.top + visualOffsets.y) / scale.y;
5961    let width = clientRect.width / scale.x;
5962    let height = clientRect.height / scale.y;
5963    if (domElement && offsetParent) {
5964      const win = getWindow(domElement);
5965      const offsetWin = isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
5966      let currentWin = win;
5967      let currentIFrame = getFrameElement(currentWin);
5968      while (currentIFrame && offsetWin !== currentWin) {
5969        const iframeScale = getScale(currentIFrame);
5970        const iframeRect = currentIFrame.getBoundingClientRect();
5971        const css = getComputedStyle2(currentIFrame);
5972        const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
5973        const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
5974        x *= iframeScale.x;
5975        y *= iframeScale.y;
5976        width *= iframeScale.x;
5977        height *= iframeScale.y;
5978        x += left;
5979        y += top;
5980        currentWin = getWindow(currentIFrame);
5981        currentIFrame = getFrameElement(currentWin);
5982      }
5983    }
5984    return rectToClientRect({
5985      width,
5986      height,
5987      x,
5988      y
5989    });
5990  }
5991  function getWindowScrollBarX(element, rect) {
5992    const leftScroll = getNodeScroll(element).scrollLeft;
5993    if (!rect) {
5994      return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
5995    }
5996    return rect.left + leftScroll;
5997  }
5998  function getHTMLOffset(documentElement, scroll) {
5999    const htmlRect = documentElement.getBoundingClientRect();
6000    const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
6001    const y = htmlRect.top + scroll.scrollTop;
6002    return {
6003      x,
6004      y
6005    };
6006  }
6007  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
6008    let {
6009      elements,
6010      rect,
6011      offsetParent,
6012      strategy
6013    } = _ref;
6014    const isFixed = strategy === "fixed";
6015    const documentElement = getDocumentElement(offsetParent);
6016    const topLayer = elements ? isTopLayer(elements.floating) : false;
6017    if (offsetParent === documentElement || topLayer && isFixed) {
6018      return rect;
6019    }
6020    let scroll = {
6021      scrollLeft: 0,
6022      scrollTop: 0
6023    };
6024    let scale = createCoords(1);
6025    const offsets = createCoords(0);
6026    const isOffsetParentAnElement = isHTMLElement(offsetParent);
6027    if (isOffsetParentAnElement || !isFixed) {
6028      if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
6029        scroll = getNodeScroll(offsetParent);
6030      }
6031      if (isOffsetParentAnElement) {
6032        const offsetRect = getBoundingClientRect(offsetParent);
6033        scale = getScale(offsetParent);
6034        offsets.x = offsetRect.x + offsetParent.clientLeft;
6035        offsets.y = offsetRect.y + offsetParent.clientTop;
6036      }
6037    }
6038    const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
6039    return {
6040      width: rect.width * scale.x,
6041      height: rect.height * scale.y,
6042      x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
6043      y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
6044    };
6045  }
6046  function getClientRects(element) {
6047    return element.getClientRects ? Array.from(element.getClientRects()) : [];
6048  }
6049  function getDocumentRect(html) {
6050    const scroll = getNodeScroll(html);
6051    const body = html.ownerDocument.body;
6052    const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
6053    const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
6054    let x = -scroll.scrollLeft + getWindowScrollBarX(html);
6055    const y = -scroll.scrollTop;
6056    if (getComputedStyle2(body).direction === "rtl") {
6057      x += max(html.clientWidth, body.clientWidth) - width;
6058    }
6059    return {
6060      width,
6061      height,
6062      x,
6063      y
6064    };
6065  }
6066  var SCROLLBAR_MAX = 25;
6067  function getViewportRect(element, strategy, rootBoundary) {
6068    if (rootBoundary === void 0) {
6069      rootBoundary = "viewport";
6070    }
6071    const isLayoutViewport = rootBoundary === "layoutViewport";
6072    const win = getWindow(element);
6073    const html = getDocumentElement(element);
6074    const visualViewport = win.visualViewport;
6075    let width = html.clientWidth;
6076    let height = html.clientHeight;
6077    let x = 0;
6078    let y = 0;
6079    if (visualViewport) {
6080      const layoutRelativeClientCoords = !isWebKit() || strategy === "fixed";
6081      if (isLayoutViewport) {
6082        if (!layoutRelativeClientCoords) {
6083          x = -visualViewport.offsetLeft;
6084          y = -visualViewport.offsetTop;
6085        }
6086      } else {
6087        width = visualViewport.width;
6088        height = visualViewport.height;
6089        if (layoutRelativeClientCoords) {
6090          x = visualViewport.offsetLeft;
6091          y = visualViewport.offsetTop;
6092        }
6093      }
6094    }
6095    const windowScrollbarX = getWindowScrollBarX(html);
6096    if (windowScrollbarX <= 0) {
6097      const doc = html.ownerDocument;
6098      const body = doc.body;
6099      const bodyStyles = getComputedStyle(body);
6100      const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
6101      const reservedWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
6102      const gutter = getComputedStyle(html).scrollbarGutter === "stable both-edges" ? reservedWidth / 2 : reservedWidth;
6103      if (gutter <= SCROLLBAR_MAX) {
6104        width -= gutter;
6105      }
6106    }
6107    return {
6108      width,
6109      height,
6110      x,
6111      y
6112    };
6113  }
6114  function getInnerBoundingClientRect(element, strategy) {
6115    const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
6116    const top = clientRect.top + element.clientTop;
6117    const left = clientRect.left + element.clientLeft;
6118    const scale = getScale(element);
6119    const width = element.clientWidth * scale.x;
6120    const height = element.clientHeight * scale.y;
6121    const x = left * scale.x;
6122    const y = top * scale.y;
6123    return {
6124      width,
6125      height,
6126      x,
6127      y
6128    };
6129  }
6130  function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
6131    let rect;
6132    if (clippingAncestor === "viewport" || clippingAncestor === "layoutViewport") {
6133      rect = getViewportRect(element, strategy, clippingAncestor);
6134    } else if (clippingAncestor === "document") {
6135      rect = getDocumentRect(getDocumentElement(element));
6136    } else if (isElement(clippingAncestor)) {
6137      rect = getInnerBoundingClientRect(clippingAncestor, strategy);
6138    } else {
6139      const visualOffsets = getVisualOffsets(element);
6140      rect = {
6141        x: clippingAncestor.x - visualOffsets.x,
6142        y: clippingAncestor.y - visualOffsets.y,
6143        width: clippingAncestor.width,
6144        height: clippingAncestor.height
6145      };
6146    }
6147    return rectToClientRect(rect);
6148  }
6149  function getClippingElementAncestors(element, cache) {
6150    const cachedResult = cache.get(element);
6151    if (cachedResult) {
6152      return cachedResult;
6153    }
6154    let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
6155    let lastKeptComputedStyle = null;
6156    const elementIsFixed = getComputedStyle2(element).position === "fixed";
6157    let currentNode = elementIsFixed ? getParentNode(element) : element;
6158    while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
6159      const computedStyle = getComputedStyle2(currentNode);
6160      const currentNodeIsContaining = isContainingBlock(currentNode);
6161      const lastPosition = lastKeptComputedStyle ? lastKeptComputedStyle.position : elementIsFixed ? "fixed" : "";
6162      const shouldDropCurrentNode = !currentNodeIsContaining && (lastPosition === "fixed" || lastPosition === "absolute" && computedStyle.position === "static");
6163      if (shouldDropCurrentNode) {
6164        result = result.filter((ancestor) => ancestor !== currentNode);
6165      } else {
6166        lastKeptComputedStyle = computedStyle;
6167      }
6168      currentNode = getParentNode(currentNode);
6169    }
6170    cache.set(element, result);
6171    return result;
6172  }
6173  function getClippingRect(_ref) {
6174    let {
6175      element,
6176      boundary,
6177      rootBoundary,
6178      strategy
6179    } = _ref;
6180    const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
6181    const clippingAncestors = [...elementClippingAncestors, rootBoundary];
6182    const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
6183    let top = firstRect.top;
6184    let right = firstRect.right;
6185    let bottom = firstRect.bottom;
6186    let left = firstRect.left;
6187    for (let i = 1; i < clippingAncestors.length; i++) {
6188      const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
6189      top = max(rect.top, top);
6190      right = min(rect.right, right);
6191      bottom = min(rect.bottom, bottom);
6192      left = max(rect.left, left);
6193    }
6194    return {
6195      width: right - left,
6196      height: bottom - top,
6197      x: left,
6198      y: top
6199    };
6200  }
6201  function getDimensions(element) {
6202    const {
6203      width,
6204      height
6205    } = getCssDimensions(element);
6206    return {
6207      width,
6208      height
6209    };
6210  }
6211  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
6212    const isOffsetParentAnElement = isHTMLElement(offsetParent);
6213    const documentElement = getDocumentElement(offsetParent);
6214    const isFixed = strategy === "fixed";
6215    const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
6216    let scroll = {
6217      scrollLeft: 0,
6218      scrollTop: 0
6219    };
6220    const offsets = createCoords(0);
6221    if (isOffsetParentAnElement || !isFixed) {
6222      if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
6223        scroll = getNodeScroll(offsetParent);
6224      }
6225      if (isOffsetParentAnElement) {
6226        const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
6227        offsets.x = offsetRect.x + offsetParent.clientLeft;
6228        offsets.y = offsetRect.y + offsetParent.clientTop;
6229      }
6230    }
6231    if (!isOffsetParentAnElement && documentElement) {
6232      offsets.x = getWindowScrollBarX(documentElement);
6233    }
6234    const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
6235    const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
6236    const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
6237    return {
6238      x,
6239      y,
6240      width: rect.width,
6241      height: rect.height
6242    };
6243  }
6244  function isStaticPositioned(element) {
6245    return getComputedStyle2(element).position === "static";
6246  }
6247  function getTrueOffsetParent(element, polyfill) {
6248    if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") {
6249      return null;
6250    }
6251    if (polyfill) {
6252      return polyfill(element);
6253    }
6254    let rawOffsetParent = element.offsetParent;
6255    if (getDocumentElement(element) === rawOffsetParent) {
6256      rawOffsetParent = rawOffsetParent.ownerDocument.body;
6257    }
6258    return rawOffsetParent;
6259  }
6260  function getOffsetParent(element, polyfill) {
6261    const win = getWindow(element);
6262    if (isTopLayer(element)) {
6263      return win;
6264    }
6265    if (!isHTMLElement(element)) {
6266      let svgOffsetParent = getParentNode(element);
6267      while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
6268        if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
6269          return svgOffsetParent;
6270        }
6271        svgOffsetParent = getParentNode(svgOffsetParent);
6272      }
6273      return win;
6274    }
6275    let offsetParent = getTrueOffsetParent(element, polyfill);
6276    while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
6277      offsetParent = getTrueOffsetParent(offsetParent, polyfill);
6278    }
6279    if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
6280      return win;
6281    }
6282    return offsetParent || getContainingBlock(element) || win;
6283  }
6284  var getElementRects = async function(data) {
6285    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
6286    const getDimensionsFn = this.getDimensions;
6287    const floatingDimensions = await getDimensionsFn(data.floating);
6288    return {
6289      reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
6290      floating: {
6291        x: 0,
6292        y: 0,
6293        width: floatingDimensions.width,
6294        height: floatingDimensions.height
6295      }
6296    };
6297  };
6298  function isRTL(element) {
6299    return getComputedStyle2(element).direction === "rtl";
6300  }
6301  var platform2 = {
6302    convertOffsetParentRelativeRectToViewportRelativeRect,
6303    getDocumentElement,
6304    getClippingRect,
6305    getOffsetParent,
6306    getElementRects,
6307    getClientRects,
6308    getDimensions,
6309    getScale,
6310    isElement,
6311    isRTL
6312  };
6313  function rectsAreEqual(a, b) {
6314    return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
6315  }
6316  function observeMove(element, onMove, ancestorResize) {
6317    let io = null;
6318    let timeoutId;
6319    const root = getDocumentElement(element);
6320    function cleanup() {
6321      var _io;
6322      clearTimeout(timeoutId);
6323      (_io = io) == null || _io.disconnect();
6324      io = null;
6325    }
6326    function refresh(skip, threshold) {
6327      if (skip === void 0) {
6328        skip = false;
6329      }
6330      if (threshold === void 0) {
6331        threshold = 1;
6332      }
6333      cleanup();
6334      const elementRectForRootMargin = element.getBoundingClientRect();
6335      const {
6336        left,
6337        top,
6338        width,
6339        height
6340      } = elementRectForRootMargin;
6341      if (!skip) {
6342        onMove();
6343      }
6344      if (!width || !height) {
6345        return;
6346      }
6347      const insetTop = floor(top);
6348      const insetRight = floor(root.clientWidth - (left + width));
6349      const insetBottom = floor(root.clientHeight - (top + height));
6350      const insetLeft = floor(left);
6351      const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
6352      const options = {
6353        rootMargin,
6354        threshold: max(0, min(1, threshold)) || 1
6355      };
6356      let isFirstUpdate = true;
6357      function handleObserve(entries) {
6358        const ratio = entries[0].intersectionRatio;
6359        if (!rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
6360          return refresh();
6361        }
6362        if (ratio !== threshold) {
6363          if (!isFirstUpdate) {
6364            return refresh();
6365          }
6366          if (!ratio) {
6367            timeoutId = setTimeout(() => {
6368              refresh(false, 1e-7);
6369            }, 1e3);
6370          } else {
6371            refresh(false, ratio);
6372          }
6373        }
6374        isFirstUpdate = false;
6375      }
6376      try {
6377        io = new IntersectionObserver(handleObserve, {
6378          ...options,
6379          // Handle <iframe>s
6380          root: root.ownerDocument
6381        });
6382      } catch (_e) {
6383        io = new IntersectionObserver(handleObserve, options);
6384      }
6385      io.observe(element);
6386    }
6387    const win = getWindow(element);
6388    const handleResize = () => refresh(ancestorResize);
6389    win.addEventListener("resize", handleResize);
6390    refresh(true);
6391    return () => {
6392      win.removeEventListener("resize", handleResize);
6393      cleanup();
6394    };
6395  }
6396  function autoUpdate(reference, floating, update2, options) {
6397    if (options === void 0) {
6398      options = {};
6399    }
6400    const {
6401      ancestorScroll = true,
6402      ancestorResize = true,
6403      elementResize = typeof ResizeObserver === "function",
6404      layoutShift = typeof IntersectionObserver === "function",
6405      animationFrame = false
6406    } = options;
6407    const referenceEl = unwrapElement(reference);
6408    const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
6409    ancestors.forEach((ancestor) => {
6410      ancestorScroll && ancestor.addEventListener("scroll", update2);
6411      ancestorResize && ancestor.addEventListener("resize", update2);
6412    });
6413    const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update2, ancestorResize) : null;
6414    let reobserveFrame = -1;
6415    let resizeObserver = null;
6416    if (elementResize) {
6417      resizeObserver = new ResizeObserver((_ref) => {
6418        let [firstEntry] = _ref;
6419        if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
6420          resizeObserver.unobserve(floating);
6421          cancelAnimationFrame(reobserveFrame);
6422          reobserveFrame = requestAnimationFrame(() => {
6423            var _resizeObserver;
6424            (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
6425          });
6426        }
6427        update2();
6428      });
6429      if (referenceEl && !animationFrame) {
6430        resizeObserver.observe(referenceEl);
6431      }
6432      if (floating) {
6433        resizeObserver.observe(floating);
6434      }
6435    }
6436    let frameId;
6437    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
6438    if (animationFrame) {
6439      frameLoop();
6440    }
6441    function frameLoop() {
6442      const nextRefRect = getBoundingClientRect(reference);
6443      if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
6444        update2();
6445      }
6446      prevRefRect = nextRefRect;
6447      frameId = requestAnimationFrame(frameLoop);
6448    }
6449    update2();
6450    return () => {
6451      var _resizeObserver2;
6452      ancestors.forEach((ancestor) => {
6453        ancestorScroll && ancestor.removeEventListener("scroll", update2);
6454        ancestorResize && ancestor.removeEventListener("resize", update2);
6455      });
6456      cleanupIo == null || cleanupIo();
6457      (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
6458      resizeObserver = null;
6459      if (animationFrame) {
6460        cancelAnimationFrame(frameId);
6461      }
6462    };
6463  }
6464  var offset2 = offset;
6465  var shift2 = shift;
6466  var flip2 = flip;
6467  var size2 = size;
6468  var limitShift2 = limitShift;
6469  var computePosition2 = (reference, floating, options) => {
6470    const cache = /* @__PURE__ */ new Map();
6471    const mergedOptions = options != null ? options : {};
6472    const platformWithCache = {
6473      ...platform2,
6474      ...mergedOptions.platform,
6475      _c: cache
6476    };
6477    return computePosition(reference, floating, {
6478      ...mergedOptions,
6479      platform: platformWithCache
6480    });
6481  };
6482  
6483  // node_modules/.store/@floating-ui/react-dom@2.1.9-AxWcAwqlMfOrAFOinFKSVg/node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
6484  var React27 = __toESM(require_react(), 1);
6485  var import_react2 = __toESM(require_react(), 1);
6486  var ReactDOM5 = __toESM(require_react_dom(), 1);
6487  var isClient = typeof document !== "undefined";
6488  var noop2 = function noop3() {
6489  };
6490  var index = isClient ? import_react2.useLayoutEffect : noop2;
6491  function deepEqual(a, b) {
6492    if (a === b) {
6493      return true;
6494    }
6495    if (typeof a !== typeof b) {
6496      return false;
6497    }
6498    if (typeof a === "function" && a.toString() === b.toString()) {
6499      return true;
6500    }
6501    let length;
6502    let i;
6503    let keys;
6504    if (a && b && typeof a === "object") {
6505      if (Array.isArray(a)) {
6506        length = a.length;
6507        if (length !== b.length) return false;
6508        for (i = length; i-- !== 0; ) {
6509          if (!deepEqual(a[i], b[i])) {
6510            return false;
6511          }
6512        }
6513        return true;
6514      }
6515      keys = Object.keys(a);
6516      length = keys.length;
6517      if (length !== Object.keys(b).length) {
6518        return false;
6519      }
6520      for (i = length; i-- !== 0; ) {
6521        if (!{}.hasOwnProperty.call(b, keys[i])) {
6522          return false;
6523        }
6524      }
6525      for (i = length; i-- !== 0; ) {
6526        const key = keys[i];
6527        if (key === "_owner" && a.$$typeof) {
6528          continue;
6529        }
6530        if (!deepEqual(a[key], b[key])) {
6531          return false;
6532        }
6533      }
6534      return true;
6535    }
6536    return a !== a && b !== b;
6537  }
6538  function getDPR(element) {
6539    if (typeof window === "undefined") {
6540      return 1;
6541    }
6542    const win = element.ownerDocument.defaultView || window;
6543    return win.devicePixelRatio || 1;
6544  }
6545  function roundByDPR(element, value) {
6546    const dpr = getDPR(element);
6547    return Math.round(value * dpr) / dpr;
6548  }
6549  function useLatestRef(value) {
6550    const ref = React27.useRef(value);
6551    index(() => {
6552      ref.current = value;
6553    });
6554    return ref;
6555  }
6556  function useFloating(options) {
6557    if (options === void 0) {
6558      options = {};
6559    }
6560    const {
6561      placement = "bottom",
6562      strategy = "absolute",
6563      middleware = [],
6564      platform: platform3,
6565      elements: {
6566        reference: externalReference,
6567        floating: externalFloating
6568      } = {},
6569      transform = true,
6570      whileElementsMounted,
6571      open: open2
6572    } = options;
6573    const [data, setData] = React27.useState({
6574      x: 0,
6575      y: 0,
6576      strategy,
6577      placement,
6578      middlewareData: {},
6579      isPositioned: false
6580    });
6581    const [latestMiddleware, setLatestMiddleware] = React27.useState(middleware);
6582    if (!deepEqual(latestMiddleware, middleware)) {
6583      setLatestMiddleware(middleware);
6584    }
6585    const [_reference, _setReference] = React27.useState(null);
6586    const [_floating, _setFloating] = React27.useState(null);
6587    const setReference = React27.useCallback((node) => {
6588      if (node !== referenceRef.current) {
6589        referenceRef.current = node;
6590        _setReference(node);
6591      }
6592    }, []);
6593    const setFloating = React27.useCallback((node) => {
6594      if (node !== floatingRef.current) {
6595        floatingRef.current = node;
6596        _setFloating(node);
6597      }
6598    }, []);
6599    const referenceEl = externalReference || _reference;
6600    const floatingEl = externalFloating || _floating;
6601    const referenceRef = React27.useRef(null);
6602    const floatingRef = React27.useRef(null);
6603    const dataRef = React27.useRef(data);
6604    const hasWhileElementsMounted = whileElementsMounted != null;
6605    const whileElementsMountedRef = useLatestRef(whileElementsMounted);
6606    const platformRef = useLatestRef(platform3);
6607    const openRef = useLatestRef(open2);
6608    const update2 = React27.useCallback(() => {
6609      if (!referenceRef.current || !floatingRef.current) {
6610        return;
6611      }
6612      const config = {
6613        placement,
6614        strategy,
6615        middleware: latestMiddleware
6616      };
6617      if (platformRef.current) {
6618        config.platform = platformRef.current;
6619      }
6620      computePosition2(referenceRef.current, floatingRef.current, config).then((data2) => {
6621        const fullData = {
6622          ...data2,
6623          // The floating element's position may be recomputed while it's closed
6624          // but still mounted (such as when transitioning out). To ensure
6625          // `isPositioned` will be `false` initially on the next open, avoid
6626          // setting it to `true` when `open === false` (must be specified).
6627          isPositioned: openRef.current !== false
6628        };
6629        if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
6630          dataRef.current = fullData;
6631          ReactDOM5.flushSync(() => {
6632            setData(fullData);
6633          });
6634        }
6635      });
6636    }, [latestMiddleware, placement, strategy, platformRef, openRef]);
6637    index(() => {
6638      if (open2 === false && dataRef.current.isPositioned) {
6639        dataRef.current.isPositioned = false;
6640        setData((data2) => ({
6641          ...data2,
6642          isPositioned: false
6643        }));
6644      }
6645    }, [open2]);
6646    const isMountedRef = React27.useRef(false);
6647    index(() => {
6648      isMountedRef.current = true;
6649      return () => {
6650        isMountedRef.current = false;
6651      };
6652    }, []);
6653    index(() => {
6654      if (referenceEl) referenceRef.current = referenceEl;
6655      if (floatingEl) floatingRef.current = floatingEl;
6656      if (referenceEl && floatingEl) {
6657        if (whileElementsMountedRef.current) {
6658          return whileElementsMountedRef.current(referenceEl, floatingEl, update2);
6659        }
6660        update2();
6661      }
6662    }, [referenceEl, floatingEl, update2, whileElementsMountedRef, hasWhileElementsMounted]);
6663    const refs = React27.useMemo(() => ({
6664      reference: referenceRef,
6665      floating: floatingRef,
6666      setReference,
6667      setFloating
6668    }), [setReference, setFloating]);
6669    const elements = React27.useMemo(() => ({
6670      reference: referenceEl,
6671      floating: floatingEl
6672    }), [referenceEl, floatingEl]);
6673    const floatingStyles = React27.useMemo(() => {
6674      const initialStyles = {
6675        position: strategy,
6676        left: 0,
6677        top: 0
6678      };
6679      if (!elements.floating) {
6680        return initialStyles;
6681      }
6682      const x = roundByDPR(elements.floating, data.x);
6683      const y = roundByDPR(elements.floating, data.y);
6684      if (transform) {
6685        return {
6686          ...initialStyles,
6687          transform: "translate(" + x + "px, " + y + "px)",
6688          ...getDPR(elements.floating) >= 1.5 && {
6689            willChange: "transform"
6690          }
6691        };
6692      }
6693      return {
6694        position: strategy,
6695        left: x,
6696        top: y
6697      };
6698    }, [strategy, transform, elements.floating, data.x, data.y]);
6699    return React27.useMemo(() => ({
6700      ...data,
6701      update: update2,
6702      refs,
6703      elements,
6704      floatingStyles
6705    }), [data, update2, refs, elements, floatingStyles]);
6706  }
6707  var offset3 = (options, deps) => {
6708    const result = offset2(options);
6709    return {
6710      name: result.name,
6711      fn: result.fn,
6712      options: [options, deps]
6713    };
6714  };
6715  var shift3 = (options, deps) => {
6716    const result = shift2(options);
6717    return {
6718      name: result.name,
6719      fn: result.fn,
6720      options: [options, deps]
6721    };
6722  };
6723  var limitShift3 = (options, deps) => {
6724    const result = limitShift2(options);
6725    return {
6726      fn: result.fn,
6727      options: [options, deps]
6728    };
6729  };
6730  var flip3 = (options, deps) => {
6731    const result = flip2(options);
6732    return {
6733      name: result.name,
6734      fn: result.fn,
6735      options: [options, deps]
6736    };
6737  };
6738  var size3 = (options, deps) => {
6739    const result = size2(options);
6740    return {
6741      name: result.name,
6742      fn: result.fn,
6743      options: [options, deps]
6744    };
6745  };
6746  
6747  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/NullStore.mjs
6748  var NullStore = class extends ReactStore {
6749    // `update`/`set`/`notifyAll` funnel through `setState` in the base `Store`, so overriding
6750    // `setState` alone would neutralize them today. They are overridden explicitly so the store stays
6751    // inert even if a future base-class change stops routing a mutator through `setState`.
6752    setState(_newState) {
6753    }
6754    update(_changes) {
6755    }
6756    set(_key, _value) {
6757    }
6758    notifyAll() {
6759    }
6760  };
6761  
6762  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/inertValue.mjs
6763  function inertValue(value) {
6764    if (isReactVersionAtLeast(19)) {
6765      return value;
6766    }
6767    return value ? "true" : void 0;
6768  }
6769  
6770  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/direction-context/DirectionContext.mjs
6771  var React28 = __toESM(require_react(), 1);
6772  var DirectionContext = /* @__PURE__ */ React28.createContext(void 0);
6773  if (true) DirectionContext.displayName = "DirectionContext";
6774  function useDirection() {
6775    const context = React28.useContext(DirectionContext);
6776    return context?.direction ?? "ltr";
6777  }
6778  
6779  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useAnchorPositioning.mjs
6780  var React30 = __toESM(require_react(), 1);
6781  
6782  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/hooks/useFloating.mjs
6783  var React29 = __toESM(require_react(), 1);
6784  function useBaseUIFloating(options) {
6785    const {
6786      nodeId,
6787      externalTree,
6788      rootContext: store
6789    } = options;
6790    const referenceElement = store.useState("referenceElement");
6791    const floatingElement = store.useState("floatingElement");
6792    const domReferenceElement = store.useState("domReferenceElement");
6793    const open2 = store.useState("open");
6794    const floatingId = store.useState("floatingId");
6795    const [positionReference, setPositionReferenceRaw] = React29.useState(null);
6796    const domReferenceRef = React29.useRef(null);
6797    const tree = useFloatingTree(externalTree);
6798    const storeElements = React29.useMemo(() => ({
6799      reference: referenceElement,
6800      floating: floatingElement,
6801      domReference: domReferenceElement
6802    }), [referenceElement, floatingElement, domReferenceElement]);
6803    const position = useFloating({
6804      ...options,
6805      elements: {
6806        ...storeElements,
6807        ...positionReference && {
6808          reference: positionReference
6809        }
6810      }
6811    });
6812    const setPositionReference = React29.useCallback((node) => {
6813      const computedPositionReference = isElement(node) ? {
6814        getBoundingClientRect: () => node.getBoundingClientRect(),
6815        getClientRects: () => node.getClientRects(),
6816        contextElement: node
6817      } : node;
6818      setPositionReferenceRaw(computedPositionReference);
6819      position.refs.setReference(computedPositionReference);
6820    }, [position.refs]);
6821    const refs = React29.useMemo(() => ({
6822      ...position.refs,
6823      setPositionReference,
6824      domReference: domReferenceRef
6825    }), [position.refs, setPositionReference]);
6826    const elements = React29.useMemo(() => ({
6827      ...position.elements,
6828      domReference: domReferenceElement
6829    }), [position.elements, domReferenceElement]);
6830    const context = React29.useMemo(() => ({
6831      ...position,
6832      dataRef: store.context.dataRef,
6833      open: open2,
6834      onOpenChange: store.setOpen,
6835      events: store.context.events,
6836      floatingId,
6837      refs,
6838      elements,
6839      nodeId,
6840      rootStore: store
6841    }), [position, refs, elements, nodeId, store, open2, floatingId]);
6842    useIsoLayoutEffect(() => {
6843      if (domReferenceElement) {
6844        domReferenceRef.current = domReferenceElement;
6845      }
6846    }, [domReferenceElement]);
6847    useIsoLayoutEffect(() => {
6848      store.context.dataRef.current.floatingContext = context;
6849      const node = tree?.nodesRef.current.find((n) => n.id === nodeId);
6850      if (node) {
6851        node.context = context;
6852      }
6853    });
6854    return React29.useMemo(() => ({
6855      ...position,
6856      context,
6857      refs,
6858      elements,
6859      rootStore: store
6860    }), [position, refs, elements, context, store]);
6861  }
6862  
6863  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/floating-ui-react/middleware/arrow.mjs
6864  var baseArrow = (options) => ({
6865    name: "arrow",
6866    options,
6867    async fn(state) {
6868      const {
6869        x,
6870        y,
6871        placement,
6872        rects,
6873        platform: platform3,
6874        elements,
6875        middlewareData
6876      } = state;
6877      const {
6878        element,
6879        padding = 0
6880      } = evaluate(options, state) || {};
6881      if (element == null) {
6882        return {};
6883      }
6884      const paddingObject = getPaddingObject(padding);
6885      const coords = {
6886        x,
6887        y
6888      };
6889      const axis = getAlignmentAxis(placement);
6890      const length = getAxisLength(axis);
6891      const arrowDimensions = await platform3.getDimensions(element);
6892      const isYAxis = axis === "y";
6893      const minProp = isYAxis ? "top" : "left";
6894      const maxProp = isYAxis ? "bottom" : "right";
6895      const clientProp = isYAxis ? "clientHeight" : "clientWidth";
6896      const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
6897      const startDiff = coords[axis] - rects.reference[axis];
6898      const clientSize = elements.floating[clientProp] || rects.floating[length];
6899      const centerToReference = endDiff / 2 - startDiff / 2;
6900      const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
6901      const minPadding = Math.min(paddingObject[minProp], largestPossiblePadding);
6902      const maxPadding = Math.min(paddingObject[maxProp], largestPossiblePadding);
6903      const min2 = minPadding;
6904      const max2 = clientSize - arrowDimensions[length] - maxPadding;
6905      const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
6906      const offset4 = clamp(min2, center, max2);
6907      const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length] / 2 - (center < min2 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
6908      const alignmentOffset = shouldAddOffset ? center < min2 ? center - min2 : center - max2 : 0;
6909      return {
6910        [axis]: coords[axis] + alignmentOffset,
6911        data: {
6912          [axis]: offset4,
6913          centerOffset: center - offset4 - alignmentOffset,
6914          ...shouldAddOffset && {
6915            alignmentOffset
6916          }
6917        },
6918        reset: shouldAddOffset
6919      };
6920    }
6921  });
6922  var arrow4 = (options, deps) => {
6923    const {
6924      name,
6925      fn
6926    } = baseArrow(options);
6927    return {
6928      name,
6929      fn,
6930      options: [options, deps]
6931    };
6932  };
6933  
6934  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/hideMiddleware.mjs
6935  var hide4 = {
6936    name: "hide",
6937    async fn(state) {
6938      const {
6939        width,
6940        height,
6941        x,
6942        y
6943      } = state.rects.reference;
6944      const anchorHidden2 = width === 0 && height === 0 && x === 0 && y === 0;
6945      const overflow = await state.platform.detectOverflow(state, {
6946        elementContext: "reference"
6947      });
6948      const referenceHidden = overflow.top - height >= 0 || overflow.right - width >= 0 || overflow.bottom - height >= 0 || overflow.left - width >= 0;
6949      return {
6950        data: {
6951          referenceHidden: referenceHidden || anchorHidden2
6952        }
6953      };
6954    }
6955  };
6956  
6957  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/adaptiveOriginConstants.mjs
6958  var DEFAULT_SIDES = {
6959    sideX: "left",
6960    sideY: "top"
6961  };
6962  
6963  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/CommonPositionerCssVars.mjs
6964  var availableWidth = "--available-width";
6965  var availableHeight = "--available-height";
6966  var anchorWidth = "--anchor-width";
6967  var anchorHeight = "--anchor-height";
6968  var transformOrigin = "--transform-origin";
6969  var positionerWidth = "--positioner-width";
6970  var positionerHeight = "--positioner-height";
6971  
6972  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/useAnchorPositioning.mjs
6973  var AVAILABLE_WIDTH_VAR = availableWidth;
6974  var AVAILABLE_HEIGHT_VAR = availableHeight;
6975  function getLogicalSide(sideParam, renderedSide, isRtl) {
6976    const isLogicalSideParam = sideParam === "inline-start" || sideParam === "inline-end";
6977    const logicalRight = isRtl ? "inline-start" : "inline-end";
6978    const logicalLeft = isRtl ? "inline-end" : "inline-start";
6979    return {
6980      top: "top",
6981      right: isLogicalSideParam ? logicalRight : "right",
6982      bottom: "bottom",
6983      left: isLogicalSideParam ? logicalLeft : "left"
6984    }[renderedSide];
6985  }
6986  function getOffsetData(state, sideParam, isRtl) {
6987    const {
6988      rects,
6989      placement
6990    } = state;
6991    const data = {
6992      side: getLogicalSide(sideParam, getSide(placement), isRtl),
6993      align: getAlignment(placement) || "center",
6994      anchor: {
6995        width: rects.reference.width,
6996        height: rects.reference.height
6997      },
6998      positioner: {
6999        width: rects.floating.width,
7000        height: rects.floating.height
7001      }
7002    };
7003    return data;
7004  }
7005  function useAnchorPositioning(params) {
7006    return useAnchorPositioningWithHook(params, useBaseUIFloating);
7007  }
7008  function useAnchorPositioningWithHook(params, useFloatingHook) {
7009    const {
7010      // Public parameters
7011      anchor,
7012      positionMethod = "absolute",
7013      side: sideParam = "bottom",
7014      sideOffset = 0,
7015      align = "center",
7016      alignOffset = 0,
7017      collisionBoundary,
7018      collisionPadding: collisionPaddingParam = 5,
7019      sticky = false,
7020      arrowPadding = 5,
7021      disableAnchorTracking = false,
7022      inline: inlineMiddleware,
7023      // Private parameters
7024      keepMounted = false,
7025      floatingRootContext,
7026      mounted,
7027      collisionAvoidance,
7028      shift: shift4,
7029      nodeId,
7030      adaptiveOrigin: adaptiveOrigin2,
7031      lazyFlip = false,
7032      externalTree
7033    } = params;
7034    const collisionAvoidanceSide = collisionAvoidance.side || "flip";
7035    const collisionAvoidanceAlign = collisionAvoidance.align || "flip";
7036    const collisionAvoidanceFallbackAxisSide = collisionAvoidance.fallbackAxisSide || "end";
7037    const shiftCrossAxis = shift4?.crossAxis ?? false;
7038    const shiftRootBoundary = shift4?.rootBoundary;
7039    const anchorFn = typeof anchor === "function" ? anchor : void 0;
7040    const anchorFnCallback = useStableCallback(anchorFn);
7041    const anchorDep = anchorFn ? anchorFnCallback : anchor;
7042    const anchorValueRef = useValueAsRef(anchor);
7043    const mountedRef = useValueAsRef(mounted);
7044    const direction = useDirection();
7045    const isRtl = direction === "rtl";
7046    const [mountPlacement, setMountPlacement] = React30.useState(null);
7047    if (!mounted && mountPlacement !== null) {
7048      setMountPlacement(null);
7049    }
7050    const lockAlign = lazyFlip === "placement";
7051    const mountSide = mountPlacement ? getSide(mountPlacement) : null;
7052    const mountAlign = mountPlacement && lockAlign ? getAlignment(mountPlacement) || "center" : null;
7053    const side = mountSide || {
7054      top: "top",
7055      right: "right",
7056      bottom: "bottom",
7057      left: "left",
7058      "inline-end": isRtl ? "left" : "right",
7059      "inline-start": isRtl ? "right" : "left"
7060    }[sideParam];
7061    const placementAlign = mountAlign || align;
7062    const placement = placementAlign === "center" ? side : `$side}-$placementAlign}`;
7063    let collisionPadding = collisionPaddingParam;
7064    if (typeof collisionPadding === "number") {
7065      collisionPadding = {
7066        top: collisionPadding,
7067        right: collisionPadding,
7068        bottom: collisionPadding,
7069        left: collisionPadding
7070      };
7071    } else if (collisionPadding) {
7072      collisionPadding = {
7073        top: collisionPadding.top || 0,
7074        right: collisionPadding.right || 0,
7075        bottom: collisionPadding.bottom || 0,
7076        left: collisionPadding.left || 0
7077      };
7078    }
7079    const bias = 1;
7080    const biasTop = sideParam === "bottom" ? bias : 0;
7081    const biasBottom = sideParam === "top" ? bias : 0;
7082    const biasLeft = sideParam === "right" ? bias : 0;
7083    const biasRight = sideParam === "left" ? bias : 0;
7084    const commonCollisionProps = {
7085      boundary: collisionBoundary === "clipping-ancestors" ? "clippingAncestors" : collisionBoundary,
7086      padding: collisionPadding
7087    };
7088    const arrowRef = React30.useRef(null);
7089    const sideOffsetRef = useValueAsRef(sideOffset);
7090    const alignOffsetRef = useValueAsRef(alignOffset);
7091    const sideOffsetDep = typeof sideOffset !== "function" ? sideOffset : 0;
7092    const alignOffsetDep = typeof alignOffset !== "function" ? alignOffset : 0;
7093    const middleware = [];
7094    if (inlineMiddleware) {
7095      middleware.push(inlineMiddleware);
7096    }
7097    middleware.push(offset3((state) => {
7098      const data = getOffsetData(state, sideParam, isRtl);
7099      const sideAxis = typeof sideOffsetRef.current === "function" ? sideOffsetRef.current(data) : sideOffsetRef.current;
7100      const alignAxis = typeof alignOffsetRef.current === "function" ? alignOffsetRef.current(data) : alignOffsetRef.current;
7101      return {
7102        mainAxis: sideAxis,
7103        crossAxis: alignAxis,
7104        alignmentAxis: alignAxis
7105      };
7106    }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam]));
7107    const shiftDisabled = collisionAvoidanceAlign === "none" && collisionAvoidanceSide !== "shift";
7108    const crossAxisShiftEnabled = !shiftDisabled && (sticky || shiftCrossAxis || collisionAvoidanceSide === "shift");
7109    const flipMiddleware = collisionAvoidanceSide === "none" ? null : flip3({
7110      ...commonCollisionProps,
7111      // Ensure the popup flips if it's been limited by its --available-height and it resizes.
7112      // Since the size() padding is smaller than the flip() padding, flip() will take precedence.
7113      padding: {
7114        top: collisionPadding.top + bias + biasTop,
7115        right: collisionPadding.right + bias + biasRight,
7116        bottom: collisionPadding.bottom + bias + biasBottom,
7117        left: collisionPadding.left + bias + biasLeft
7118      },
7119      mainAxis: !shiftCrossAxis && collisionAvoidanceSide === "flip",
7120      crossAxis: collisionAvoidanceAlign === "flip" ? "alignment" : false,
7121      fallbackAxisSideDirection: collisionAvoidanceFallbackAxisSide
7122    });
7123    const shiftMiddleware = shiftDisabled ? null : shift3({
7124      ...commonCollisionProps,
7125      // Use the Layout Viewport to avoid shifting around when pinch-zooming.
7126      rootBoundary: shiftRootBoundary,
7127      mainAxis: collisionAvoidanceAlign !== "none",
7128      crossAxis: crossAxisShiftEnabled,
7129      limiter: sticky || shiftCrossAxis ? void 0 : limitShift3((limitData) => {
7130        if (!arrowRef.current) {
7131          return {};
7132        }
7133        const {
7134          width,
7135          height
7136        } = arrowRef.current.getBoundingClientRect();
7137        const sideAxis = getSideAxis(getSide(limitData.placement));
7138        const arrowSize = sideAxis === "y" ? width : height;
7139        const offsetAmount = sideAxis === "y" ? collisionPadding.left + collisionPadding.right : collisionPadding.top + collisionPadding.bottom;
7140        return {
7141          offset: arrowSize / 2 + offsetAmount / 2
7142        };
7143      })
7144    }, [commonCollisionProps, sticky, shiftCrossAxis, shiftRootBoundary, collisionPadding, collisionAvoidanceAlign]);
7145    if (collisionAvoidanceSide === "shift" || collisionAvoidanceAlign === "shift" || placementAlign === "center") {
7146      middleware.push(shiftMiddleware, flipMiddleware);
7147    } else {
7148      middleware.push(flipMiddleware, shiftMiddleware);
7149    }
7150    middleware.push(size3({
7151      ...commonCollisionProps,
7152      apply({
7153        elements: {
7154          floating
7155        },
7156        availableWidth: availableWidth2,
7157        availableHeight: availableHeight2,
7158        rects
7159      }) {
7160        if (!mountedRef.current) {
7161          return;
7162        }
7163        const floatingStyle = floating.style;
7164        floatingStyle.setProperty(AVAILABLE_WIDTH_VAR, `$availableWidth2}px`);
7165        floatingStyle.setProperty(AVAILABLE_HEIGHT_VAR, `$availableHeight2}px`);
7166        const dpr = getWindow(floating).devicePixelRatio || 1;
7167        const {
7168          x: x2,
7169          y: y2,
7170          width,
7171          height
7172        } = rects.reference;
7173        const anchorWidth2 = (Math.round((x2 + width) * dpr) - Math.round(x2 * dpr)) / dpr;
7174        const anchorHeight2 = (Math.round((y2 + height) * dpr) - Math.round(y2 * dpr)) / dpr;
7175        floatingStyle.setProperty(anchorWidth, `$anchorWidth2}px`);
7176        floatingStyle.setProperty(anchorHeight, `$anchorHeight2}px`);
7177      }
7178    }), arrow4((state) => ({
7179      // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
7180      // we'll create a fake element.
7181      element: arrowRef.current || ownerDocument(state.elements.floating).createElement("div"),
7182      // No padding for the fake arrow: it would displace aligned popups on narrow anchors.
7183      padding: arrowRef.current ? arrowPadding : 0
7184    }), [arrowPadding]), {
7185      name: "transformOrigin",
7186      fn(state) {
7187        const {
7188          elements: {
7189            floating
7190          },
7191          middlewareData: middlewareData2,
7192          placement: renderedPlacement2,
7193          platform: platform3,
7194          rects,
7195          y: y2
7196        } = state;
7197        const renderedSide2 = getSide(renderedPlacement2);
7198        const renderedAlign2 = getAlignment(renderedPlacement2);
7199        const isVertical = getSideAxis(renderedSide2) === "y";
7200        const arrowEl = arrowRef.current;
7201        const sideOffsetValue = typeof sideOffset === "function" ? sideOffset(getOffsetData(state, sideParam, isRtl)) : sideOffset;
7202        let crossOrigin;
7203        if (!arrowEl && renderedAlign2 && Math.abs(isVertical ? middlewareData2.shift?.x || 0 : middlewareData2.shift?.y || 0) <= 1) {
7204          crossOrigin = renderedAlign2 === "start" === (isVertical && platform3.isRTL?.(floating) === true) ? "100%" : "0%";
7205        } else {
7206          const arrowOffset = isVertical ? middlewareData2.arrow?.x || 0 : middlewareData2.arrow?.y || 0;
7207          const arrowSize = isVertical ? arrowEl?.clientWidth || 0 : arrowEl?.clientHeight || 0;
7208          crossOrigin = `$arrowOffset + arrowSize / 2}px`;
7209        }
7210        let sideOrigin = renderedSide2 === "top" || renderedSide2 === "left" ? `calc(100% + $sideOffsetValue}px)` : `${-sideOffsetValue}px`;
7211        if (crossAxisShiftEnabled && isVertical && Math.abs(middlewareData2.shift?.y || 0) > sideOffsetValue) {
7212          sideOrigin = `$rects.reference.y + rects.reference.height / 2 - y2}px`;
7213        }
7214        floating.style.setProperty(transformOrigin, isVertical ? `$crossOrigin} $sideOrigin}` : `$sideOrigin} $crossOrigin}`);
7215        return {};
7216      }
7217    }, hide4, adaptiveOrigin2);
7218    useIsoLayoutEffect(() => {
7219      if (!mounted && floatingRootContext) {
7220        floatingRootContext.update({
7221          referenceElement: null,
7222          floatingElement: null,
7223          domReferenceElement: null,
7224          positionReference: null
7225        });
7226      }
7227    }, [mounted, floatingRootContext]);
7228    const autoUpdateOptions = React30.useMemo(() => ({
7229      ancestorScroll: !disableAnchorTracking,
7230      elementResize: !disableAnchorTracking && typeof ResizeObserver !== "undefined",
7231      layoutShift: !disableAnchorTracking && typeof IntersectionObserver !== "undefined"
7232    }), [disableAnchorTracking]);
7233    const {
7234      refs,
7235      elements,
7236      x,
7237      y,
7238      middlewareData,
7239      update: update2,
7240      placement: renderedPlacement,
7241      context,
7242      isPositioned,
7243      floatingStyles: originalFloatingStyles
7244    } = useFloatingHook({
7245      rootContext: floatingRootContext,
7246      open: keepMounted ? mounted : void 0,
7247      placement,
7248      middleware,
7249      strategy: positionMethod,
7250      whileElementsMounted: keepMounted ? void 0 : (...args) => autoUpdate(...args, autoUpdateOptions),
7251      nodeId,
7252      externalTree
7253    });
7254    const {
7255      sideX,
7256      sideY
7257    } = middlewareData.adaptiveOrigin || DEFAULT_SIDES;
7258    const resolvedPosition = isPositioned ? positionMethod : "fixed";
7259    const floatingStyles = React30.useMemo(() => {
7260      let base;
7261      if (!isPositioned) {
7262        base = {
7263          position: resolvedPosition,
7264          top: 0,
7265          left: 0
7266        };
7267      } else if (adaptiveOrigin2) {
7268        base = {
7269          position: resolvedPosition,
7270          [sideX]: x,
7271          [sideY]: y
7272        };
7273      } else {
7274        base = {
7275          ...originalFloatingStyles,
7276          position: resolvedPosition
7277        };
7278      }
7279      base[AVAILABLE_WIDTH_VAR] = "100vw";
7280      base[AVAILABLE_HEIGHT_VAR] = "100vh";
7281      if (!isPositioned) {
7282        base.opacity = 0;
7283      }
7284      return base;
7285    }, [adaptiveOrigin2, resolvedPosition, sideX, x, sideY, y, originalFloatingStyles, isPositioned]);
7286    const registeredPositionReferenceRef = React30.useRef(null);
7287    useIsoLayoutEffect(() => {
7288      if (!mounted) {
7289        return;
7290      }
7291      const anchorValue = anchorValueRef.current;
7292      const resolvedAnchor = typeof anchorValue === "function" ? anchorValue() : anchorValue;
7293      const unwrappedElement = (isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor) || null;
7294      const finalAnchor = unwrappedElement || null;
7295      if (finalAnchor !== registeredPositionReferenceRef.current) {
7296        refs.setPositionReference(finalAnchor);
7297        registeredPositionReferenceRef.current = finalAnchor;
7298      }
7299    }, [mounted, refs, anchorDep, anchorValueRef]);
7300    React30.useEffect(() => {
7301      if (!mounted) {
7302        return;
7303      }
7304      const anchorValue = anchorValueRef.current;
7305      if (typeof anchorValue === "function") {
7306        return;
7307      }
7308      if (isRef(anchorValue) && anchorValue.current !== registeredPositionReferenceRef.current) {
7309        refs.setPositionReference(anchorValue.current);
7310        registeredPositionReferenceRef.current = anchorValue.current;
7311      }
7312    }, [mounted, refs, anchorDep, anchorValueRef]);
7313    React30.useEffect(() => {
7314      if (keepMounted && mounted && elements.reference && elements.floating) {
7315        return autoUpdate(elements.reference, elements.floating, update2, autoUpdateOptions);
7316      }
7317      return void 0;
7318    }, [keepMounted, mounted, elements, update2, autoUpdateOptions]);
7319    const renderedSide = getSide(renderedPlacement);
7320    const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);
7321    const renderedAlign = getAlignment(renderedPlacement) || "center";
7322    const anchorHidden2 = Boolean(middlewareData.hide?.referenceHidden);
7323    useIsoLayoutEffect(() => {
7324      if (lazyFlip && mounted && isPositioned && (renderedSide !== side || lockAlign && renderedAlign !== placementAlign)) {
7325        setMountPlacement(renderedPlacement);
7326      }
7327    }, [lazyFlip, lockAlign, mounted, isPositioned, renderedPlacement, renderedSide, renderedAlign, side, placementAlign]);
7328    const arrowStyles = React30.useMemo(() => ({
7329      position: "absolute",
7330      top: middlewareData.arrow?.y,
7331      left: middlewareData.arrow?.x
7332    }), [middlewareData.arrow]);
7333    const arrowUncentered = middlewareData.arrow?.centerOffset !== 0;
7334    return React30.useMemo(() => ({
7335      positionerStyles: floatingStyles,
7336      arrowStyles,
7337      arrowRef,
7338      arrowUncentered,
7339      side: logicalRenderedSide,
7340      align: renderedAlign,
7341      physicalSide: renderedSide,
7342      anchorHidden: anchorHidden2,
7343      refs,
7344      context,
7345      isPositioned,
7346      update: update2
7347    }), [floatingStyles, arrowStyles, arrowRef, arrowUncentered, logicalRenderedSide, renderedAlign, renderedSide, anchorHidden2, refs, context, isPositioned, update2]);
7348  }
7349  function isRef(param) {
7350    return param != null && "current" in param;
7351  }
7352  
7353  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/internals/getDisabledMountTransitionStyles.mjs
7354  function getDisabledMountTransitionStyles(transitionStatus) {
7355    return transitionStatus === "starting" ? DISABLED_TRANSITIONS_STYLE : EMPTY_OBJECT;
7356  }
7357  
7358  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/usePositioner.mjs
7359  function usePositioner(componentProps, state, {
7360    styles,
7361    transitionStatus,
7362    props,
7363    refs,
7364    hidden,
7365    inert = false
7366  }) {
7367    const style = {
7368      ...styles
7369    };
7370    if (inert) {
7371      style.pointerEvents = "none";
7372    }
7373    return useRenderElement("div", componentProps, {
7374      state,
7375      ref: refs,
7376      props: [{
7377        role: "presentation",
7378        hidden,
7379        style
7380      }, getDisabledMountTransitionStyles(transitionStatus), props],
7381      stateAttributesMapping: popupStateMapping
7382    });
7383  }
7384  
7385  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/usePopupViewport.mjs
7386  var React34 = __toESM(require_react(), 1);
7387  var ReactDOM6 = __toESM(require_react_dom(), 1);
7388  
7389  // node_modules/.store/@base-ui/utils@0.5.0--7My7Lubseca8je9LSEweA/node_modules/@base-ui/utils/usePreviousValue.mjs
7390  var React31 = __toESM(require_react(), 1);
7391  function usePreviousValue(value) {
7392    const [state, setState] = React31.useState({
7393      current: value,
7394      previous: null
7395    });
7396    if (!Object.is(value, state.current)) {
7397      setState({
7398        current: value,
7399        previous: state.current
7400      });
7401    }
7402    return state.previous;
7403  }
7404  
7405  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/usePopupAutoResize.mjs
7406  var React32 = __toESM(require_react(), 1);
7407  
7408  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/getCssDimensions.mjs
7409  function getCssDimensions2(element) {
7410    const css = getComputedStyle2(element);
7411    let width = parseFloat(css.width) || 0;
7412    let height = parseFloat(css.height) || 0;
7413    const hasOffset = isHTMLElement(element);
7414    const offsetWidth = hasOffset ? element.offsetWidth : width;
7415    const offsetHeight = hasOffset ? element.offsetHeight : height;
7416    const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
7417    if (shouldFallback) {
7418      width = offsetWidth;
7419      height = offsetHeight;
7420    }
7421    return {
7422      width,
7423      height
7424    };
7425  }
7426  
7427  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/CommonPopupCssVars.mjs
7428  var popupWidth = "--popup-width";
7429  var popupHeight = "--popup-height";
7430  
7431  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/usePopupAutoResize.mjs
7432  function usePopupAutoResize(parameters) {
7433    const {
7434      popupElement,
7435      positionerElement,
7436      content,
7437      mounted,
7438      onMeasureLayout: onMeasureLayoutParam,
7439      onMeasureLayoutComplete: onMeasureLayoutCompleteParam,
7440      side,
7441      direction
7442    } = parameters;
7443    const runOnceAnimationsFinish = useAnimationsFinished(popupElement, true);
7444    const animationFrame = useAnimationFrame();
7445    const committedDimensionsRef = React32.useRef(null);
7446    const onMeasureLayout = useStableCallback(onMeasureLayoutParam);
7447    const onMeasureLayoutComplete = useStableCallback(onMeasureLayoutCompleteParam);
7448    const anchoringStyles = React32.useMemo(() => getPopupAnchoringStyles(side, direction), [side, direction]);
7449    useIsoLayoutEffect(() => {
7450      if (!mounted) {
7451        committedDimensionsRef.current = null;
7452        return void 0;
7453      }
7454      if (!popupElement || !positionerElement) {
7455        return void 0;
7456      }
7457      const restoreAnchoringStyles = applyElementStyles(popupElement, anchoringStyles);
7458      setPopupCssSize(popupElement, "auto");
7459      const restorePopupPosition = overrideElementStyle(popupElement, "position", "static");
7460      const restorePopupTransform = overrideElementStyle(popupElement, "transform", "none");
7461      const restorePopupScale = overrideElementStyle(popupElement, "scale", "1");
7462      const restorePositionerAvailableSize = applyElementStyles(positionerElement, {
7463        [availableWidth]: "max-content",
7464        [availableHeight]: "max-content"
7465      });
7466      function restoreMeasurementOverrides() {
7467        restorePopupPosition();
7468        restorePopupTransform();
7469        restorePositionerAvailableSize();
7470        restorePopupScale();
7471      }
7472      onMeasureLayout?.();
7473      if (committedDimensionsRef.current === null) {
7474        setPositionerCssSize(positionerElement, "max-content");
7475        const dimensions = getCssDimensions2(popupElement);
7476        committedDimensionsRef.current = dimensions;
7477        setPositionerCssSize(positionerElement, dimensions);
7478        restoreMeasurementOverrides();
7479        onMeasureLayoutComplete?.(null, dimensions);
7480        return restoreAnchoringStyles;
7481      }
7482      setPositionerCssSize(positionerElement, "max-content");
7483      const previousDimensions = committedDimensionsRef.current;
7484      const newDimensions = getCssDimensions2(popupElement);
7485      committedDimensionsRef.current = newDimensions;
7486      setPopupCssSize(popupElement, previousDimensions);
7487      restoreMeasurementOverrides();
7488      onMeasureLayoutComplete?.(previousDimensions, newDimensions);
7489      setPositionerCssSize(positionerElement, newDimensions);
7490      const abortController = new AbortController();
7491      animationFrame.request(() => {
7492        setPopupCssSize(popupElement, newDimensions);
7493        runOnceAnimationsFinish(() => {
7494          popupElement.style.setProperty(popupWidth, "auto");
7495          popupElement.style.setProperty(popupHeight, "auto");
7496        }, abortController.signal);
7497      });
7498      return () => {
7499        abortController.abort();
7500        animationFrame.cancel();
7501        restoreAnchoringStyles();
7502      };
7503    }, [content, popupElement, positionerElement, runOnceAnimationsFinish, animationFrame, mounted, onMeasureLayout, onMeasureLayoutComplete, anchoringStyles]);
7504  }
7505  function getPopupAnchoringStyles(side, direction) {
7506    const isPhysicalTop = side === "top";
7507    const isPhysicalLeft = side === "left" || side === (direction === "rtl" ? "inline-end" : "inline-start");
7508    if (!isPhysicalTop && !isPhysicalLeft) {
7509      return EMPTY_OBJECT;
7510    }
7511    return {
7512      position: "absolute",
7513      [isPhysicalTop ? "bottom" : "top"]: "0",
7514      [isPhysicalLeft ? "right" : "left"]: "0"
7515    };
7516  }
7517  function overrideElementStyle(element, property, value) {
7518    const originalValue = element.style.getPropertyValue(property);
7519    element.style.setProperty(property, value);
7520    return () => {
7521      element.style.setProperty(property, originalValue);
7522    };
7523  }
7524  function applyElementStyles(element, styles) {
7525    const restorers = [];
7526    for (const [key, value] of Object.entries(styles)) {
7527      restorers.push(overrideElementStyle(element, key, value));
7528    }
7529    return restorers.length ? () => {
7530      restorers.forEach((restore) => restore());
7531    } : NOOP;
7532  }
7533  function setPopupCssSize(popupElement, size4) {
7534    const width = size4 === "auto" ? "auto" : `$size4.width}px`;
7535    const height = size4 === "auto" ? "auto" : `$size4.height}px`;
7536    popupElement.style.setProperty(popupWidth, width);
7537    popupElement.style.setProperty(popupHeight, height);
7538  }
7539  function setPositionerCssSize(positionerElement, size4) {
7540    const width = size4 === "max-content" ? "max-content" : `$size4.width}px`;
7541    const height = size4 === "max-content" ? "max-content" : `$size4.height}px`;
7542    positionerElement.style.setProperty(positionerWidth, width);
7543    positionerElement.style.setProperty(positionerHeight, height);
7544  }
7545  
7546  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/direction-provider/DirectionProvider.mjs
7547  var React33 = __toESM(require_react(), 1);
7548  var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
7549  var DirectionProvider = function DirectionProvider2(props) {
7550    const {
7551      direction = "ltr"
7552    } = props;
7553    const contextValue = React33.useMemo(() => ({
7554      direction
7555    }), [direction]);
7556    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(DirectionContext.Provider, {
7557      value: contextValue,
7558      children: props.children
7559    });
7560  };
7561  if (true) DirectionProvider.displayName = "DirectionProvider";
7562  
7563  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/adaptiveOriginMiddleware.mjs
7564  var adaptiveOrigin = {
7565    name: "adaptiveOrigin",
7566    async fn(state) {
7567      const {
7568        x: rawX,
7569        y: rawY,
7570        rects: {
7571          floating: floatRect
7572        },
7573        elements: {
7574          floating
7575        },
7576        platform: platform3,
7577        strategy,
7578        placement
7579      } = state;
7580      const win = getWindow(floating);
7581      const styles = win.getComputedStyle(floating);
7582      const hasTransition = styles.transitionDuration !== "0s" && styles.transitionDuration !== "";
7583      if (!hasTransition) {
7584        return {
7585          x: rawX,
7586          y: rawY,
7587          data: DEFAULT_SIDES
7588        };
7589      }
7590      const offsetParent = await platform3.getOffsetParent?.(floating);
7591      let offsetDimensions = {
7592        width: 0,
7593        height: 0
7594      };
7595      if (strategy === "fixed" && win?.visualViewport) {
7596        offsetDimensions = {
7597          width: win.visualViewport.width,
7598          height: win.visualViewport.height
7599        };
7600      } else if (offsetParent === win) {
7601        const doc = ownerDocument(floating);
7602        offsetDimensions = {
7603          width: doc.documentElement.clientWidth,
7604          height: doc.documentElement.clientHeight
7605        };
7606      } else if (await platform3.isElement?.(offsetParent)) {
7607        offsetDimensions = await platform3.getDimensions(offsetParent);
7608      }
7609      const currentSide = getSide(placement);
7610      let x = rawX;
7611      let y = rawY;
7612      if (currentSide === "left") {
7613        x = offsetDimensions.width - (rawX + floatRect.width);
7614      }
7615      if (currentSide === "top") {
7616        y = offsetDimensions.height - (rawY + floatRect.height);
7617      }
7618      const sideX = currentSide === "left" ? "right" : DEFAULT_SIDES.sideX;
7619      const sideY = currentSide === "top" ? "bottom" : DEFAULT_SIDES.sideY;
7620      return {
7621        x,
7622        y,
7623        data: {
7624          sideX,
7625          sideY
7626        }
7627      };
7628    }
7629  };
7630  
7631  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/CommonViewportDataAttributes.mjs
7632  var activationDirection = "data-activation-direction";
7633  
7634  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/usePopupViewport.mjs
7635  var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
7636  var popupViewportStateMapping = {
7637    activationDirection: (value) => value ? {
7638      [activationDirection]: value
7639    } : null
7640  };
7641  function usePopupViewport(parameters) {
7642    const {
7643      store,
7644      side,
7645      children
7646    } = parameters;
7647    const direction = useDirection();
7648    const activeTrigger = store.useState("activeTriggerElement");
7649    const activeTriggerId = store.useState("activeTriggerId");
7650    const open2 = store.useState("open");
7651    const payload = store.useState("payload");
7652    const mounted = store.useState("mounted");
7653    const popupElement = store.useState("popupElement");
7654    const positionerElement = store.useState("positionerElement");
7655    const previousActiveTrigger = usePreviousValue(open2 ? activeTrigger : null);
7656    const currentContentKey = usePopupContentKey(activeTriggerId, payload);
7657    const capturedNodeRef = React34.useRef(null);
7658    const [previousContentNode, setPreviousContentNode] = React34.useState(null);
7659    const [newTriggerOffset, setNewTriggerOffset] = React34.useState(null);
7660    const currentContainerRef = React34.useRef(null);
7661    const previousContainerRef = React34.useRef(null);
7662    const onAnimationsFinished = useAnimationsFinished(currentContainerRef, true);
7663    const cleanupFrame = useAnimationFrame();
7664    const cleanupControllerRef = React34.useRef(null);
7665    const [previousContentDimensions, setPreviousContentDimensions] = React34.useState(null);
7666    const [showStartingStyleAttribute, setShowStartingStyleAttribute] = React34.useState(false);
7667    useIsoLayoutEffect(() => {
7668      store.set("adaptiveOrigin", adaptiveOrigin);
7669      return () => {
7670        store.set("adaptiveOrigin", void 0);
7671      };
7672    }, [store]);
7673    const handleMeasureLayout = useStableCallback(() => {
7674      currentContainerRef.current?.style.setProperty("animation", "none");
7675      currentContainerRef.current?.style.setProperty("transition", "none");
7676      previousContainerRef.current?.style.setProperty("display", "none");
7677    });
7678    const handleMeasureLayoutComplete = useStableCallback((previousDimensions) => {
7679      currentContainerRef.current?.style.removeProperty("animation");
7680      currentContainerRef.current?.style.removeProperty("transition");
7681      previousContainerRef.current?.style.removeProperty("display");
7682      if (previousDimensions) {
7683        setPreviousContentDimensions(previousDimensions);
7684      }
7685    });
7686    const armViewportCleanup = useStableCallback(() => {
7687      cleanupControllerRef.current?.abort();
7688      const controller = new AbortController();
7689      cleanupControllerRef.current = controller;
7690      onAnimationsFinished(() => {
7691        setPreviousContentNode(null);
7692        setPreviousContentDimensions(null);
7693        capturedNodeRef.current = null;
7694      }, controller.signal);
7695    });
7696    const lastHandledTriggerRef = React34.useRef(null);
7697    useIsoLayoutEffect(() => {
7698      if (!open2 || !mounted) {
7699        lastHandledTriggerRef.current = null;
7700      }
7701    }, [open2, mounted]);
7702    useIsoLayoutEffect(() => {
7703      if (open2 && activeTrigger && previousActiveTrigger && activeTrigger !== previousActiveTrigger && lastHandledTriggerRef.current !== activeTrigger && capturedNodeRef.current) {
7704        setPreviousContentNode(capturedNodeRef.current);
7705        setShowStartingStyleAttribute(true);
7706        const offset4 = calculateRelativePosition(previousActiveTrigger, activeTrigger);
7707        setNewTriggerOffset(offset4);
7708        lastHandledTriggerRef.current = activeTrigger;
7709      }
7710    }, [open2, activeTrigger, previousActiveTrigger]);
7711    useIsoLayoutEffect(() => {
7712      if (previousContentNode == null) {
7713        return;
7714      }
7715      cleanupControllerRef.current?.abort();
7716      setShowStartingStyleAttribute(true);
7717      cleanupFrame.request(() => {
7718        ReactDOM6.flushSync(() => {
7719          setShowStartingStyleAttribute(false);
7720        });
7721        armViewportCleanup();
7722      });
7723    }, [currentContentKey, previousContentNode, armViewportCleanup, cleanupFrame]);
7724    useIsoLayoutEffect(() => {
7725      const source = currentContainerRef.current;
7726      if (!source) {
7727        return;
7728      }
7729      const wrapper = ownerDocument(source).createElement("div");
7730      for (const child of Array.from(source.childNodes)) {
7731        wrapper.appendChild(child.cloneNode(true));
7732      }
7733      capturedNodeRef.current = wrapper;
7734    });
7735    const isTransitioning = previousContentNode != null;
7736    let childrenToRender;
7737    if (!isTransitioning) {
7738      childrenToRender = /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", {
7739        "data-current": true,
7740        ref: currentContainerRef,
7741        children
7742      }, currentContentKey);
7743    } else {
7744      childrenToRender = /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(React34.Fragment, {
7745        children: [/* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", {
7746          "data-previous": true,
7747          inert: inertValue(true),
7748          ref: previousContainerRef,
7749          style: {
7750            ...previousContentDimensions ? {
7751              [popupWidth]: `$previousContentDimensions.width}px`,
7752              [popupHeight]: `$previousContentDimensions.height}px`
7753            } : null,
7754            position: "absolute"
7755          },
7756          "data-ending-style": showStartingStyleAttribute ? void 0 : ""
7757        }, "previous"), /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", {
7758          "data-current": true,
7759          ref: currentContainerRef,
7760          "data-starting-style": showStartingStyleAttribute ? "" : void 0,
7761          children
7762        }, currentContentKey)]
7763      });
7764    }
7765    useIsoLayoutEffect(() => {
7766      const container = previousContainerRef.current;
7767      if (!container || !previousContentNode) {
7768        return;
7769      }
7770      container.replaceChildren(...Array.from(previousContentNode.childNodes));
7771    }, [previousContentNode]);
7772    usePopupAutoResize({
7773      popupElement,
7774      positionerElement,
7775      mounted,
7776      content: payload,
7777      onMeasureLayout: handleMeasureLayout,
7778      onMeasureLayoutComplete: handleMeasureLayoutComplete,
7779      side,
7780      direction
7781    });
7782    const state = {
7783      activationDirection: getActivationDirection(newTriggerOffset),
7784      transitioning: isTransitioning
7785    };
7786    return {
7787      children: childrenToRender,
7788      state
7789    };
7790  }
7791  function getActivationDirection(offset4) {
7792    if (!offset4) {
7793      return void 0;
7794    }
7795    return `$getValueWithTolerance(offset4.horizontal, 5, "right", "left")} $getValueWithTolerance(offset4.vertical, 5, "down", "up")}`;
7796  }
7797  function getValueWithTolerance(value, tolerance, positiveLabel, negativeLabel) {
7798    if (value > tolerance) {
7799      return positiveLabel;
7800    }
7801    if (value < -tolerance) {
7802      return negativeLabel;
7803    }
7804    return "";
7805  }
7806  function calculateRelativePosition(from, to) {
7807    const fromRect = from.getBoundingClientRect();
7808    const toRect = to.getBoundingClientRect();
7809    const fromCenter = {
7810      x: fromRect.left + fromRect.width / 2,
7811      y: fromRect.top + fromRect.height / 2
7812    };
7813    const toCenter = {
7814      x: toRect.left + toRect.width / 2,
7815      y: toRect.top + toRect.height / 2
7816    };
7817    return {
7818      horizontal: toCenter.x - fromCenter.x,
7819      vertical: toCenter.y - fromCenter.y
7820    };
7821  }
7822  function usePopupContentKey(activeTriggerId, payload) {
7823    const [contentKey, setContentKey] = React34.useState(0);
7824    const previousActiveTriggerIdRef = React34.useRef(activeTriggerId);
7825    const previousPayloadRef = React34.useRef(payload);
7826    const pendingPayloadUpdateRef = React34.useRef(false);
7827    useIsoLayoutEffect(() => {
7828      const previousActiveTriggerId = previousActiveTriggerIdRef.current;
7829      const previousPayload = previousPayloadRef.current;
7830      const triggerIdChanged = activeTriggerId !== previousActiveTriggerId;
7831      const payloadChanged = payload !== previousPayload;
7832      if (triggerIdChanged) {
7833        setContentKey((value) => value + 1);
7834        pendingPayloadUpdateRef.current = !payloadChanged;
7835      } else if (pendingPayloadUpdateRef.current && payloadChanged) {
7836        setContentKey((value) => value + 1);
7837        pendingPayloadUpdateRef.current = false;
7838      }
7839      previousActiveTriggerIdRef.current = activeTriggerId;
7840      previousPayloadRef.current = payload;
7841    }, [activeTriggerId, payload]);
7842    return `$activeTriggerId ?? "current"}-$contentKey}`;
7843  }
7844  
7845  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/utils/FloatingPortalLite.mjs
7846  var React35 = __toESM(require_react(), 1);
7847  var ReactDOM7 = __toESM(require_react_dom(), 1);
7848  var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
7849  var FloatingPortalLite = /* @__PURE__ */ React35.forwardRef(function FloatingPortalLite2(componentProps, forwardedRef) {
7850    const {
7851      children,
7852      container,
7853      className,
7854      render,
7855      style,
7856      ...elementProps
7857    } = componentProps;
7858    const {
7859      node: portalNode,
7860      subtree: portalSubtree
7861    } = useFloatingPortalNode({
7862      container,
7863      ref: forwardedRef,
7864      componentProps,
7865      elementProps
7866    });
7867    if (!portalSubtree && !portalNode) {
7868      return null;
7869    }
7870    return /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)(React35.Fragment, {
7871      children: [portalSubtree, portalNode && /* @__PURE__ */ ReactDOM7.createPortal(children, portalNode)]
7872    });
7873  });
7874  if (true) FloatingPortalLite.displayName = "FloatingPortalLite";
7875  
7876  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/index.parts.mjs
7877  var index_parts_exports = {};
7878  __export(index_parts_exports, {
7879    Arrow: () => TooltipArrow,
7880    Handle: () => TooltipHandle,
7881    Popup: () => TooltipPopup,
7882    Portal: () => TooltipPortal,
7883    Positioner: () => TooltipPositioner,
7884    Provider: () => TooltipProvider,
7885    Root: () => TooltipRoot,
7886    Trigger: () => TooltipTrigger,
7887    Viewport: () => TooltipViewport,
7888    createHandle: () => createTooltipHandle
7889  });
7890  
7891  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/root/TooltipRoot.mjs
7892  var React38 = __toESM(require_react(), 1);
7893  
7894  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/root/TooltipRootContext.mjs
7895  var React36 = __toESM(require_react(), 1);
7896  var TooltipRootContext = /* @__PURE__ */ React36.createContext(void 0);
7897  if (true) TooltipRootContext.displayName = "TooltipRootContext";
7898  function useTooltipRootContext(optional) {
7899    const context = React36.useContext(TooltipRootContext);
7900    if (context === void 0 && !optional) {
7901      throw new Error(true ? "Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>." : formatErrorMessage_default(72));
7902    }
7903    return context;
7904  }
7905  
7906  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/store/TooltipStore.mjs
7907  var React37 = __toESM(require_react(), 1);
7908  var selectors2 = {
7909    ...popupStoreSelectors,
7910    disabled: (state) => state.disabled,
7911    instantType: (state) => state.instantType,
7912    isInstantPhase: (state) => state.isInstantPhase,
7913    trackCursorAxis: (state) => state.trackCursorAxis,
7914    disableHoverablePopup: (state) => state.disableHoverablePopup,
7915    lastOpenChangeReason: (state) => state.openChangeReason,
7916    closeOnClick: (state) => state.closeOnClick,
7917    // Active and inactive trigger props are the same object, so a constant for triggers that discard
7918    // them keeps those triggers from re-rendering when the props change.
7919    appliedTriggerProps: (state, apply) => apply ? state.activeTriggerProps : void 0,
7920    closeDelay: (state) => state.closeDelay,
7921    adaptiveOrigin: (state) => state.adaptiveOrigin
7922  };
7923  var TooltipStore = class extends ReactStore {
7924    constructor(initialState, floatingId, nested) {
7925      const triggerElements = new PopupTriggerMap();
7926      super(createInitialState(initialState, triggerElements, floatingId, nested), createInitialContext(triggerElements), selectors2);
7927    }
7928    setOpen = (nextOpen, eventDetails) => {
7929      applyPopupOpenChange(this, nextOpen, eventDetails, {
7930        extraState: {
7931          openChangeReason: eventDetails.reason
7932        }
7933      });
7934    };
7935    // Used by trigger clicks to clear a delayed hover open without reporting a public open-state change.
7936    cancelPendingOpen(event) {
7937      this.state.floatingRootContext.dispatchOpenChange(false, createChangeEventDetails(reason_parts_exports.triggerPress, event));
7938    }
7939  };
7940  function createNullTooltipStore() {
7941    const triggerElements = new PopupTriggerMap();
7942    const store = new NullStore(Object.freeze(createInitialState(void 0, triggerElements)), Object.freeze(createInitialContext(triggerElements)), selectors2);
7943    return Object.assign(store, {
7944      setOpen: NOOP,
7945      cancelPendingOpen: NOOP
7946    });
7947  }
7948  function createInitialState(initialState, triggerElements, floatingId, nested = false) {
7949    const state = {
7950      ...createInitialPopupStoreState(triggerElements, floatingId, nested),
7951      disabled: false,
7952      instantType: void 0,
7953      isInstantPhase: false,
7954      trackCursorAxis: "none",
7955      disableHoverablePopup: false,
7956      openChangeReason: null,
7957      closeOnClick: true,
7958      closeDelay: 0,
7959      adaptiveOrigin: void 0,
7960      ...initialState
7961    };
7962    return state;
7963  }
7964  function createInitialContext(triggerElements) {
7965    return {
7966      popupRef: /* @__PURE__ */ React37.createRef(),
7967      onOpenChange: void 0,
7968      onOpenChangeComplete: void 0,
7969      triggerElements
7970    };
7971  }
7972  
7973  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/root/TooltipRoot.mjs
7974  var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
7975  var TooltipRoot = fastComponent(function TooltipRoot2(props) {
7976    const {
7977      disabled: disabled2 = false,
7978      defaultOpen = false,
7979      open: openProp,
7980      disableHoverablePopup = false,
7981      trackCursorAxis = "none",
7982      actionsRef,
7983      onOpenChange,
7984      onOpenChangeComplete,
7985      handle,
7986      triggerId: triggerIdProp,
7987      defaultTriggerId: defaultTriggerIdProp = null,
7988      children
7989    } = props;
7990    const store = usePopupRootStore((floatingId, nested) => new TooltipStore({
7991      open: defaultOpen,
7992      openProp,
7993      activeTriggerId: defaultTriggerIdProp,
7994      triggerIdProp
7995    }, floatingId, nested));
7996    store.useControlledProp("openProp", openProp);
7997    store.useControlledProp("triggerIdProp", triggerIdProp);
7998    store.useContextCallback("onOpenChange", onOpenChange);
7999    store.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
8000    const openState = store.useState("open");
8001    const open2 = !disabled2 && openState;
8002    const activeTriggerId = store.useState("activeTriggerId");
8003    const mounted = store.useState("mounted");
8004    const payload = store.useState("payload");
8005    store.useSyncedValues({
8006      trackCursorAxis,
8007      disableHoverablePopup,
8008      disabled: disabled2
8009    });
8010    useImplicitActiveTrigger(store, {
8011      closeOnActiveTriggerUnmount: true
8012    });
8013    const {
8014      forceUnmount,
8015      transitionStatus
8016    } = useOpenStateTransitions(open2, store);
8017    const isInstantPhase = store.useState("isInstantPhase");
8018    const instantType = store.useState("instantType");
8019    const lastOpenChangeReason = store.useState("lastOpenChangeReason");
8020    const previousInstantTypeRef = React38.useRef(null);
8021    useIsoLayoutEffect(() => {
8022      if (openState && disabled2) {
8023        store.setOpen(false, createChangeEventDetails(reason_parts_exports.disabled));
8024      }
8025    }, [openState, disabled2, store]);
8026    useIsoLayoutEffect(() => {
8027      if (transitionStatus === "ending" && lastOpenChangeReason === reason_parts_exports.none || transitionStatus !== "ending" && isInstantPhase) {
8028        if (instantType !== "delay") {
8029          previousInstantTypeRef.current = instantType;
8030        }
8031        store.set("instantType", "delay");
8032      } else if (previousInstantTypeRef.current !== null) {
8033        store.set("instantType", previousInstantTypeRef.current);
8034        previousInstantTypeRef.current = null;
8035      }
8036    }, [transitionStatus, isInstantPhase, lastOpenChangeReason, instantType, store]);
8037    useIsoLayoutEffect(() => {
8038      if (open2) {
8039        if (activeTriggerId == null) {
8040          store.set("payload", void 0);
8041        }
8042      }
8043    }, [store, activeTriggerId, open2]);
8044    React38.useImperativeHandle(actionsRef, () => ({
8045      unmount: forceUnmount,
8046      close: () => store.setOpen(false, createChangeEventDetails(reason_parts_exports.imperativeAction))
8047    }), [forceUnmount, store]);
8048    const shouldRenderInteractions = open2 || mounted || !disabled2 && trackCursorAxis !== "none";
8049    return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(TooltipRootContext.Provider, {
8050      value: store,
8051      children: [handle && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(PopupHandleAttachment, {
8052        handle,
8053        store
8054      }), shouldRenderInteractions && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(TooltipInteractions, {
8055        store,
8056        disabled: disabled2,
8057        trackCursorAxis
8058      }), typeof children === "function" ? children({
8059        payload
8060      }) : children]
8061    });
8062  });
8063  if (true) TooltipRoot.displayName = "TooltipRoot";
8064  function TooltipInteractions({
8065    store,
8066    disabled: disabled2,
8067    trackCursorAxis
8068  }) {
8069    const floatingRootContext = store.useState("floatingRootContext");
8070    const dismiss = useDismiss(floatingRootContext, {
8071      enabled: !disabled2,
8072      referencePress: () => store.select("closeOnClick")
8073    });
8074    const clientPoint = useClientPoint(floatingRootContext, {
8075      enabled: !disabled2 && trackCursorAxis !== "none",
8076      axis: trackCursorAxis === "none" ? void 0 : trackCursorAxis
8077    });
8078    const triggerProps = React38.useMemo(() => mergeProps(clientPoint.reference, dismiss.reference), [clientPoint.reference, dismiss.reference]);
8079    usePopupInteractionProps(store, {
8080      activeTriggerProps: triggerProps,
8081      inactiveTriggerProps: triggerProps,
8082      popupProps: dismiss.floating ?? EMPTY_OBJECT
8083    });
8084    return null;
8085  }
8086  
8087  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/trigger/TooltipTrigger.mjs
8088  var React40 = __toESM(require_react(), 1);
8089  
8090  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/provider/TooltipProviderContext.mjs
8091  var React39 = __toESM(require_react(), 1);
8092  var TooltipProviderContext = /* @__PURE__ */ React39.createContext(void 0);
8093  if (true) TooltipProviderContext.displayName = "TooltipProviderContext";
8094  function useTooltipProviderContext() {
8095    return React39.useContext(TooltipProviderContext);
8096  }
8097  
8098  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/utils/constants.mjs
8099  var OPEN_DELAY = 600;
8100  
8101  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/trigger/TooltipTrigger.mjs
8102  var TOOLTIP_TRIGGER_IDENTIFIER = "data-base-ui-tooltip-trigger";
8103  function getTargetElement(event) {
8104    const target = getTarget(event);
8105    return isElement(target) ? target : null;
8106  }
8107  var TooltipTrigger = fastComponentRef(function TooltipTrigger2(componentProps, forwardedRef) {
8108    const {
8109      render,
8110      className,
8111      style,
8112      handle,
8113      payload,
8114      disabled: disabledProp,
8115      delay,
8116      closeOnClick = true,
8117      closeDelay,
8118      id: idProp,
8119      ...elementProps
8120    } = componentProps;
8121    const rootContext = useTooltipRootContext(true);
8122    const handleStore = usePopupHandleStore(handle);
8123    const store = handleStore ?? rootContext;
8124    if (!store) {
8125      throw new Error(true ? "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle." : formatErrorMessage_default(82));
8126    }
8127    const thisTriggerId = useBaseUiId(idProp);
8128    const isTriggerActive = store.useState("isTriggerActive", thisTriggerId);
8129    const isOpenedByThisTrigger = store.useState("isOpenedByTrigger", thisTriggerId);
8130    const floatingRootContext = store.useState("floatingRootContext");
8131    const triggerElementRef = React40.useRef(null);
8132    const closeDelayWithDefault = closeDelay ?? 0;
8133    const {
8134      registerTrigger,
8135      isMountedByThisTrigger
8136    } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
8137      payload,
8138      closeOnClick,
8139      closeDelay: closeDelayWithDefault
8140    });
8141    const providerDelay = useTooltipProviderContext();
8142    const {
8143      activeIdRef,
8144      delayRef,
8145      isInstantPhase,
8146      hasProvider
8147    } = useDelayGroup(floatingRootContext, {
8148      open: isOpenedByThisTrigger
8149    });
8150    const hoverInteraction = useHoverInteractionSharedState(floatingRootContext);
8151    store.useSyncedValue("isInstantPhase", isInstantPhase);
8152    const rootDisabled = store.useState("disabled");
8153    const disabled2 = disabledProp ?? rootDisabled;
8154    const disabledRef = useValueAsRef(disabled2);
8155    const trackCursorAxis = store.useState("trackCursorAxis");
8156    const disableHoverablePopup = store.useState("disableHoverablePopup");
8157    const isNestedTriggerHoveredRef = React40.useRef(false);
8158    const nestedTriggerOpenTimeout = useTimeout();
8159    const pointerTypeRef = React40.useRef(void 0);
8160    function getOpenDelay() {
8161      if (hasProvider && activeIdRef.current != null) {
8162        return 0;
8163      }
8164      return delay ?? providerDelay ?? OPEN_DELAY;
8165    }
8166    function isEnabledNestedTriggerTarget(target) {
8167      const triggerEl = triggerElementRef.current;
8168      if (!triggerEl || !target) {
8169        return false;
8170      }
8171      const nearestTrigger = closest(target, `[$TOOLTIP_TRIGGER_IDENTIFIER}]`);
8172      return nearestTrigger !== null && nearestTrigger !== triggerEl && contains(triggerEl, nearestTrigger);
8173    }
8174    function detectNestedTriggerHover(target) {
8175      const nestedTriggerHovered = isEnabledNestedTriggerTarget(target);
8176      isNestedTriggerHoveredRef.current = nestedTriggerHovered;
8177      if (nestedTriggerHovered) {
8178        hoverInteraction.openChangeTimeout.clear();
8179        hoverInteraction.restTimeout.clear();
8180        hoverInteraction.restTimeoutPending = false;
8181        nestedTriggerOpenTimeout.clear();
8182      }
8183      return nestedTriggerHovered;
8184    }
8185    const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
8186      enabled: !disabled2,
8187      mouseOnly: true,
8188      move: false,
8189      handleClose: !disableHoverablePopup && trackCursorAxis !== "both" ? safePolygon() : null,
8190      restMs: getOpenDelay,
8191      delay() {
8192        if (closeDelay == null && hasProvider) {
8193          return {
8194            close: getDelay(delayRef.current, "close")
8195          };
8196        }
8197        return {
8198          close: closeDelayWithDefault
8199        };
8200      },
8201      triggerElementRef,
8202      isActiveTrigger: isTriggerActive,
8203      isClosing: () => store.select("transitionStatus") === "ending",
8204      shouldOpen() {
8205        return !isNestedTriggerHoveredRef.current;
8206      }
8207    });
8208    const focusProps = useFocus(floatingRootContext, {
8209      enabled: !disabled2
8210    }).reference;
8211    const handleNestedTriggerHover = (event) => {
8212      const wasNestedTriggerHovered = isNestedTriggerHoveredRef.current;
8213      const target = getTargetElement(event);
8214      const nestedTriggerHovered = detectNestedTriggerHover(target);
8215      const triggerEl = triggerElementRef.current;
8216      const targetInsideTrigger = triggerEl && target && contains(triggerEl, target);
8217      if (nestedTriggerHovered && store.select("open") && store.select("lastOpenChangeReason") === reason_parts_exports.triggerHover) {
8218        store.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
8219        return;
8220      }
8221      if (wasNestedTriggerHovered && !nestedTriggerHovered && targetInsideTrigger && !disabledRef.current && !store.select("open") && triggerEl && // Match the hover hook's non-strict mouse fallback for mouse-only event sequences.
8222      isMouseLikePointerType(pointerTypeRef.current)) {
8223        const open2 = () => {
8224          if (!isNestedTriggerHoveredRef.current && !disabledRef.current && !store.select("open")) {
8225            store.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerEl));
8226          }
8227        };
8228        const openDelay = getOpenDelay();
8229        if (openDelay === 0) {
8230          nestedTriggerOpenTimeout.clear();
8231          open2();
8232        } else {
8233          nestedTriggerOpenTimeout.start(openDelay, open2);
8234        }
8235      }
8236    };
8237    const rootTriggerProps = store.useState("appliedTriggerProps", isMountedByThisTrigger || trackCursorAxis !== "none");
8238    const state = {
8239      open: isOpenedByThisTrigger
8240    };
8241    const element = useRenderElement("button", componentProps, {
8242      state,
8243      ref: [forwardedRef, registerTrigger, triggerElementRef],
8244      props: [hoverProps, focusProps, rootTriggerProps, {
8245        onMouseOver(event) {
8246          handleNestedTriggerHover(event.nativeEvent);
8247        },
8248        onFocus(event) {
8249          if (isEnabledNestedTriggerTarget(getTargetElement(event.nativeEvent))) {
8250            event.preventBaseUIHandler();
8251          }
8252        },
8253        onMouseLeave() {
8254          isNestedTriggerHoveredRef.current = false;
8255          nestedTriggerOpenTimeout.clear();
8256          pointerTypeRef.current = void 0;
8257        },
8258        onPointerEnter(event) {
8259          pointerTypeRef.current = event.pointerType;
8260        },
8261        onPointerDown(event) {
8262          pointerTypeRef.current = event.pointerType;
8263          store.set("closeOnClick", closeOnClick);
8264          if (closeOnClick && !store.select("open")) {
8265            store.cancelPendingOpen(event.nativeEvent);
8266          }
8267        },
8268        onClick(event) {
8269          if (closeOnClick && !store.select("open")) {
8270            store.cancelPendingOpen(event.nativeEvent);
8271          }
8272        },
8273        id: thisTriggerId,
8274        [triggerDisabled]: disabled2 ? "" : void 0,
8275        [TOOLTIP_TRIGGER_IDENTIFIER]: disabled2 ? void 0 : ""
8276      }, elementProps],
8277      stateAttributesMapping: triggerOpenStateMapping
8278    });
8279    return element;
8280  });
8281  if (true) TooltipTrigger.displayName = "TooltipTrigger";
8282  
8283  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/portal/TooltipPortal.mjs
8284  var React42 = __toESM(require_react(), 1);
8285  
8286  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/portal/TooltipPortalContext.mjs
8287  var React41 = __toESM(require_react(), 1);
8288  var TooltipPortalContext = /* @__PURE__ */ React41.createContext(void 0);
8289  if (true) TooltipPortalContext.displayName = "TooltipPortalContext";
8290  function useTooltipPortalContext() {
8291    const value = React41.useContext(TooltipPortalContext);
8292    if (value === void 0) {
8293      throw new Error(true ? "Base UI: <Tooltip.Portal> is missing." : formatErrorMessage_default(70));
8294    }
8295    return value;
8296  }
8297  
8298  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/portal/TooltipPortal.mjs
8299  var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
8300  var TooltipPortal = /* @__PURE__ */ React42.forwardRef(function TooltipPortal2(props, forwardedRef) {
8301    const {
8302      keepMounted = false,
8303      ...portalProps
8304    } = props;
8305    const store = useTooltipRootContext();
8306    const mounted = store.useState("mounted");
8307    const shouldRender = mounted || keepMounted;
8308    if (!shouldRender) {
8309      return null;
8310    }
8311    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(TooltipPortalContext.Provider, {
8312      value: keepMounted,
8313      children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(FloatingPortalLite, {
8314        ref: forwardedRef,
8315        ...portalProps
8316      })
8317    });
8318  });
8319  if (true) TooltipPortal.displayName = "TooltipPortal";
8320  
8321  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/positioner/TooltipPositioner.mjs
8322  var React44 = __toESM(require_react(), 1);
8323  
8324  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/positioner/TooltipPositionerContext.mjs
8325  var React43 = __toESM(require_react(), 1);
8326  var TooltipPositionerContext = /* @__PURE__ */ React43.createContext(void 0);
8327  if (true) TooltipPositionerContext.displayName = "TooltipPositionerContext";
8328  function useTooltipPositionerContext() {
8329    const context = React43.useContext(TooltipPositionerContext);
8330    if (context === void 0) {
8331      throw new Error(true ? "Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>." : formatErrorMessage_default(71));
8332    }
8333    return context;
8334  }
8335  
8336  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/positioner/TooltipPositioner.mjs
8337  var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
8338  var TooltipPositioner = /* @__PURE__ */ React44.forwardRef(function TooltipPositioner2(componentProps, forwardedRef) {
8339    const {
8340      render,
8341      className,
8342      anchor,
8343      positionMethod = "absolute",
8344      side = "top",
8345      align = "center",
8346      sideOffset = 0,
8347      alignOffset = 0,
8348      collisionBoundary = "clipping-ancestors",
8349      collisionPadding = 5,
8350      arrowPadding = 5,
8351      sticky = false,
8352      disableAnchorTracking = false,
8353      collisionAvoidance = POPUP_COLLISION_AVOIDANCE,
8354      style,
8355      ...elementProps
8356    } = componentProps;
8357    const store = useTooltipRootContext();
8358    const keepMounted = useTooltipPortalContext();
8359    const open2 = store.useState("open");
8360    const mounted = store.useState("mounted");
8361    const trackCursorAxis = store.useState("trackCursorAxis");
8362    const disableHoverablePopup = store.useState("disableHoverablePopup");
8363    const floatingRootContext = store.useState("floatingRootContext");
8364    const instantType = store.useState("instantType");
8365    const transitionStatus = store.useState("transitionStatus");
8366    const adaptiveOrigin2 = store.useState("adaptiveOrigin");
8367    const positioning = useAnchorPositioning({
8368      anchor,
8369      positionMethod,
8370      floatingRootContext,
8371      mounted,
8372      side,
8373      sideOffset,
8374      align,
8375      alignOffset,
8376      collisionBoundary,
8377      collisionPadding,
8378      sticky,
8379      arrowPadding,
8380      disableAnchorTracking,
8381      keepMounted,
8382      collisionAvoidance,
8383      adaptiveOrigin: adaptiveOrigin2
8384    });
8385    const state = React44.useMemo(() => ({
8386      open: open2,
8387      side: positioning.side,
8388      align: positioning.align,
8389      anchorHidden: positioning.anchorHidden,
8390      instant: trackCursorAxis !== "none" ? "tracking-cursor" : instantType
8391    }), [open2, positioning.side, positioning.align, positioning.anchorHidden, trackCursorAxis, instantType]);
8392    const element = usePositioner(componentProps, state, {
8393      styles: positioning.positionerStyles,
8394      transitionStatus,
8395      props: elementProps,
8396      refs: [forwardedRef, store.useStateSetter("positionerElement")],
8397      hidden: !mounted,
8398      inert: !open2 || trackCursorAxis === "both" || disableHoverablePopup
8399    });
8400    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(TooltipPositionerContext.Provider, {
8401      value: positioning,
8402      children: element
8403    });
8404  });
8405  if (true) TooltipPositioner.displayName = "TooltipPositioner";
8406  
8407  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/popup/TooltipPopup.mjs
8408  var React45 = __toESM(require_react(), 1);
8409  var TooltipPopup = /* @__PURE__ */ React45.forwardRef(function TooltipPopup2(componentProps, forwardedRef) {
8410    const {
8411      render,
8412      className,
8413      style,
8414      ...elementProps
8415    } = componentProps;
8416    const store = useTooltipRootContext();
8417    const {
8418      side,
8419      align
8420    } = useTooltipPositionerContext();
8421    const open2 = store.useState("open");
8422    const instantType = store.useState("instantType");
8423    const transitionStatus = store.useState("transitionStatus");
8424    const popupProps = store.useState("popupProps");
8425    const floatingContext = store.useState("floatingRootContext");
8426    const disabled2 = store.useState("disabled");
8427    const closeDelay = store.useState("closeDelay");
8428    useOpenChangeComplete({
8429      open: open2,
8430      ref: store.context.popupRef,
8431      onComplete() {
8432        if (open2) {
8433          store.context.onOpenChangeComplete?.(true);
8434        }
8435      }
8436    });
8437    useHoverFloatingInteraction(floatingContext, {
8438      enabled: !disabled2,
8439      closeDelay
8440    });
8441    const setPopupElement = store.useStateSetter("popupElement");
8442    const state = {
8443      open: open2,
8444      side,
8445      align,
8446      instant: instantType,
8447      transitionStatus
8448    };
8449    const element = useRenderElement("div", componentProps, {
8450      state,
8451      ref: [forwardedRef, store.context.popupRef, setPopupElement],
8452      props: [FOCUSABLE_POPUP_PROPS, popupProps, getDisabledMountTransitionStyles(transitionStatus), elementProps],
8453      stateAttributesMapping: popupTransitionStateMapping
8454    });
8455    return element;
8456  });
8457  if (true) TooltipPopup.displayName = "TooltipPopup";
8458  
8459  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/arrow/TooltipArrow.mjs
8460  var React46 = __toESM(require_react(), 1);
8461  var TooltipArrow = /* @__PURE__ */ React46.forwardRef(function TooltipArrow2(componentProps, forwardedRef) {
8462    const {
8463      render,
8464      className,
8465      style,
8466      ...elementProps
8467    } = componentProps;
8468    const store = useTooltipRootContext();
8469    const {
8470      arrowRef,
8471      side,
8472      align,
8473      arrowUncentered,
8474      arrowStyles
8475    } = useTooltipPositionerContext();
8476    const open2 = store.useState("open");
8477    const instantType = store.useState("instantType");
8478    const state = {
8479      open: open2,
8480      side,
8481      align,
8482      uncentered: arrowUncentered,
8483      instant: instantType
8484    };
8485    const element = useRenderElement("div", componentProps, {
8486      state,
8487      ref: [forwardedRef, arrowRef],
8488      props: [{
8489        style: arrowStyles,
8490        "aria-hidden": true
8491      }, elementProps],
8492      stateAttributesMapping: popupStateMapping
8493    });
8494    return element;
8495  });
8496  if (true) TooltipArrow.displayName = "TooltipArrow";
8497  
8498  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/provider/TooltipProvider.mjs
8499  var React47 = __toESM(require_react(), 1);
8500  var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
8501  var TooltipProvider = function TooltipProvider2(props) {
8502    const {
8503      delay,
8504      closeDelay,
8505      timeout = 400
8506    } = props;
8507    const delayValue = React47.useMemo(() => ({
8508      open: delay,
8509      close: closeDelay
8510    }), [delay, closeDelay]);
8511    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(TooltipProviderContext.Provider, {
8512      value: delay,
8513      children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(FloatingDelayGroup, {
8514        delay: delayValue,
8515        timeoutMs: timeout,
8516        children: props.children
8517      })
8518    });
8519  };
8520  if (true) TooltipProvider.displayName = "TooltipProvider";
8521  
8522  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/viewport/TooltipViewport.mjs
8523  var React48 = __toESM(require_react(), 1);
8524  var TooltipViewport = /* @__PURE__ */ React48.forwardRef(function TooltipViewport2(componentProps, forwardedRef) {
8525    const {
8526      render,
8527      className,
8528      style,
8529      children,
8530      ...elementProps
8531    } = componentProps;
8532    const store = useTooltipRootContext();
8533    const positioner = useTooltipPositionerContext();
8534    const instantType = store.useState("instantType");
8535    const {
8536      children: childrenToRender,
8537      state: viewportState
8538    } = usePopupViewport({
8539      store,
8540      side: positioner.side,
8541      children
8542    });
8543    const state = {
8544      activationDirection: viewportState.activationDirection,
8545      transitioning: viewportState.transitioning,
8546      instant: instantType
8547    };
8548    return useRenderElement("div", componentProps, {
8549      state,
8550      ref: forwardedRef,
8551      props: [elementProps, {
8552        children: childrenToRender
8553      }],
8554      stateAttributesMapping: popupViewportStateMapping
8555    });
8556  });
8557  if (true) TooltipViewport.displayName = "TooltipViewport";
8558  
8559  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/tooltip/store/TooltipHandle.mjs
8560  var TooltipHandle = class extends BasePopupHandle {
8561    constructor() {
8562      super(createNullTooltipStore(), "Tooltip");
8563    }
8564    /**
8565     * Opens the tooltip and associates it with the trigger with the given id.
8566     *
8567     * This method should only be called in an event handler or an effect (not during rendering).
8568     *
8569     * @param triggerId ID of the trigger to associate with the tooltip. The trigger must be a matching
8570     * `Tooltip.Trigger` with this handle passed as a prop.
8571     */
8572    open(triggerId) {
8573      this.openByTrigger(triggerId);
8574    }
8575    /**
8576     * Closes the tooltip.
8577     *
8578     * This method should only be called in an event handler or an effect (not during rendering).
8579     */
8580    close() {
8581      this.closePopup();
8582    }
8583    /**
8584     * Whether the tooltip is currently open. Returns `false` while no root is attached to the handle.
8585     */
8586    get isOpen() {
8587      return this.attachedStore?.select("open") ?? false;
8588    }
8589  };
8590  function createTooltipHandle() {
8591    return new TooltipHandle();
8592  }
8593  
8594  // node_modules/.store/@base-ui/react@1.9.0-uHNeM94OdjIeOtpyYGvL0A/node_modules/@base-ui/react/use-render/useRender.mjs
8595  function useRender(params) {
8596    return useRenderElement(params.defaultTagName ?? "div", params, params);
8597  }
8598  
8599  // packages/ui/build-module/visually-hidden/visually-hidden.mjs
8600  var import_element12 = __toESM(require_element(), 1);
8601  var STYLE_HASH_ATTRIBUTE = "data-wp-hash";
8602  function getRuntime() {
8603    const globalScope = globalThis;
8604    if (globalScope.__wpStyleRuntime) {
8605      return globalScope.__wpStyleRuntime;
8606    }
8607    globalScope.__wpStyleRuntime = {
8608      documents: /* @__PURE__ */ new Map(),
8609      styles: /* @__PURE__ */ new Map(),
8610      injectedStyles: /* @__PURE__ */ new WeakMap()
8611    };
8612    if (typeof document !== "undefined") {
8613      registerDocument(document);
8614    }
8615    return globalScope.__wpStyleRuntime;
8616  }
8617  function documentContainsStyleHash(targetDocument, hash) {
8618    if (!targetDocument.head) {
8619      return false;
8620    }
8621    for (const style of targetDocument.head.querySelectorAll(
8622      `style[$STYLE_HASH_ATTRIBUTE}]`
8623    )) {
8624      if (style.getAttribute(STYLE_HASH_ATTRIBUTE) === hash) {
8625        return true;
8626      }
8627    }
8628    return false;
8629  }
8630  function injectStyle(targetDocument, hash, css) {
8631    if (!targetDocument.head) {
8632      return;
8633    }
8634    const runtime = getRuntime();
8635    let injectedStyles = runtime.injectedStyles.get(targetDocument);
8636    if (!injectedStyles) {
8637      injectedStyles = /* @__PURE__ */ new Set();
8638      runtime.injectedStyles.set(targetDocument, injectedStyles);
8639    }
8640    if (injectedStyles.has(hash)) {
8641      return;
8642    }
8643    if (documentContainsStyleHash(targetDocument, hash)) {
8644      injectedStyles.add(hash);
8645      return;
8646    }
8647    const style = targetDocument.createElement("style");
8648    style.setAttribute(STYLE_HASH_ATTRIBUTE, hash);
8649    style.appendChild(targetDocument.createTextNode(css));
8650    targetDocument.head.appendChild(style);
8651    injectedStyles.add(hash);
8652  }
8653  function registerDocument(targetDocument) {
8654    const runtime = getRuntime();
8655    runtime.documents.set(
8656      targetDocument,
8657      (runtime.documents.get(targetDocument) ?? 0) + 1
8658    );
8659    for (const [hash, css] of runtime.styles) {
8660      injectStyle(targetDocument, hash, css);
8661    }
8662    return () => {
8663      const count = runtime.documents.get(targetDocument);
8664      if (count === void 0) {
8665        return;
8666      }
8667      if (count <= 1) {
8668        runtime.documents.delete(targetDocument);
8669        return;
8670      }
8671      runtime.documents.set(targetDocument, count - 1);
8672    };
8673  }
8674  function registerStyle(hash, css) {
8675    const runtime = getRuntime();
8676    runtime.styles.set(hash, css);
8677    for (const targetDocument of runtime.documents.keys()) {
8678      injectStyle(targetDocument, hash, css);
8679    }
8680  }
8681  if (typeof process === "undefined" || true) {
8682    registerStyle("15abcab4d0", ".f37b9e2e191ebd66__visually-hidden{border:0;clip-path:inset(50%);height:1px;margin:-1px;overflow:hidden;overflow-wrap:normal;padding:0;position:absolute;width:1px;word-break:normal}");
8683  }
8684  var style_default = { "visually-hidden": "f37b9e2e191ebd66__visually-hidden" };
8685  var VisuallyHidden = (0, import_element12.forwardRef)(
8686    function UnforwardedVisuallyHidden({ render, ...restProps }, ref) {
8687      const element = useRender({
8688        render,
8689        ref,
8690        props: mergeProps(
8691          { className: style_default["visually-hidden"] },
8692          restProps,
8693          {
8694            // @ts-expect-error Arbitrary data-* attributes aren't indexable on the typed div props. Kept hardcoded so consumers can't change or remove it.
8695            "data-visually-hidden": ""
8696          }
8697        )
8698      });
8699      return element;
8700    }
8701  );
8702  
8703  // packages/ui/build-module/utils/render-slot-with-children.mjs
8704  var import_element13 = __toESM(require_element(), 1);
8705  function renderSlotWithChildren(slot, defaultSlot, children) {
8706    return (0, import_element13.cloneElement)(
8707      slot ?? defaultSlot,
8708      { children }
8709    );
8710  }
8711  
8712  // packages/ui/build-module/utils/wp-compat-overlay-slot.mjs
8713  var STYLE_HASH_ATTRIBUTE2 = "data-wp-hash";
8714  function getRuntime2() {
8715    const globalScope = globalThis;
8716    if (globalScope.__wpStyleRuntime) {
8717      return globalScope.__wpStyleRuntime;
8718    }
8719    globalScope.__wpStyleRuntime = {
8720      documents: /* @__PURE__ */ new Map(),
8721      styles: /* @__PURE__ */ new Map(),
8722      injectedStyles: /* @__PURE__ */ new WeakMap()
8723    };
8724    if (typeof document !== "undefined") {
8725      registerDocument2(document);
8726    }
8727    return globalScope.__wpStyleRuntime;
8728  }
8729  function documentContainsStyleHash2(targetDocument, hash) {
8730    if (!targetDocument.head) {
8731      return false;
8732    }
8733    for (const style of targetDocument.head.querySelectorAll(
8734      `style[$STYLE_HASH_ATTRIBUTE2}]`
8735    )) {
8736      if (style.getAttribute(STYLE_HASH_ATTRIBUTE2) === hash) {
8737        return true;
8738      }
8739    }
8740    return false;
8741  }
8742  function injectStyle2(targetDocument, hash, css) {
8743    if (!targetDocument.head) {
8744      return;
8745    }
8746    const runtime = getRuntime2();
8747    let injectedStyles = runtime.injectedStyles.get(targetDocument);
8748    if (!injectedStyles) {
8749      injectedStyles = /* @__PURE__ */ new Set();
8750      runtime.injectedStyles.set(targetDocument, injectedStyles);
8751    }
8752    if (injectedStyles.has(hash)) {
8753      return;
8754    }
8755    if (documentContainsStyleHash2(targetDocument, hash)) {
8756      injectedStyles.add(hash);
8757      return;
8758    }
8759    const style = targetDocument.createElement("style");
8760    style.setAttribute(STYLE_HASH_ATTRIBUTE2, hash);
8761    style.appendChild(targetDocument.createTextNode(css));
8762    targetDocument.head.appendChild(style);
8763    injectedStyles.add(hash);
8764  }
8765  function registerDocument2(targetDocument) {
8766    const runtime = getRuntime2();
8767    runtime.documents.set(
8768      targetDocument,
8769      (runtime.documents.get(targetDocument) ?? 0) + 1
8770    );
8771    for (const [hash, css] of runtime.styles) {
8772      injectStyle2(targetDocument, hash, css);
8773    }
8774    return () => {
8775      const count = runtime.documents.get(targetDocument);
8776      if (count === void 0) {
8777        return;
8778      }
8779      if (count <= 1) {
8780        runtime.documents.delete(targetDocument);
8781        return;
8782      }
8783      runtime.documents.set(targetDocument, count - 1);
8784    };
8785  }
8786  function registerStyle2(hash, css) {
8787    const runtime = getRuntime2();
8788    runtime.styles.set(hash, css);
8789    for (const targetDocument of runtime.documents.keys()) {
8790      injectStyle2(targetDocument, hash, css);
8791    }
8792  }
8793  if (typeof process === "undefined" || true) {
8794    registerStyle2("be37f31c1e", "._11fc52b637ff8a7e__slot{inset:0;isolation:isolate;pointer-events:none;position:fixed;z-index:1000000003}@layer wp-ui{@layer utilities, components, compositions, overrides;@layer utilities{._11fc52b637ff8a7e__slot>*{pointer-events:auto}}}");
8795  }
8796  var wp_compat_overlay_slot_default = { "slot": "_11fc52b637ff8a7e__slot" };
8797  var WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE = "data-wp-compat-overlay-slot";
8798  function resolveOwnerDocument() {
8799    return typeof document === "undefined" ? null : document;
8800  }
8801  function isInWordPressEnvironment() {
8802    let topWp;
8803    try {
8804      topWp = window.top?.wp;
8805    } catch {
8806    }
8807    const wp = topWp ?? window.wp;
8808    return typeof wp?.components === "object" && wp.components !== null;
8809  }
8810  var cachedSlot = null;
8811  function ensureSlotIsAccessible(element) {
8812    element.setAttribute("aria-hidden", "false");
8813    return element;
8814  }
8815  function createSlot(ownerDocument2) {
8816    const element = ownerDocument2.createElement("div");
8817    element.setAttribute(WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE, "");
8818    if (wp_compat_overlay_slot_default.slot) {
8819      element.classList.add(wp_compat_overlay_slot_default.slot);
8820    }
8821    ownerDocument2.body.appendChild(element);
8822    return element;
8823  }
8824  function getWpCompatOverlaySlot() {
8825    if (typeof window === "undefined") {
8826      return void 0;
8827    }
8828    if (!isInWordPressEnvironment() && window.__wpUiCompatOverlaySlotEnabled !== true) {
8829      return void 0;
8830    }
8831    const ownerDocument2 = resolveOwnerDocument();
8832    if (!ownerDocument2 || !ownerDocument2.body) {
8833      return void 0;
8834    }
8835    if (cachedSlot && cachedSlot.ownerDocument === ownerDocument2 && cachedSlot.isConnected) {
8836      return ensureSlotIsAccessible(cachedSlot);
8837    }
8838    const existing = ownerDocument2.querySelector(
8839      `[$WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE}]`
8840    );
8841    if (existing instanceof HTMLDivElement) {
8842      cachedSlot = ensureSlotIsAccessible(existing);
8843      return cachedSlot;
8844    }
8845    if (cachedSlot?.isConnected) {
8846      cachedSlot.remove();
8847    }
8848    cachedSlot = ensureSlotIsAccessible(createSlot(ownerDocument2));
8849    return cachedSlot;
8850  }
8851  
8852  // packages/ui/build-module/utils/direction-provider.mjs
8853  var import_i18n = __toESM(require_i18n(), 1);
8854  var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
8855  function DirectionProvider3({ children }) {
8856    return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(DirectionProvider, { direction: (0, import_i18n.isRTL)() ? "rtl" : "ltr", children });
8857  }
8858  
8859  // packages/ui/build-module/tooltip/index.mjs
8860  var tooltip_exports = {};
8861  __export(tooltip_exports, {
8862    Popup: () => Popup,
8863    Portal: () => Portal,
8864    Positioner: () => Positioner,
8865    Provider: () => Provider,
8866    Root: () => Root,
8867    Trigger: () => Trigger
8868  });
8869  
8870  // packages/ui/build-module/tooltip/popup.mjs
8871  var import_element16 = __toESM(require_element(), 1);
8872  
8873  // packages/ui/build-module/tooltip/portal.mjs
8874  var import_element14 = __toESM(require_element(), 1);
8875  var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
8876  var Portal = (0, import_element14.forwardRef)(
8877    function TooltipPortal3({ container, ...restProps }, ref) {
8878      return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
8879        index_parts_exports.Portal,
8880        {
8881          container: container === void 0 ? getWpCompatOverlaySlot() : container,
8882          ...restProps,
8883          ref
8884        }
8885      );
8886    }
8887  );
8888  
8889  // packages/ui/build-module/tooltip/positioner.mjs
8890  var import_element15 = __toESM(require_element(), 1);
8891  var import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
8892  var STYLE_HASH_ATTRIBUTE3 = "data-wp-hash";
8893  function getRuntime3() {
8894    const globalScope = globalThis;
8895    if (globalScope.__wpStyleRuntime) {
8896      return globalScope.__wpStyleRuntime;
8897    }
8898    globalScope.__wpStyleRuntime = {
8899      documents: /* @__PURE__ */ new Map(),
8900      styles: /* @__PURE__ */ new Map(),
8901      injectedStyles: /* @__PURE__ */ new WeakMap()
8902    };
8903    if (typeof document !== "undefined") {
8904      registerDocument3(document);
8905    }
8906    return globalScope.__wpStyleRuntime;
8907  }
8908  function documentContainsStyleHash3(targetDocument, hash) {
8909    if (!targetDocument.head) {
8910      return false;
8911    }
8912    for (const style of targetDocument.head.querySelectorAll(
8913      `style[$STYLE_HASH_ATTRIBUTE3}]`
8914    )) {
8915      if (style.getAttribute(STYLE_HASH_ATTRIBUTE3) === hash) {
8916        return true;
8917      }
8918    }
8919    return false;
8920  }
8921  function injectStyle3(targetDocument, hash, css) {
8922    if (!targetDocument.head) {
8923      return;
8924    }
8925    const runtime = getRuntime3();
8926    let injectedStyles = runtime.injectedStyles.get(targetDocument);
8927    if (!injectedStyles) {
8928      injectedStyles = /* @__PURE__ */ new Set();
8929      runtime.injectedStyles.set(targetDocument, injectedStyles);
8930    }
8931    if (injectedStyles.has(hash)) {
8932      return;
8933    }
8934    if (documentContainsStyleHash3(targetDocument, hash)) {
8935      injectedStyles.add(hash);
8936      return;
8937    }
8938    const style = targetDocument.createElement("style");
8939    style.setAttribute(STYLE_HASH_ATTRIBUTE3, hash);
8940    style.appendChild(targetDocument.createTextNode(css));
8941    targetDocument.head.appendChild(style);
8942    injectedStyles.add(hash);
8943  }
8944  function registerDocument3(targetDocument) {
8945    const runtime = getRuntime3();
8946    runtime.documents.set(
8947      targetDocument,
8948      (runtime.documents.get(targetDocument) ?? 0) + 1
8949    );
8950    for (const [hash, css] of runtime.styles) {
8951      injectStyle3(targetDocument, hash, css);
8952    }
8953    return () => {
8954      const count = runtime.documents.get(targetDocument);
8955      if (count === void 0) {
8956        return;
8957      }
8958      if (count <= 1) {
8959        runtime.documents.delete(targetDocument);
8960        return;
8961      }
8962      runtime.documents.set(targetDocument, count - 1);
8963    };
8964  }
8965  function registerStyle3(hash, css) {
8966    const runtime = getRuntime3();
8967    runtime.styles.set(hash, css);
8968    for (const targetDocument of runtime.documents.keys()) {
8969      injectStyle3(targetDocument, hash, css);
8970    }
8971  }
8972  if (typeof process === "undefined" || true) {
8973    registerStyle3("10f3806643", "@layer wp-ui{@layer utilities, components, compositions, overrides;@layer utilities{._336cd3e4e743482f__box-sizing{box-sizing:border-box;*,:after,:before{box-sizing:inherit}}}}");
8974  }
8975  var resets_default = { "box-sizing": "_336cd3e4e743482f__box-sizing" };
8976  if (typeof process === "undefined" || true) {
8977    registerStyle3("19fcc06039", '@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{._480b748dd3510e64__positioner{z-index:var(--wp-ui-tooltip-z-index,initial)}._50096b232db7709d__popup{--_wp-ui-elevation-sm:0 1px 2px rgba(0,0,0,.05),0 2px 3px rgba(0,0,0,.04),0 6px 6px rgba(0,0,0,.03),0 8px 8px rgba(0,0,0,.02);background-color:var(--wpds-color-background-surface-neutral-strong,#fff);border-radius:var(--wpds-border-radius-md,4px);box-shadow:var(--_wp-ui-elevation-sm);color:var(--wpds-color-foreground-content-neutral,#1e1e1e);font-family:var(--wpds-typography-font-family-body,-apple-system,system-ui,"Segoe UI","Roboto","Oxygen-Sans","Ubuntu","Cantarell","Helvetica Neue",sans-serif);font-size:var(--wpds-typography-font-size-sm,12px);line-height:1.4;padding:var(--wpds-dimension-padding-xs,4px) var(--wpds-dimension-padding-sm,8px);@media (forced-colors:active){border-bottom-color:CanvasText;border-bottom-style:solid;border-bottom-width:1px;border-left-color:CanvasText;border-left-style:solid;border-left-width:1px;border-right-color:CanvasText;border-right-style:solid;border-right-width:1px;border-top-color:CanvasText;border-top-style:solid;border-top-width:1px}}}}');
8978  }
8979  var style_default2 = { "positioner": "_480b748dd3510e64__positioner", "popup": "_50096b232db7709d__popup" };
8980  var Positioner = (0, import_element15.forwardRef)(
8981    function TooltipPositioner3({ align = "center", className, side = "top", sideOffset = 4, ...props }, ref) {
8982      return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
8983        index_parts_exports.Positioner,
8984        {
8985          ref,
8986          align,
8987          side,
8988          sideOffset,
8989          ...props,
8990          className: clsx_default(
8991            resets_default["box-sizing"],
8992            style_default2.positioner,
8993            className
8994          )
8995        }
8996      );
8997    }
8998  );
8999  
9000  // packages/ui/build-module/utils/theme-provider.mjs
9001  var theme = __toESM(require_theme(), 1);
9002  
9003  // packages/ui/build-module/lock-unlock.mjs
9004  var import_private_apis = __toESM(require_private_apis(), 1);
9005  var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
9006    "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
9007    "@wordpress/ui"
9008  );
9009  
9010  // packages/ui/build-module/utils/theme-provider.mjs
9011  function getThemeProvider() {
9012    const themePackage = theme;
9013    if (themePackage.ThemeProvider) {
9014      return themePackage.ThemeProvider;
9015    }
9016    if (!themePackage.privateApis) {
9017      throw new Error(
9018        "@wordpress/ui: @wordpress/theme must expose `ThemeProvider` or `privateApis.ThemeProvider`."
9019      );
9020    }
9021    return unlock(
9022      themePackage.privateApis
9023    ).ThemeProvider;
9024  }
9025  var ThemeProvider = getThemeProvider();
9026  
9027  // packages/ui/build-module/tooltip/popup.mjs
9028  var import_jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
9029  var STYLE_HASH_ATTRIBUTE4 = "data-wp-hash";
9030  function getRuntime4() {
9031    const globalScope = globalThis;
9032    if (globalScope.__wpStyleRuntime) {
9033      return globalScope.__wpStyleRuntime;
9034    }
9035    globalScope.__wpStyleRuntime = {
9036      documents: /* @__PURE__ */ new Map(),
9037      styles: /* @__PURE__ */ new Map(),
9038      injectedStyles: /* @__PURE__ */ new WeakMap()
9039    };
9040    if (typeof document !== "undefined") {
9041      registerDocument4(document);
9042    }
9043    return globalScope.__wpStyleRuntime;
9044  }
9045  function documentContainsStyleHash4(targetDocument, hash) {
9046    if (!targetDocument.head) {
9047      return false;
9048    }
9049    for (const style of targetDocument.head.querySelectorAll(
9050      `style[$STYLE_HASH_ATTRIBUTE4}]`
9051    )) {
9052      if (style.getAttribute(STYLE_HASH_ATTRIBUTE4) === hash) {
9053        return true;
9054      }
9055    }
9056    return false;
9057  }
9058  function injectStyle4(targetDocument, hash, css) {
9059    if (!targetDocument.head) {
9060      return;
9061    }
9062    const runtime = getRuntime4();
9063    let injectedStyles = runtime.injectedStyles.get(targetDocument);
9064    if (!injectedStyles) {
9065      injectedStyles = /* @__PURE__ */ new Set();
9066      runtime.injectedStyles.set(targetDocument, injectedStyles);
9067    }
9068    if (injectedStyles.has(hash)) {
9069      return;
9070    }
9071    if (documentContainsStyleHash4(targetDocument, hash)) {
9072      injectedStyles.add(hash);
9073      return;
9074    }
9075    const style = targetDocument.createElement("style");
9076    style.setAttribute(STYLE_HASH_ATTRIBUTE4, hash);
9077    style.appendChild(targetDocument.createTextNode(css));
9078    targetDocument.head.appendChild(style);
9079    injectedStyles.add(hash);
9080  }
9081  function registerDocument4(targetDocument) {
9082    const runtime = getRuntime4();
9083    runtime.documents.set(
9084      targetDocument,
9085      (runtime.documents.get(targetDocument) ?? 0) + 1
9086    );
9087    for (const [hash, css] of runtime.styles) {
9088      injectStyle4(targetDocument, hash, css);
9089    }
9090    return () => {
9091      const count = runtime.documents.get(targetDocument);
9092      if (count === void 0) {
9093        return;
9094      }
9095      if (count <= 1) {
9096        runtime.documents.delete(targetDocument);
9097        return;
9098      }
9099      runtime.documents.set(targetDocument, count - 1);
9100    };
9101  }
9102  function registerStyle4(hash, css) {
9103    const runtime = getRuntime4();
9104    runtime.styles.set(hash, css);
9105    for (const targetDocument of runtime.documents.keys()) {
9106      injectStyle4(targetDocument, hash, css);
9107    }
9108  }
9109  if (typeof process === "undefined" || true) {
9110    registerStyle4("19fcc06039", '@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{._480b748dd3510e64__positioner{z-index:var(--wp-ui-tooltip-z-index,initial)}._50096b232db7709d__popup{--_wp-ui-elevation-sm:0 1px 2px rgba(0,0,0,.05),0 2px 3px rgba(0,0,0,.04),0 6px 6px rgba(0,0,0,.03),0 8px 8px rgba(0,0,0,.02);background-color:var(--wpds-color-background-surface-neutral-strong,#fff);border-radius:var(--wpds-border-radius-md,4px);box-shadow:var(--_wp-ui-elevation-sm);color:var(--wpds-color-foreground-content-neutral,#1e1e1e);font-family:var(--wpds-typography-font-family-body,-apple-system,system-ui,"Segoe UI","Roboto","Oxygen-Sans","Ubuntu","Cantarell","Helvetica Neue",sans-serif);font-size:var(--wpds-typography-font-size-sm,12px);line-height:1.4;padding:var(--wpds-dimension-padding-xs,4px) var(--wpds-dimension-padding-sm,8px);@media (forced-colors:active){border-bottom-color:CanvasText;border-bottom-style:solid;border-bottom-width:1px;border-left-color:CanvasText;border-left-style:solid;border-left-width:1px;border-right-color:CanvasText;border-right-style:solid;border-right-width:1px;border-top-color:CanvasText;border-top-style:solid;border-top-width:1px}}}}');
9111  }
9112  var style_default3 = { "positioner": "_480b748dd3510e64__positioner", "popup": "_50096b232db7709d__popup" };
9113  var POPUP_COLOR = { background: "#1e1e1e" };
9114  var Popup = (0, import_element16.forwardRef)(function TooltipPopup3({ portal, positioner, children, className, ...props }, ref) {
9115    const popupContent = /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(ThemeProvider, { color: POPUP_COLOR, children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(
9116      index_parts_exports.Popup,
9117      {
9118        ref,
9119        className: clsx_default(style_default3.popup, className),
9120        ...props,
9121        children
9122      }
9123    ) });
9124    const positionedPopup = renderSlotWithChildren(
9125      positioner,
9126      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(Positioner, {}),
9127      popupContent
9128    );
9129    return renderSlotWithChildren(portal, /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(Portal, {}), positionedPopup);
9130  });
9131  
9132  // packages/ui/build-module/tooltip/trigger.mjs
9133  var import_element17 = __toESM(require_element(), 1);
9134  var import_jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
9135  var Trigger = (0, import_element17.forwardRef)(
9136    function TooltipTrigger3(props, ref) {
9137      return /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(index_parts_exports.Trigger, { ref, ...props });
9138    }
9139  );
9140  
9141  // packages/ui/build-module/tooltip/root.mjs
9142  var import_jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
9143  function Root(props) {
9144    return /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(DirectionProvider3, { children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(index_parts_exports.Root, { ...props }) });
9145  }
9146  
9147  // packages/ui/build-module/tooltip/provider.mjs
9148  var import_jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
9149  function Provider({ ...props }) {
9150    return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(index_parts_exports.Provider, { ...props });
9151  }
9152  
9153  // packages/ui/build-module/stack/stack.mjs
9154  var import_element18 = __toESM(require_element(), 1);
9155  var STYLE_HASH_ATTRIBUTE5 = "data-wp-hash";
9156  function getRuntime5() {
9157    const globalScope = globalThis;
9158    if (globalScope.__wpStyleRuntime) {
9159      return globalScope.__wpStyleRuntime;
9160    }
9161    globalScope.__wpStyleRuntime = {
9162      documents: /* @__PURE__ */ new Map(),
9163      styles: /* @__PURE__ */ new Map(),
9164      injectedStyles: /* @__PURE__ */ new WeakMap()
9165    };
9166    if (typeof document !== "undefined") {
9167      registerDocument5(document);
9168    }
9169    return globalScope.__wpStyleRuntime;
9170  }
9171  function documentContainsStyleHash5(targetDocument, hash) {
9172    if (!targetDocument.head) {
9173      return false;
9174    }
9175    for (const style of targetDocument.head.querySelectorAll(
9176      `style[$STYLE_HASH_ATTRIBUTE5}]`
9177    )) {
9178      if (style.getAttribute(STYLE_HASH_ATTRIBUTE5) === hash) {
9179        return true;
9180      }
9181    }
9182    return false;
9183  }
9184  function injectStyle5(targetDocument, hash, css) {
9185    if (!targetDocument.head) {
9186      return;
9187    }
9188    const runtime = getRuntime5();
9189    let injectedStyles = runtime.injectedStyles.get(targetDocument);
9190    if (!injectedStyles) {
9191      injectedStyles = /* @__PURE__ */ new Set();
9192      runtime.injectedStyles.set(targetDocument, injectedStyles);
9193    }
9194    if (injectedStyles.has(hash)) {
9195      return;
9196    }
9197    if (documentContainsStyleHash5(targetDocument, hash)) {
9198      injectedStyles.add(hash);
9199      return;
9200    }
9201    const style = targetDocument.createElement("style");
9202    style.setAttribute(STYLE_HASH_ATTRIBUTE5, hash);
9203    style.appendChild(targetDocument.createTextNode(css));
9204    targetDocument.head.appendChild(style);
9205    injectedStyles.add(hash);
9206  }
9207  function registerDocument5(targetDocument) {
9208    const runtime = getRuntime5();
9209    runtime.documents.set(
9210      targetDocument,
9211      (runtime.documents.get(targetDocument) ?? 0) + 1
9212    );
9213    for (const [hash, css] of runtime.styles) {
9214      injectStyle5(targetDocument, hash, css);
9215    }
9216    return () => {
9217      const count = runtime.documents.get(targetDocument);
9218      if (count === void 0) {
9219        return;
9220      }
9221      if (count <= 1) {
9222        runtime.documents.delete(targetDocument);
9223        return;
9224      }
9225      runtime.documents.set(targetDocument, count - 1);
9226    };
9227  }
9228  function registerStyle5(hash, css) {
9229    const runtime = getRuntime5();
9230    runtime.styles.set(hash, css);
9231    for (const targetDocument of runtime.documents.keys()) {
9232      injectStyle5(targetDocument, hash, css);
9233    }
9234  }
9235  if (typeof process === "undefined" || true) {
9236    registerStyle5("32aba35fe1", "@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{._19ce0419607e1896__stack{display:flex}}}");
9237  }
9238  var style_default4 = { "stack": "_19ce0419607e1896__stack" };
9239  var gapTokens = {
9240    xs: "var(--wpds-dimension-gap-xs, 4px)",
9241    sm: "var(--wpds-dimension-gap-sm, 8px)",
9242    md: "var(--wpds-dimension-gap-md, 12px)",
9243    lg: "var(--wpds-dimension-gap-lg, 16px)",
9244    xl: "var(--wpds-dimension-gap-xl, 24px)",
9245    "2xl": "var(--wpds-dimension-gap-2xl, 32px)",
9246    "3xl": "var(--wpds-dimension-gap-3xl, 40px)"
9247  };
9248  var Stack = (0, import_element18.forwardRef)(
9249    function UnforwardedStack({ direction, gap, align, justify, wrap, render, ...props }, ref) {
9250      const style = {
9251        gap: gap && gapTokens[gap],
9252        alignItems: align,
9253        justifyContent: justify,
9254        flexDirection: direction,
9255        flexWrap: wrap
9256      };
9257      const element = useRender({
9258        render,
9259        ref,
9260        props: mergeProps(props, {
9261          style,
9262          className: style_default4.stack
9263        })
9264      });
9265      return element;
9266    }
9267  );
9268  
9269  // packages/core-fields/build-module/wp_template/author/view.mjs
9270  var import_jsx_runtime25 = __toESM(require_jsx_runtime(), 1);
9271  var STYLE_HASH_ATTRIBUTE6 = "data-wp-hash";
9272  function getRuntime6() {
9273    const globalScope = globalThis;
9274    if (globalScope.__wpStyleRuntime) {
9275      return globalScope.__wpStyleRuntime;
9276    }
9277    globalScope.__wpStyleRuntime = {
9278      documents: /* @__PURE__ */ new Map(),
9279      styles: /* @__PURE__ */ new Map(),
9280      injectedStyles: /* @__PURE__ */ new WeakMap()
9281    };
9282    if (typeof document !== "undefined") {
9283      registerDocument6(document);
9284    }
9285    return globalScope.__wpStyleRuntime;
9286  }
9287  function documentContainsStyleHash6(targetDocument, hash) {
9288    if (!targetDocument.head) {
9289      return false;
9290    }
9291    for (const style of targetDocument.head.querySelectorAll(
9292      `style[$STYLE_HASH_ATTRIBUTE6}]`
9293    )) {
9294      if (style.getAttribute(STYLE_HASH_ATTRIBUTE6) === hash) {
9295        return true;
9296      }
9297    }
9298    return false;
9299  }
9300  function injectStyle6(targetDocument, hash, css) {
9301    if (!targetDocument.head) {
9302      return;
9303    }
9304    const runtime = getRuntime6();
9305    let injectedStyles = runtime.injectedStyles.get(targetDocument);
9306    if (!injectedStyles) {
9307      injectedStyles = /* @__PURE__ */ new Set();
9308      runtime.injectedStyles.set(targetDocument, injectedStyles);
9309    }
9310    if (injectedStyles.has(hash)) {
9311      return;
9312    }
9313    if (documentContainsStyleHash6(targetDocument, hash)) {
9314      injectedStyles.add(hash);
9315      return;
9316    }
9317    const style = targetDocument.createElement("style");
9318    style.setAttribute(STYLE_HASH_ATTRIBUTE6, hash);
9319    style.appendChild(targetDocument.createTextNode(css));
9320    targetDocument.head.appendChild(style);
9321    injectedStyles.add(hash);
9322  }
9323  function registerDocument6(targetDocument) {
9324    const runtime = getRuntime6();
9325    runtime.documents.set(
9326      targetDocument,
9327      (runtime.documents.get(targetDocument) ?? 0) + 1
9328    );
9329    for (const [hash, css] of runtime.styles) {
9330      injectStyle6(targetDocument, hash, css);
9331    }
9332    return () => {
9333      const count = runtime.documents.get(targetDocument);
9334      if (count === void 0) {
9335        return;
9336      }
9337      if (count <= 1) {
9338        runtime.documents.delete(targetDocument);
9339        return;
9340      }
9341      runtime.documents.set(targetDocument, count - 1);
9342    };
9343  }
9344  function registerStyle6(hash, css) {
9345    const runtime = getRuntime6();
9346    runtime.styles.set(hash, css);
9347    for (const targetDocument of runtime.documents.keys()) {
9348      injectStyle6(targetDocument, hash, css);
9349    }
9350  }
9351  if (typeof process === "undefined" || true) {
9352    registerStyle6("e26bdc0796", ".eddbc0a77c8a621a__avatar{align-items:center;block-size:24px;display:flex;flex-shrink:0;inline-size:24px;justify-content:start;overflow:hidden}.eddbc0a77c8a621a__avatar img{block-size:16px;border-radius:100%;inline-size:16px;object-fit:cover;opacity:0}@media not (prefers-reduced-motion){.eddbc0a77c8a621a__avatar img{transition:opacity .1s linear}}.eddbc0a77c8a621a__avatar._5e74dacabd67dfdf__is-loaded img{opacity:1}.c0d40ce1da6dacc2__icon{block-size:24px;display:flex;flex-shrink:0;inline-size:24px}.c0d40ce1da6dacc2__icon svg{fill:currentColor;margin-inline-start:-4px}._9e337be7fe946fd4__name{overflow:hidden;text-overflow:ellipsis}");
9353  }
9354  var style_default5 = { "avatar": "eddbc0a77c8a621a__avatar", "is-loaded": "_5e74dacabd67dfdf__is-loaded", "icon": "c0d40ce1da6dacc2__icon", "name": "_9e337be7fe946fd4__name" };
9355  function getIconForSource(originalSource) {
9356    switch (originalSource) {
9357      case "theme":
9358        return layout_default;
9359      case "plugin":
9360        return plugins_default;
9361      case "site":
9362        return globe_default;
9363      default:
9364        return comment_author_avatar_default;
9365    }
9366  }
9367  function TemplateAuthorView({ item }) {
9368    const [isImageLoaded, setIsImageLoaded] = (0, import_element19.useState)(false);
9369    const originalSource = item.original_source;
9370    const icon = getIconForSource(originalSource);
9371    const text = item.author_text;
9372    const authorId = item.author;
9373    const imageUrl = (0, import_data.useSelect)(
9374      (select) => {
9375        if (originalSource === "site") {
9376          const siteData = select(import_core_data.store).getEntityRecord("root", "__unstableBase");
9377          const logoId = siteData?.site_logo;
9378          if (!logoId) {
9379            return void 0;
9380          }
9381          return select(import_core_data.store).getEntityRecord("postType", "attachment", logoId)?.source_url;
9382        }
9383        if (originalSource !== "user" || !authorId) {
9384          return void 0;
9385        }
9386        return select(import_core_data.store).getUser(authorId)?.avatar_urls?.[48];
9387      },
9388      [originalSource, authorId]
9389    );
9390    return /* @__PURE__ */ (0, import_jsx_runtime25.jsxs)(Stack, { direction: "row", align: "center", children: [
9391      imageUrl && /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
9392        "div",
9393        {
9394          className: clsx_default(style_default5.avatar, {
9395            [style_default5["is-loaded"]]: isImageLoaded
9396          }),
9397          children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
9398            "img",
9399            {
9400              onLoad: () => setIsImageLoaded(true),
9401              alt: "",
9402              src: imageUrl
9403            }
9404          )
9405        }
9406      ),
9407      !imageUrl && /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("div", { className: style_default5.icon, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(Icon, { icon }) }),
9408      /* @__PURE__ */ (0, import_jsx_runtime25.jsx)("span", { className: style_default5.name, children: text })
9409    ] });
9410  }
9411  
9412  // packages/core-fields/build-module/wp_template/author/get-author-elements.mjs
9413  var import_data2 = __toESM(require_data(), 1);
9414  var import_core_data2 = __toESM(require_core_data(), 1);
9415  async function getAuthorElements(postType) {
9416    const records = await (0, import_data2.resolveSelect)(import_core_data2.store).getEntityRecords(
9417      "postType",
9418      postType,
9419      { per_page: -1, _fields: "id,author_text" }
9420    );
9421    const seen = /* @__PURE__ */ new Set();
9422    const elements = [];
9423    for (const record of records ?? []) {
9424      const value = record.author_text;
9425      if (value && !seen.has(value)) {
9426        seen.add(value);
9427        elements.push({ value, label: value });
9428      }
9429    }
9430    return elements;
9431  }
9432  
9433  // packages/core-fields/build-module/wp_template_part/author/field.mjs
9434  var fieldExtensions = {
9435    getValue: ({ item }) => item.author_text,
9436    render: TemplateAuthorView,
9437    getElements: () => getAuthorElements("wp_template_part")
9438  };
9439  
9440  // packages/core-fields/build-module/shared/title/get-item-title.mjs
9441  var import_html_entities = __toESM(require_html_entities(), 1);
9442  var import_i18n2 = __toESM(require_i18n(), 1);
9443  function getItemTitle(item, fallback = (0, import_i18n2.__)("(no title)")) {
9444    let title = "";
9445    if (typeof item.title === "string") {
9446      title = (0, import_html_entities.decodeEntities)(item.title);
9447    } else if (item.title && "rendered" in item.title) {
9448      title = (0, import_html_entities.decodeEntities)(item.title.rendered ?? "");
9449    } else if (item.title && "raw" in item.title) {
9450      title = (0, import_html_entities.decodeEntities)(item.title.raw ?? "");
9451    }
9452    return title || fallback;
9453  }
9454  
9455  // packages/core-fields/build-module/shared/title/pattern-view.mjs
9456  var import_i18n4 = __toESM(require_i18n(), 1);
9457  
9458  // packages/core-fields/build-module/shared/title/view.mjs
9459  var import_i18n3 = __toESM(require_i18n(), 1);
9460  var import_jsx_runtime26 = __toESM(require_jsx_runtime(), 1);
9461  var STYLE_HASH_ATTRIBUTE7 = "data-wp-hash";
9462  function getRuntime7() {
9463    const globalScope = globalThis;
9464    if (globalScope.__wpStyleRuntime) {
9465      return globalScope.__wpStyleRuntime;
9466    }
9467    globalScope.__wpStyleRuntime = {
9468      documents: /* @__PURE__ */ new Map(),
9469      styles: /* @__PURE__ */ new Map(),
9470      injectedStyles: /* @__PURE__ */ new WeakMap()
9471    };
9472    if (typeof document !== "undefined") {
9473      registerDocument7(document);
9474    }
9475    return globalScope.__wpStyleRuntime;
9476  }
9477  function documentContainsStyleHash7(targetDocument, hash) {
9478    if (!targetDocument.head) {
9479      return false;
9480    }
9481    for (const style of targetDocument.head.querySelectorAll(
9482      `style[$STYLE_HASH_ATTRIBUTE7}]`
9483    )) {
9484      if (style.getAttribute(STYLE_HASH_ATTRIBUTE7) === hash) {
9485        return true;
9486      }
9487    }
9488    return false;
9489  }
9490  function injectStyle7(targetDocument, hash, css) {
9491    if (!targetDocument.head) {
9492      return;
9493    }
9494    const runtime = getRuntime7();
9495    let injectedStyles = runtime.injectedStyles.get(targetDocument);
9496    if (!injectedStyles) {
9497      injectedStyles = /* @__PURE__ */ new Set();
9498      runtime.injectedStyles.set(targetDocument, injectedStyles);
9499    }
9500    if (injectedStyles.has(hash)) {
9501      return;
9502    }
9503    if (documentContainsStyleHash7(targetDocument, hash)) {
9504      injectedStyles.add(hash);
9505      return;
9506    }
9507    const style = targetDocument.createElement("style");
9508    style.setAttribute(STYLE_HASH_ATTRIBUTE7, hash);
9509    style.appendChild(targetDocument.createTextNode(css));
9510    targetDocument.head.appendChild(style);
9511    injectedStyles.add(hash);
9512  }
9513  function registerDocument7(targetDocument) {
9514    const runtime = getRuntime7();
9515    runtime.documents.set(
9516      targetDocument,
9517      (runtime.documents.get(targetDocument) ?? 0) + 1
9518    );
9519    for (const [hash, css] of runtime.styles) {
9520      injectStyle7(targetDocument, hash, css);
9521    }
9522    return () => {
9523      const count = runtime.documents.get(targetDocument);
9524      if (count === void 0) {
9525        return;
9526      }
9527      if (count <= 1) {
9528        runtime.documents.delete(targetDocument);
9529        return;
9530      }
9531      runtime.documents.set(targetDocument, count - 1);
9532    };
9533  }
9534  function registerStyle7(hash, css) {
9535    const runtime = getRuntime7();
9536    runtime.styles.set(hash, css);
9537    for (const targetDocument of runtime.documents.keys()) {
9538      injectStyle7(targetDocument, hash, css);
9539    }
9540  }
9541  if (typeof process === "undefined" || true) {
9542    registerStyle7("cd9f81046b", ".f17c7d5418aade3c__title>span:first-child{display:block;flex-grow:0;overflow:hidden;text-decoration:none;text-overflow:ellipsis;white-space:nowrap}._86b9872383a1ab5e__pattern-title>span:first-child{flex:1}");
9543  }
9544  var style_default6 = { "title": "f17c7d5418aade3c__title", "pattern-title": "_86b9872383a1ab5e__pattern-title" };
9545  function BaseTitleView({
9546    item,
9547    className,
9548    children
9549  }) {
9550    const renderedTitle = getItemTitle(item);
9551    return /* @__PURE__ */ (0, import_jsx_runtime26.jsxs)(
9552      Stack,
9553      {
9554        direction: "row",
9555        align: "center",
9556        justify: "flex-start",
9557        gap: "sm",
9558        className: clsx_default("fields-field__title", style_default6.title, className),
9559        children: [
9560          /* @__PURE__ */ (0, import_jsx_runtime26.jsx)("span", { children: renderedTitle || (0, import_i18n3.__)("(no title)") }),
9561          children
9562        ]
9563      }
9564    );
9565  }
9566  
9567  // packages/core-fields/build-module/shared/title/pattern-view.mjs
9568  var import_jsx_runtime27 = __toESM(require_jsx_runtime(), 1);
9569  var STYLE_HASH_ATTRIBUTE8 = "data-wp-hash";
9570  function getRuntime8() {
9571    const globalScope = globalThis;
9572    if (globalScope.__wpStyleRuntime) {
9573      return globalScope.__wpStyleRuntime;
9574    }
9575    globalScope.__wpStyleRuntime = {
9576      documents: /* @__PURE__ */ new Map(),
9577      styles: /* @__PURE__ */ new Map(),
9578      injectedStyles: /* @__PURE__ */ new WeakMap()
9579    };
9580    if (typeof document !== "undefined") {
9581      registerDocument8(document);
9582    }
9583    return globalScope.__wpStyleRuntime;
9584  }
9585  function documentContainsStyleHash8(targetDocument, hash) {
9586    if (!targetDocument.head) {
9587      return false;
9588    }
9589    for (const style of targetDocument.head.querySelectorAll(
9590      `style[$STYLE_HASH_ATTRIBUTE8}]`
9591    )) {
9592      if (style.getAttribute(STYLE_HASH_ATTRIBUTE8) === hash) {
9593        return true;
9594      }
9595    }
9596    return false;
9597  }
9598  function injectStyle8(targetDocument, hash, css) {
9599    if (!targetDocument.head) {
9600      return;
9601    }
9602    const runtime = getRuntime8();
9603    let injectedStyles = runtime.injectedStyles.get(targetDocument);
9604    if (!injectedStyles) {
9605      injectedStyles = /* @__PURE__ */ new Set();
9606      runtime.injectedStyles.set(targetDocument, injectedStyles);
9607    }
9608    if (injectedStyles.has(hash)) {
9609      return;
9610    }
9611    if (documentContainsStyleHash8(targetDocument, hash)) {
9612      injectedStyles.add(hash);
9613      return;
9614    }
9615    const style = targetDocument.createElement("style");
9616    style.setAttribute(STYLE_HASH_ATTRIBUTE8, hash);
9617    style.appendChild(targetDocument.createTextNode(css));
9618    targetDocument.head.appendChild(style);
9619    injectedStyles.add(hash);
9620  }
9621  function registerDocument8(targetDocument) {
9622    const runtime = getRuntime8();
9623    runtime.documents.set(
9624      targetDocument,
9625      (runtime.documents.get(targetDocument) ?? 0) + 1
9626    );
9627    for (const [hash, css] of runtime.styles) {
9628      injectStyle8(targetDocument, hash, css);
9629    }
9630    return () => {
9631      const count = runtime.documents.get(targetDocument);
9632      if (count === void 0) {
9633        return;
9634      }
9635      if (count <= 1) {
9636        runtime.documents.delete(targetDocument);
9637        return;
9638      }
9639      runtime.documents.set(targetDocument, count - 1);
9640    };
9641  }
9642  function registerStyle8(hash, css) {
9643    const runtime = getRuntime8();
9644    runtime.styles.set(hash, css);
9645    for (const targetDocument of runtime.documents.keys()) {
9646      injectStyle8(targetDocument, hash, css);
9647    }
9648  }
9649  if (typeof process === "undefined" || true) {
9650    registerStyle8("cd9f81046b", ".f17c7d5418aade3c__title>span:first-child{display:block;flex-grow:0;overflow:hidden;text-decoration:none;text-overflow:ellipsis;white-space:nowrap}._86b9872383a1ab5e__pattern-title>span:first-child{flex:1}");
9651  }
9652  var style_default7 = { "title": "f17c7d5418aade3c__title", "pattern-title": "_86b9872383a1ab5e__pattern-title" };
9653  function PatternTitleView({
9654    item
9655  }) {
9656    const lockMessage = (0, import_i18n4.__)("This pattern cannot be edited.");
9657    return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
9658      BaseTitleView,
9659      {
9660        item,
9661        className: clsx_default(
9662          "fields-field__pattern-title",
9663          style_default7["pattern-title"]
9664        ),
9665        children: item.type === "pattern" && /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(import_jsx_runtime27.Fragment, { children: [
9666          /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(VisuallyHidden, { children: lockMessage }),
9667          /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(tooltip_exports.Root, { children: [
9668            /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
9669              tooltip_exports.Trigger,
9670              {
9671                render: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(icon_default, { icon: lock_small_default, size: 24 })
9672              }
9673            ),
9674            /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(tooltip_exports.Popup, { children: lockMessage })
9675          ] })
9676        ] })
9677      }
9678    );
9679  }
9680  
9681  // packages/core-fields/build-module/wp_template_part/title/field.mjs
9682  var fieldExtensions2 = {
9683    getValue: ({ item }) => getItemTitle(item),
9684    render: PatternTitleView
9685  };
9686  
9687  // packages/core-fields/build-module/wp_template_part/index.mjs
9688  var fields = {
9689    author: fieldExtensions,
9690    title: fieldExtensions2
9691  };
9692  var wp_template_part_default = fields;
9693  export {
9694    wp_template_part_default as default
9695  };
9696  /*! Bundled license information:
9697  
9698  use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
9699    (**
9700     * @license React
9701     * use-sync-external-store-shim.development.js
9702     *
9703     * Copyright (c) Meta Platforms, Inc. and affiliates.
9704     *
9705     * This source code is licensed under the MIT license found in the
9706     * LICENSE file in the root directory of this source tree.
9707     *)
9708  
9709  use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js:
9710    (**
9711     * @license React
9712     * use-sync-external-store-shim/with-selector.development.js
9713     *
9714     * Copyright (c) Meta Platforms, Inc. and affiliates.
9715     *
9716     * This source code is licensed under the MIT license found in the
9717     * LICENSE file in the root directory of this source tree.
9718     *)
9719  */