[Summary view] [Print] [Text view]

   1  (function() {
   2  "use strict";
   3  var wp;
   4  (wp ||= {}).commands = (() => {
   5    var __create = Object.create;
   6    var __defProp = Object.defineProperty;
   7    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   8    var __getOwnPropNames = Object.getOwnPropertyNames;
   9    var __getProtoOf = Object.getPrototypeOf;
  10    var __hasOwnProp = Object.prototype.hasOwnProperty;
  11    var __commonJS = (cb, mod) => function __require() {
  12      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  13    };
  14    var __export = (target, all) => {
  15      for (var name in all)
  16        __defProp(target, name, { get: all[name], enumerable: true });
  17    };
  18    var __copyProps = (to, from, except, desc) => {
  19      if (from && typeof from === "object" || typeof from === "function") {
  20        for (let key of __getOwnPropNames(from))
  21          if (!__hasOwnProp.call(to, key) && key !== except)
  22            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  23      }
  24      return to;
  25    };
  26    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  27      // If the importer is in node compatibility mode or this is not an ESM
  28      // file that has been converted to a CommonJS file using a Babel-
  29      // compatible transform (i.e. "__esModule" has not been set), then set
  30      // "default" to the CommonJS "module.exports" for node compatibility.
  31      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  32      mod
  33    ));
  34    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  35  
  36    // vendor-external:react
  37    var require_react = __commonJS({
  38      "vendor-external:react"(exports, module) {
  39        module.exports = window.React;
  40      }
  41    });
  42  
  43    // vendor-external:react/jsx-runtime
  44    var require_jsx_runtime = __commonJS({
  45      "vendor-external:react/jsx-runtime"(exports, module) {
  46        module.exports = window.ReactJSXRuntime;
  47      }
  48    });
  49  
  50    // vendor-external:react-dom
  51    var require_react_dom = __commonJS({
  52      "vendor-external:react-dom"(exports, module) {
  53        module.exports = window.ReactDOM;
  54      }
  55    });
  56  
  57    // package-external:@wordpress/data
  58    var require_data = __commonJS({
  59      "package-external:@wordpress/data"(exports, module) {
  60        module.exports = window.wp.data;
  61      }
  62    });
  63  
  64    // package-external:@wordpress/element
  65    var require_element = __commonJS({
  66      "package-external:@wordpress/element"(exports, module) {
  67        module.exports = window.wp.element;
  68      }
  69    });
  70  
  71    // package-external:@wordpress/i18n
  72    var require_i18n = __commonJS({
  73      "package-external:@wordpress/i18n"(exports, module) {
  74        module.exports = window.wp.i18n;
  75      }
  76    });
  77  
  78    // package-external:@wordpress/components
  79    var require_components = __commonJS({
  80      "package-external:@wordpress/components"(exports, module) {
  81        module.exports = window.wp.components;
  82      }
  83    });
  84  
  85    // package-external:@wordpress/keyboard-shortcuts
  86    var require_keyboard_shortcuts = __commonJS({
  87      "package-external:@wordpress/keyboard-shortcuts"(exports, module) {
  88        module.exports = window.wp.keyboardShortcuts;
  89      }
  90    });
  91  
  92    // package-external:@wordpress/keycodes
  93    var require_keycodes = __commonJS({
  94      "package-external:@wordpress/keycodes"(exports, module) {
  95        module.exports = window.wp.keycodes;
  96      }
  97    });
  98  
  99    // package-external:@wordpress/primitives
 100    var require_primitives = __commonJS({
 101      "package-external:@wordpress/primitives"(exports, module) {
 102        module.exports = window.wp.primitives;
 103      }
 104    });
 105  
 106    // package-external:@wordpress/private-apis
 107    var require_private_apis = __commonJS({
 108      "package-external:@wordpress/private-apis"(exports, module) {
 109        module.exports = window.wp.privateApis;
 110      }
 111    });
 112  
 113    // package-external:@wordpress/preferences
 114    var require_preferences = __commonJS({
 115      "package-external:@wordpress/preferences"(exports, module) {
 116        module.exports = window.wp.preferences;
 117      }
 118    });
 119  
 120    // packages/commands/build-module/index.mjs
 121    var index_exports = {};
 122    __export(index_exports, {
 123      CommandMenu: () => CommandMenu,
 124      privateApis: () => privateApis,
 125      store: () => store,
 126      useCommand: () => useCommand,
 127      useCommandLoader: () => useCommandLoader,
 128      useCommands: () => useCommands
 129    });
 130  
 131    // node_modules/.store/cmdk@1.1.1-2SvSjHrFhiqsPDore7Lelw/node_modules/cmdk/dist/chunk-NZJY6EH4.mjs
 132    var U = 1;
 133    var Y = 0.9;
 134    var H = 0.8;
 135    var J = 0.17;
 136    var p = 0.1;
 137    var u = 0.999;
 138    var $ = 0.9999;
 139    var k = 0.99;
 140    var m = /[\\\/_+.#"@\[\(\{&]/;
 141    var B = /[\\\/_+.#"@\[\(\{&]/g;
 142    var K = /[\s-]/;
 143    var X = /[\s-]/g;
 144    function G(_, C, h, P2, A, f, O) {
 145      if (f === C.length) return A === _.length ? U : k;
 146      var T2 = `$A},$f}`;
 147      if (O[T2] !== void 0) return O[T2];
 148      for (var L2 = P2.charAt(f), c = h.indexOf(L2, A), S = 0, E, N2, R, M; c >= 0; ) E = G(_, C, h, P2, c + 1, f + 1, O), E > S && (c === A ? E *= U : m.test(_.charAt(c - 1)) ? (E *= H, R = _.slice(A, c - 1).match(B), R && A > 0 && (E *= Math.pow(u, R.length))) : K.test(_.charAt(c - 1)) ? (E *= Y, M = _.slice(A, c - 1).match(X), M && A > 0 && (E *= Math.pow(u, M.length))) : (E *= J, A > 0 && (E *= Math.pow(u, c - A))), _.charAt(c) !== C.charAt(f) && (E *= $)), (E < p && h.charAt(c - 1) === P2.charAt(f + 1) || P2.charAt(f + 1) === P2.charAt(f) && h.charAt(c - 1) !== P2.charAt(f)) && (N2 = G(_, C, h, P2, c + 1, f + 2, O), N2 * p > E && (E = N2 * p)), E > S && (S = E), c = h.indexOf(L2, c + 1);
 149      return O[T2] = S, S;
 150    }
 151    function D(_) {
 152      return _.toLowerCase().replace(X, " ");
 153    }
 154    function W(_, C, h) {
 155      return _ = h && h.length > 0 ? `$_ + " " + h.join(" ")}` : _, G(_, C, D(_), D(C), 0, 0, {});
 156    }
 157  
 158    // node_modules/.store/@radix-ui/react-dialog@1.1.23-ytDSaPyJAw3b9aD4KkIiOA/node_modules/@radix-ui/react-dialog/dist/index.mjs
 159    var React24 = __toESM(require_react(), 1);
 160  
 161    // node_modules/.store/@radix-ui/primitive@1.1.7-U6Tg5_5zgTQvcXJNNg7HcQ/node_modules/@radix-ui/primitive/dist/index.mjs
 162    var __defProp2 = Object.defineProperty;
 163    var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
 164    var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement);
 165    function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
 166      return /* @__PURE__ */ __name(function handleEvent(event) {
 167        originalEventHandler?.(event);
 168        if (checkForDefaultPrevented === false || !event || !event.defaultPrevented) {
 169          return ourEventHandler?.(event);
 170        }
 171      }, "handleEvent");
 172    }
 173    __name(composeEventHandlers, "composeEventHandlers");
 174    function getOwnerWindow(element) {
 175      if (!canUseDOM) {
 176        throw new Error("Cannot access window outside of the DOM");
 177      }
 178      return element?.ownerDocument?.defaultView ?? window;
 179    }
 180    __name(getOwnerWindow, "getOwnerWindow");
 181    function getOwnerDocument(element) {
 182      if (!canUseDOM) {
 183        throw new Error("Cannot access document outside of the DOM");
 184      }
 185      return element?.ownerDocument ?? document;
 186    }
 187    __name(getOwnerDocument, "getOwnerDocument");
 188    function getActiveElement(node, activeDescendant = false) {
 189      const { activeElement } = getOwnerDocument(node);
 190      if (!activeElement?.nodeName) {
 191        return null;
 192      }
 193      if (isFrame(activeElement) && activeElement.contentDocument) {
 194        return getActiveElement(activeElement.contentDocument.body, activeDescendant);
 195      }
 196      if (activeDescendant) {
 197        const id = activeElement.getAttribute("aria-activedescendant");
 198        if (id) {
 199          const element = getOwnerDocument(activeElement).getElementById(id);
 200          if (element) {
 201            return element;
 202          }
 203        }
 204      }
 205      return activeElement;
 206    }
 207    __name(getActiveElement, "getActiveElement");
 208    function isFrame(element) {
 209      return element.tagName === "IFRAME";
 210    }
 211    __name(isFrame, "isFrame");
 212  
 213    // node_modules/.store/@radix-ui/react-compose-refs@1.1.5-Yxi_9Vcwu9BZ5W9uATcsBQ/node_modules/@radix-ui/react-compose-refs/dist/index.mjs
 214    var React = __toESM(require_react(), 1);
 215    var __defProp3 = Object.defineProperty;
 216    var __name2 = (target, value) => __defProp3(target, "name", { value, configurable: true });
 217    function setRef(ref, value) {
 218      if (typeof ref === "function") {
 219        return ref(value);
 220      } else if (ref !== null && ref !== void 0) {
 221        ref.current = value;
 222      }
 223    }
 224    __name2(setRef, "setRef");
 225    function composeRefs(...refs) {
 226      return (node) => {
 227        let hasCleanup = false;
 228        const cleanups = refs.map((ref) => {
 229          const cleanup = setRef(ref, node);
 230          if (!hasCleanup && typeof cleanup == "function") {
 231            hasCleanup = true;
 232          }
 233          return cleanup;
 234        });
 235        if (hasCleanup) {
 236          return () => {
 237            for (let i = 0; i < cleanups.length; i++) {
 238              const cleanup = cleanups[i];
 239              if (typeof cleanup == "function") {
 240                cleanup();
 241              } else {
 242                setRef(refs[i], null);
 243              }
 244            }
 245          };
 246        }
 247      };
 248    }
 249    __name2(composeRefs, "composeRefs");
 250    function useComposedRefs(...refs) {
 251      return React.useCallback(composeRefs(...refs), refs);
 252    }
 253    __name2(useComposedRefs, "useComposedRefs");
 254  
 255    // node_modules/.store/@radix-ui/react-context@1.2.2-j7-25QEapK1ImCGTa8GJpg/node_modules/@radix-ui/react-context/dist/index.mjs
 256    var React2 = __toESM(require_react(), 1);
 257    var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
 258    var __defProp4 = Object.defineProperty;
 259    var __name3 = (target, value) => __defProp4(target, "name", { value, configurable: true });
 260    // @__NO_SIDE_EFFECTS__
 261    function createContext2(rootComponentName, defaultContext) {
 262      const Context = React2.createContext(defaultContext);
 263      Context.displayName = rootComponentName + "Context";
 264      const Provider = /* @__PURE__ */ __name3((props) => {
 265        const { children, ...context2 } = props;
 266        const value = React2.useMemo(() => context2, Object.values(context2));
 267        return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Context.Provider, { value, children });
 268      }, "Provider");
 269      Provider.displayName = rootComponentName + "Provider";
 270      function useContext22(consumerName, options = {}) {
 271        const { optional = false } = options;
 272        const context2 = React2.useContext(Context);
 273        if (context2) return context2;
 274        if (defaultContext !== void 0) return defaultContext;
 275        if (optional) return void 0;
 276        throw new Error(`\`$consumerName}\` must be used within \`$rootComponentName}\``);
 277      }
 278      __name3(useContext22, "useContext");
 279      return [Provider, useContext22];
 280    }
 281    __name3(createContext2, "createContext");
 282    // @__NO_SIDE_EFFECTS__
 283    function createContextScope(scopeName, createContextScopeDeps = []) {
 284      let defaultContexts = [];
 285      function createContext32(rootComponentName, defaultContext) {
 286        const BaseContext = React2.createContext(defaultContext);
 287        BaseContext.displayName = rootComponentName + "Context";
 288        const index = defaultContexts.length;
 289        defaultContexts = [...defaultContexts, defaultContext];
 290        const Provider = /* @__PURE__ */ __name3((props) => {
 291          const { scope, children, ...context2 } = props;
 292          const Context = scope?.[scopeName]?.[index] || BaseContext;
 293          const value = React2.useMemo(() => context2, Object.values(context2));
 294          return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Context.Provider, { value, children });
 295        }, "Provider");
 296        Provider.displayName = rootComponentName + "Provider";
 297        function useContext22(consumerName, scope, options = {}) {
 298          const { optional = false } = options;
 299          const Context = scope?.[scopeName]?.[index] || BaseContext;
 300          const context2 = React2.useContext(Context);
 301          if (context2) return context2;
 302          if (defaultContext !== void 0) return defaultContext;
 303          if (optional) return void 0;
 304          throw new Error(`\`$consumerName}\` must be used within \`$rootComponentName}\``);
 305        }
 306        __name3(useContext22, "useContext");
 307        return [Provider, useContext22];
 308      }
 309      __name3(createContext32, "createContext");
 310      const createScope = /* @__PURE__ */ __name3(() => {
 311        const scopeContexts = defaultContexts.map((defaultContext) => {
 312          return React2.createContext(defaultContext);
 313        });
 314        return /* @__PURE__ */ __name3(function useScope(scope) {
 315          const contexts = scope?.[scopeName] || scopeContexts;
 316          return React2.useMemo(
 317            () => ({ [`__scope$scopeName}`]: { ...scope, [scopeName]: contexts } }),
 318            [scope, contexts]
 319          );
 320        }, "useScope");
 321      }, "createScope");
 322      createScope.scopeName = scopeName;
 323      return [createContext32, composeContextScopes(createScope, ...createContextScopeDeps)];
 324    }
 325    __name3(createContextScope, "createContextScope");
 326    function composeContextScopes(...scopes) {
 327      const baseScope = scopes[0];
 328      if (scopes.length === 1) return baseScope;
 329      const createScope = /* @__PURE__ */ __name3(() => {
 330        const scopeHooks = scopes.map((createScope2) => ({
 331          useScope: createScope2(),
 332          scopeName: createScope2.scopeName
 333        }));
 334        return /* @__PURE__ */ __name3(function useComposedScopes(overrideScopes) {
 335          const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {
 336            const scopeProps = useScope(overrideScopes);
 337            const currentScope = scopeProps[`__scope$scopeName}`];
 338            return { ...nextScopes2, ...currentScope };
 339          }, {});
 340          return React2.useMemo(() => ({ [`__scope$baseScope.scopeName}`]: nextScopes }), [nextScopes]);
 341        }, "useComposedScopes");
 342      }, "createScope");
 343      createScope.scopeName = baseScope.scopeName;
 344      return createScope;
 345    }
 346    __name3(composeContextScopes, "composeContextScopes");
 347  
 348    // node_modules/.store/@radix-ui/react-id@1.1.4-lJYQ8uCc9ZjR3dGsRybCAQ/node_modules/@radix-ui/react-id/dist/index.mjs
 349    var React4 = __toESM(require_react(), 1);
 350  
 351    // node_modules/.store/@radix-ui/react-use-layout-effect@1.1.4-xgr8ZdGzRbbpiAVfalj0KQ/node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs
 352    var React3 = __toESM(require_react(), 1);
 353    var useLayoutEffect2 = globalThis?.document ? React3.useLayoutEffect : () => {
 354    };
 355  
 356    // node_modules/.store/@radix-ui/react-id@1.1.4-lJYQ8uCc9ZjR3dGsRybCAQ/node_modules/@radix-ui/react-id/dist/index.mjs
 357    var __defProp5 = Object.defineProperty;
 358    var __name4 = (target, value) => __defProp5(target, "name", { value, configurable: true });
 359    var useReactId = React4[" useId ".trim().toString()] || (() => void 0);
 360    var count = 0;
 361    function useId(deterministicId) {
 362      const [id, setId] = React4.useState(useReactId());
 363      useLayoutEffect2(() => {
 364        if (!deterministicId) setId((reactId) => reactId ?? String(count++));
 365      }, [deterministicId]);
 366      return deterministicId || (id ? `radix-$id}` : "");
 367    }
 368    __name4(useId, "useId");
 369  
 370    // node_modules/.store/@radix-ui/react-use-controllable-state@1.2.6-E1gehUSActoGL_ABO78qWQ/node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
 371    var React6 = __toESM(require_react(), 1);
 372  
 373    // node_modules/.store/@radix-ui/primitive@1.1.7-U6Tg5_5zgTQvcXJNNg7HcQ/node_modules/@radix-ui/primitive/dist/internal/is-development.true.mjs
 374    var IS_DEVELOPMENT = true;
 375  
 376    // node_modules/.store/@radix-ui/react-use-controllable-state@1.2.6-E1gehUSActoGL_ABO78qWQ/node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
 377    var React22 = __toESM(require_react(), 1);
 378  
 379    // node_modules/.store/@radix-ui/react-use-effect-event@0.0.5-Yi5oSZAZmYwW6OVrdtieoA/node_modules/@radix-ui/react-use-effect-event/dist/index.mjs
 380    var React5 = __toESM(require_react(), 1);
 381    var __defProp6 = Object.defineProperty;
 382    var __name5 = (target, value) => __defProp6(target, "name", { value, configurable: true });
 383    var useReactEffectEvent = React5[" useEffectEvent ".trim().toString()];
 384    var useReactInsertionEffect = React5[" useInsertionEffect ".trim().toString()];
 385    function useEffectEvent(callback) {
 386      if (typeof useReactEffectEvent === "function") {
 387        return useReactEffectEvent(callback);
 388      }
 389      const ref = React5.useRef(() => {
 390        throw new Error("Cannot call an event handler while rendering.");
 391      });
 392      if (typeof useReactInsertionEffect === "function") {
 393        useReactInsertionEffect(() => {
 394          ref.current = callback;
 395        });
 396      } else {
 397        useLayoutEffect2(() => {
 398          ref.current = callback;
 399        });
 400      }
 401      return React5.useMemo(() => ((...args) => ref.current?.(...args)), []);
 402    }
 403    __name5(useEffectEvent, "useEffectEvent");
 404  
 405    // node_modules/.store/@radix-ui/react-use-controllable-state@1.2.6-E1gehUSActoGL_ABO78qWQ/node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs
 406    var __defProp7 = Object.defineProperty;
 407    var __name6 = (target, value) => __defProp7(target, "name", { value, configurable: true });
 408    var useInsertionEffect = React6[" useInsertionEffect ".trim().toString()] || useLayoutEffect2;
 409    function useControllableState({
 410      prop,
 411      defaultProp,
 412      onChange = /* @__PURE__ */ __name6(() => {
 413      }, "onChange"),
 414      caller
 415    }) {
 416      const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({
 417        defaultProp,
 418        onChange
 419      });
 420      const isControlled = prop !== void 0;
 421      const value = isControlled ? prop : uncontrolledProp;
 422      if (IS_DEVELOPMENT) {
 423        const isControlledRef = React6.useRef(prop !== void 0);
 424        React6.useEffect(() => {
 425          const wasControlled = isControlledRef.current;
 426          if (wasControlled !== isControlled) {
 427            const from = wasControlled ? "controlled" : "uncontrolled";
 428            const to = isControlled ? "controlled" : "uncontrolled";
 429            console.warn(
 430              `$caller} is changing from $from} to $to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
 431            );
 432          }
 433          isControlledRef.current = isControlled;
 434        }, [isControlled, caller]);
 435      }
 436      const setValue = React6.useCallback(
 437        (nextValue) => {
 438          if (isControlled) {
 439            const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue;
 440            if (value2 !== prop) {
 441              onChangeRef.current?.(value2);
 442            }
 443          } else {
 444            setUncontrolledProp(nextValue);
 445          }
 446        },
 447        [isControlled, prop, setUncontrolledProp, onChangeRef]
 448      );
 449      return [value, setValue];
 450    }
 451    __name6(useControllableState, "useControllableState");
 452    function useUncontrolledState({
 453      defaultProp,
 454      onChange
 455    }) {
 456      const [value, setValue] = React6.useState(defaultProp);
 457      const prevValueRef = React6.useRef(value);
 458      const onChangeRef = React6.useRef(onChange);
 459      useInsertionEffect(() => {
 460        onChangeRef.current = onChange;
 461      }, [onChange]);
 462      React6.useEffect(() => {
 463        if (prevValueRef.current !== value) {
 464          onChangeRef.current?.(value);
 465          prevValueRef.current = value;
 466        }
 467      }, [value, prevValueRef]);
 468      return [value, setValue, onChangeRef];
 469    }
 470    __name6(useUncontrolledState, "useUncontrolledState");
 471    function isFunction(value) {
 472      return typeof value === "function";
 473    }
 474    __name6(isFunction, "isFunction");
 475    var SYNC_STATE = /* @__PURE__ */ Symbol("RADIX:SYNC_STATE");
 476    function useControllableStateReducer(reducer2, userArgs, initialArg, init) {
 477      const { prop: controlledState, defaultProp, onChange: onChangeProp, caller } = userArgs;
 478      const isControlled = controlledState !== void 0;
 479      const onChange = useEffectEvent(onChangeProp);
 480      if (IS_DEVELOPMENT) {
 481        const isControlledRef = React22.useRef(controlledState !== void 0);
 482        React22.useEffect(() => {
 483          const wasControlled = isControlledRef.current;
 484          if (wasControlled !== isControlled) {
 485            const from = wasControlled ? "controlled" : "uncontrolled";
 486            const to = isControlled ? "controlled" : "uncontrolled";
 487            console.warn(
 488              `$caller} is changing from $from} to $to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.`
 489            );
 490          }
 491          isControlledRef.current = isControlled;
 492        }, [isControlled, caller]);
 493      }
 494      const args = [{ ...initialArg, state: defaultProp }];
 495      if (init) {
 496        args.push(init);
 497      }
 498      const [internalState, dispatch2] = React22.useReducer(
 499        (state2, action) => {
 500          if (action.type === SYNC_STATE) {
 501            return { ...state2, state: action.state };
 502          }
 503          const next = reducer2(state2, action);
 504          if (isControlled && !Object.is(next.state, state2.state)) {
 505            onChange(next.state);
 506          }
 507          return next;
 508        },
 509        ...args
 510      );
 511      const uncontrolledState = internalState.state;
 512      const prevValueRef = React22.useRef(uncontrolledState);
 513      React22.useEffect(() => {
 514        if (prevValueRef.current !== uncontrolledState) {
 515          prevValueRef.current = uncontrolledState;
 516          if (!isControlled) {
 517            onChange(uncontrolledState);
 518          }
 519        }
 520      }, [uncontrolledState, prevValueRef, isControlled]);
 521      const state = React22.useMemo(() => {
 522        const isControlled2 = controlledState !== void 0;
 523        if (isControlled2) {
 524          return { ...internalState, state: controlledState };
 525        }
 526        return internalState;
 527      }, [internalState, controlledState]);
 528      React22.useEffect(() => {
 529        if (isControlled && !Object.is(controlledState, internalState.state)) {
 530          dispatch2({ type: SYNC_STATE, state: controlledState });
 531        }
 532      }, [controlledState, internalState.state, isControlled]);
 533      return [state, dispatch2];
 534    }
 535    __name6(useControllableStateReducer, "useControllableStateReducer");
 536  
 537    // node_modules/.store/@radix-ui/react-dismissable-layer@1.1.19-TH-TBgk6yZ9haPsxC6i4zw/node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs
 538    var React10 = __toESM(require_react(), 1);
 539  
 540    // node_modules/.store/@radix-ui/react-primitive@2.1.10-zeSsoG72bCPsw9Cm9y8JEw/node_modules/@radix-ui/react-primitive/dist/index.mjs
 541    var React8 = __toESM(require_react(), 1);
 542    var ReactDOM = __toESM(require_react_dom(), 1);
 543  
 544    // node_modules/.store/@radix-ui/react-slot@1.3.3-gXjH-EJQB-ydh9AEtBi9Xg/node_modules/@radix-ui/react-slot/dist/index.mjs
 545    var React7 = __toESM(require_react(), 1);
 546    var __defProp8 = Object.defineProperty;
 547    var __name7 = (target, value) => __defProp8(target, "name", { value, configurable: true });
 548    // @__NO_SIDE_EFFECTS__
 549    function createSlot(ownerName) {
 550      const Slot2 = React7.forwardRef((props, forwardedRef) => {
 551        let { children, ...slotProps } = props;
 552        let slottableElement = null;
 553        let hasSlottable = false;
 554        const newChildren = [];
 555        if (isLazyComponent(children) && typeof use === "function") {
 556          children = use(children._payload);
 557        }
 558        React7.Children.forEach(children, (maybeSlottable) => {
 559          if (isSlottable(maybeSlottable)) {
 560            hasSlottable = true;
 561            const slottable = maybeSlottable;
 562            let child = "child" in slottable.props ? slottable.props.child : slottable.props.children;
 563            if (isLazyComponent(child) && typeof use === "function") {
 564              child = use(child._payload);
 565            }
 566            slottableElement = getSlottableElementFromSlottable(slottable, child);
 567            newChildren.push(slottableElement?.props?.children);
 568          } else {
 569            newChildren.push(maybeSlottable);
 570          }
 571        });
 572        if (slottableElement) {
 573          slottableElement = React7.cloneElement(slottableElement, void 0, newChildren);
 574        } else if (
 575          // A `Slottable` was found but it didn't resolve to a single element (e.g.
 576          // it wrapped multiple elements, text, or a render-prop `child` that
 577          // wasn't an element). Don't fall back to treating the `Slottable` wrapper
 578          // itself as the slot target — throw a descriptive error below instead.
 579          !hasSlottable && React7.Children.count(children) === 1 && React7.isValidElement(children)
 580        ) {
 581          slottableElement = children;
 582        }
 583        const slottableElementRef = slottableElement ? getElementRef(slottableElement) : void 0;
 584        const composedRef = useComposedRefs(forwardedRef, slottableElementRef);
 585        if (!slottableElement) {
 586          if (children || children === 0) {
 587            throw new Error(
 588              hasSlottable ? createSlottableError(ownerName) : createSlotError(ownerName)
 589            );
 590          }
 591          return children;
 592        }
 593        const mergedProps = mergeProps(slotProps, slottableElement.props ?? {});
 594        if (slottableElement.type !== React7.Fragment) {
 595          mergedProps.ref = forwardedRef ? composedRef : slottableElementRef;
 596        }
 597        return React7.cloneElement(slottableElement, mergedProps);
 598      });
 599      Slot2.displayName = `$ownerName}.Slot`;
 600      return Slot2;
 601    }
 602    __name7(createSlot, "createSlot");
 603    var SLOTTABLE_IDENTIFIER = /* @__PURE__ */ Symbol.for("radix.slottable");
 604    // @__NO_SIDE_EFFECTS__
 605    function createSlottable(ownerName) {
 606      const Slottable2 = /* @__PURE__ */ __name7((props) => "child" in props ? props.children(props.child) : props.children, "Slottable");
 607      Slottable2.displayName = `$ownerName}.Slottable`;
 608      Slottable2.__radixId = SLOTTABLE_IDENTIFIER;
 609      return Slottable2;
 610    }
 611    __name7(createSlottable, "createSlottable");
 612    var getSlottableElementFromSlottable = /* @__PURE__ */ __name7((slottable, child) => {
 613      if ("child" in slottable.props) {
 614        const child2 = slottable.props.child;
 615        if (!React7.isValidElement(child2)) return null;
 616        return React7.cloneElement(child2, void 0, slottable.props.children(child2.props.children));
 617      }
 618      return React7.isValidElement(child) ? child : null;
 619    }, "getSlottableElementFromSlottable");
 620    function mergeProps(slotProps, childProps) {
 621      const overrideProps = { ...childProps };
 622      for (const propName in childProps) {
 623        const slotPropValue = slotProps[propName];
 624        const childPropValue = childProps[propName];
 625        const isHandler = /^on[A-Z]/.test(propName);
 626        if (isHandler) {
 627          if (slotPropValue && childPropValue) {
 628            overrideProps[propName] = (...args) => {
 629              const result = childPropValue(...args);
 630              slotPropValue(...args);
 631              return result;
 632            };
 633          } else if (slotPropValue) {
 634            overrideProps[propName] = slotPropValue;
 635          }
 636        } else if (propName === "style") {
 637          overrideProps[propName] = { ...slotPropValue, ...childPropValue };
 638        } else if (propName === "className") {
 639          overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
 640        }
 641      }
 642      return { ...slotProps, ...overrideProps };
 643    }
 644    __name7(mergeProps, "mergeProps");
 645    function getElementRef(element) {
 646      let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
 647      let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
 648      if (mayWarn) {
 649        return element.ref;
 650      }
 651      getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
 652      mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
 653      if (mayWarn) {
 654        return element.props.ref;
 655      }
 656      return element.props.ref || element.ref;
 657    }
 658    __name7(getElementRef, "getElementRef");
 659    function isSlottable(child) {
 660      return React7.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER;
 661    }
 662    __name7(isSlottable, "isSlottable");
 663    var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
 664    function isLazyComponent(element) {
 665      return element != null && typeof element === "object" && "$$typeof" in element && element.$$typeof === REACT_LAZY_TYPE && "_payload" in element && isPromiseLike(element._payload);
 666    }
 667    __name7(isLazyComponent, "isLazyComponent");
 668    function isPromiseLike(value) {
 669      return typeof value === "object" && value !== null && "then" in value;
 670    }
 671    __name7(isPromiseLike, "isPromiseLike");
 672    var createSlotError = /* @__PURE__ */ __name7((ownerName) => {
 673      return `$ownerName} failed to slot onto its children. Expected a single React element child or \`Slottable\`.`;
 674    }, "createSlotError");
 675    var createSlottableError = /* @__PURE__ */ __name7((ownerName) => {
 676      return `$ownerName} failed to slot onto its \`Slottable\`. Expected \`Slottable\` to receive a single React element child.`;
 677    }, "createSlottableError");
 678    var use = React7[" use ".trim().toString()];
 679  
 680    // node_modules/.store/@radix-ui/react-primitive@2.1.10-zeSsoG72bCPsw9Cm9y8JEw/node_modules/@radix-ui/react-primitive/dist/index.mjs
 681    var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
 682    var __defProp9 = Object.defineProperty;
 683    var __name8 = (target, value) => __defProp9(target, "name", { value, configurable: true });
 684    var NODES = [
 685      "a",
 686      "button",
 687      "div",
 688      "form",
 689      "h2",
 690      "h3",
 691      "img",
 692      "input",
 693      "label",
 694      "li",
 695      "nav",
 696      "ol",
 697      "p",
 698      "select",
 699      "span",
 700      "svg",
 701      "ul"
 702    ];
 703    var Primitive = NODES.reduce((primitive, node) => {
 704      const Slot2 = createSlot(`Primitive.$node}`);
 705      const Node2 = React8.forwardRef((props, forwardedRef) => {
 706        const { asChild, ...primitiveProps } = props;
 707        const Comp = asChild ? Slot2 : node;
 708        if (typeof window !== "undefined") {
 709          window[/* @__PURE__ */ Symbol.for("radix-ui")] = true;
 710        }
 711        return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Comp, { ...primitiveProps, ref: forwardedRef });
 712      });
 713      Node2.displayName = `Primitive.$node}`;
 714      return { ...primitive, [node]: Node2 };
 715    }, {});
 716    function dispatchDiscreteCustomEvent(target, event) {
 717      if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));
 718    }
 719    __name8(dispatchDiscreteCustomEvent, "dispatchDiscreteCustomEvent");
 720  
 721    // node_modules/.store/@radix-ui/react-use-callback-ref@1.1.4-e0xqDXwla-RxBDlP4otgfA/node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs
 722    var React9 = __toESM(require_react(), 1);
 723    var __defProp10 = Object.defineProperty;
 724    var __name9 = (target, value) => __defProp10(target, "name", { value, configurable: true });
 725    function useCallbackRef(callback) {
 726      const callbackRef = React9.useRef(callback);
 727      React9.useEffect(() => {
 728        callbackRef.current = callback;
 729      });
 730      return React9.useMemo(() => ((...args) => callbackRef.current?.(...args)), []);
 731    }
 732    __name9(useCallbackRef, "useCallbackRef");
 733  
 734    // node_modules/.store/@radix-ui/react-dismissable-layer@1.1.19-TH-TBgk6yZ9haPsxC6i4zw/node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs
 735    var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
 736    var __defProp11 = Object.defineProperty;
 737    var __name10 = (target, value) => __defProp11(target, "name", { value, configurable: true });
 738    var CONTEXT_UPDATE = "dismissableLayer.update";
 739    var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
 740    var FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
 741    var originalBodyPointerEvents;
 742    var DismissableLayerContext = React10.createContext({
 743      layers: /* @__PURE__ */ new Set(),
 744      layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
 745      branches: /* @__PURE__ */ new Set(),
 746      // Outside elements that belong to a layer's own dismiss affordance (eg, a
 747      // dialog overlay). Pressing them should dismiss the layer regardless of
 748      // whether or not they stop propagation.
 749      //
 750      // See https://github.com/radix-ui/primitives/issues/3346
 751      dismissableSurfaces: /* @__PURE__ */ new Set()
 752    });
 753    var DismissableLayer = /* @__PURE__ */ React10.forwardRef(
 754      // blank line to reduce diff noise
 755      /* @__PURE__ */ __name10(function DismissableLayer2(props, forwardedRef) {
 756        const {
 757          disableOutsidePointerEvents = false,
 758          deferPointerDownOutside = false,
 759          onEscapeKeyDown,
 760          onPointerDownOutside,
 761          onFocusOutside,
 762          onInteractOutside,
 763          onDismiss,
 764          ...layerProps
 765        } = props;
 766        const context2 = React10.useContext(DismissableLayerContext);
 767        const [node, setNode] = React10.useState(null);
 768        const ownerDocument = node?.ownerDocument ?? globalThis?.document;
 769        const [, force] = React10.useState({});
 770        const composedRefs = useComposedRefs(forwardedRef, setNode);
 771        const layers = Array.from(context2.layers);
 772        const [highestLayerWithOutsidePointerEventsDisabled] = [
 773          ...context2.layersWithOutsidePointerEventsDisabled
 774        ].slice(-1);
 775        const highestLayerWithOutsidePointerEventsDisabledIndex = highestLayerWithOutsidePointerEventsDisabled ? layers.indexOf(highestLayerWithOutsidePointerEventsDisabled) : -1;
 776        const index = node ? layers.indexOf(node) : -1;
 777        const isBodyPointerEventsDisabled = context2.layersWithOutsidePointerEventsDisabled.size > 0;
 778        const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;
 779        const isDeferredPointerDownOutsideRef = React10.useRef(false);
 780        const pointerDownOutside = usePointerDownOutside(
 781          (event) => {
 782            onPointerDownOutside?.(event);
 783            onInteractOutside?.(event);
 784            if (!event.defaultPrevented) onDismiss?.();
 785          },
 786          {
 787            ownerDocument,
 788            deferPointerDownOutside,
 789            isDeferredPointerDownOutsideRef,
 790            dismissableSurfaces: context2.dismissableSurfaces,
 791            shouldHandlePointerDownOutside: React10.useCallback(
 792              (target) => {
 793                if (!(target instanceof Node)) {
 794                  return false;
 795                }
 796                const isPointerDownOnBranch = [...context2.branches].some(
 797                  (branch) => branch.contains(target)
 798                );
 799                return isPointerEventsEnabled && !isPointerDownOnBranch;
 800              },
 801              [context2.branches, isPointerEventsEnabled]
 802            )
 803          }
 804        );
 805        const focusOutside = useFocusOutside((event) => {
 806          if (deferPointerDownOutside && isDeferredPointerDownOutsideRef.current) {
 807            return;
 808          }
 809          const target = event.target;
 810          const isFocusInBranch = [...context2.branches].some((branch) => branch.contains(target));
 811          if (isFocusInBranch) return;
 812          onFocusOutside?.(event);
 813          onInteractOutside?.(event);
 814          if (!event.defaultPrevented) onDismiss?.();
 815        }, ownerDocument);
 816        const isHighestLayer = node ? index === layers.length - 1 : false;
 817        const handleKeyDown = useCallbackRef((event) => {
 818          if (event.key !== "Escape") {
 819            return;
 820          }
 821          onEscapeKeyDown?.(event);
 822          if (!event.defaultPrevented && onDismiss) {
 823            event.preventDefault();
 824            onDismiss();
 825          }
 826        });
 827        React10.useEffect(() => {
 828          if (!isHighestLayer) {
 829            return;
 830          }
 831          ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true });
 832          return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true });
 833        }, [ownerDocument, isHighestLayer, handleKeyDown]);
 834        React10.useEffect(() => {
 835          if (!node) return;
 836          if (disableOutsidePointerEvents) {
 837            if (context2.layersWithOutsidePointerEventsDisabled.size === 0) {
 838              originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;
 839              ownerDocument.body.style.pointerEvents = "none";
 840            }
 841            context2.layersWithOutsidePointerEventsDisabled.add(node);
 842          }
 843          context2.layers.add(node);
 844          dispatchUpdate();
 845          return () => {
 846            if (disableOutsidePointerEvents) {
 847              context2.layersWithOutsidePointerEventsDisabled.delete(node);
 848              if (context2.layersWithOutsidePointerEventsDisabled.size === 0) {
 849                ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;
 850              }
 851            }
 852          };
 853        }, [node, ownerDocument, disableOutsidePointerEvents, context2]);
 854        React10.useEffect(() => {
 855          return () => {
 856            if (!node) return;
 857            context2.layers.delete(node);
 858            context2.layersWithOutsidePointerEventsDisabled.delete(node);
 859            dispatchUpdate();
 860          };
 861        }, [node, context2]);
 862        React10.useEffect(() => {
 863          const handleUpdate = /* @__PURE__ */ __name10(() => force({}), "handleUpdate");
 864          document.addEventListener(CONTEXT_UPDATE, handleUpdate);
 865          return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);
 866        }, []);
 867        return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
 868          Primitive.div,
 869          {
 870            ...layerProps,
 871            ref: composedRefs,
 872            style: {
 873              pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0,
 874              ...props.style
 875            },
 876            onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture),
 877            onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture),
 878            onPointerDownCapture: composeEventHandlers(
 879              props.onPointerDownCapture,
 880              pointerDownOutside.onPointerDownCapture
 881            )
 882          }
 883        );
 884      }, "DismissableLayer")
 885    );
 886    function useDismissableLayerSurface() {
 887      const context2 = React10.useContext(DismissableLayerContext);
 888      const [node, setNode] = React10.useState(null);
 889      React10.useEffect(() => {
 890        if (!node) {
 891          return;
 892        }
 893        context2.dismissableSurfaces.add(node);
 894        return () => {
 895          context2.dismissableSurfaces.delete(node);
 896        };
 897      }, [node, context2.dismissableSurfaces]);
 898      return setNode;
 899    }
 900    __name10(useDismissableLayerSurface, "useDismissableLayerSurface");
 901    var IS_TRUE = /* @__PURE__ */ __name10(() => true, "IS_TRUE");
 902    function usePointerDownOutside(onPointerDownOutside, args) {
 903      const {
 904        ownerDocument = globalThis?.document,
 905        deferPointerDownOutside = false,
 906        isDeferredPointerDownOutsideRef,
 907        dismissableSurfaces,
 908        shouldHandlePointerDownOutside = IS_TRUE
 909      } = args;
 910      const handlePointerDownOutside = useCallbackRef(onPointerDownOutside);
 911      const isPointerInsideReactTreeRef = React10.useRef(false);
 912      const isPointerDownOutsideRef = React10.useRef(false);
 913      const interceptedOutsideInteractionEventsRef = React10.useRef(/* @__PURE__ */ new Map());
 914      const handleClickRef = React10.useRef(() => {
 915      });
 916      React10.useEffect(() => {
 917        function resetOutsideInteraction() {
 918          isPointerDownOutsideRef.current = false;
 919          isDeferredPointerDownOutsideRef.current = false;
 920          interceptedOutsideInteractionEventsRef.current.clear();
 921        }
 922        __name10(resetOutsideInteraction, "resetOutsideInteraction");
 923        function isOutsideInteractionIntercepted() {
 924          return Array.from(interceptedOutsideInteractionEventsRef.current.values()).some(Boolean);
 925        }
 926        __name10(isOutsideInteractionIntercepted, "isOutsideInteractionIntercepted");
 927        function handleInteractionCapture(event) {
 928          if (!isPointerDownOutsideRef.current) {
 929            return;
 930          }
 931          const target = event.target;
 932          const isDismissableSurface = target instanceof Node && [...dismissableSurfaces].some((surface) => surface.contains(target));
 933          if (!isDismissableSurface) {
 934            interceptedOutsideInteractionEventsRef.current.set(event.type, true);
 935          }
 936          if (event.type === "click") {
 937            window.setTimeout(() => {
 938              if (isPointerDownOutsideRef.current) {
 939                handleClickRef.current();
 940              }
 941            }, 0);
 942          }
 943        }
 944        __name10(handleInteractionCapture, "handleInteractionCapture");
 945        function handleInteractionBubble(event) {
 946          if (isPointerDownOutsideRef.current) {
 947            interceptedOutsideInteractionEventsRef.current.set(event.type, false);
 948          }
 949        }
 950        __name10(handleInteractionBubble, "handleInteractionBubble");
 951        const handlePointerDown = /* @__PURE__ */ __name10((event) => {
 952          if (event.target && !isPointerInsideReactTreeRef.current) {
 953            let handleAndDispatchPointerDownOutsideEvent2 = function() {
 954              ownerDocument.removeEventListener("click", handleClickRef.current);
 955              const wasOutsideInteractionIntercepted = isOutsideInteractionIntercepted();
 956              resetOutsideInteraction();
 957              if (!wasOutsideInteractionIntercepted) {
 958                handleAndDispatchCustomEvent(
 959                  POINTER_DOWN_OUTSIDE,
 960                  handlePointerDownOutside,
 961                  eventDetail,
 962                  { discrete: true }
 963                );
 964              }
 965            };
 966            var handleAndDispatchPointerDownOutsideEvent = handleAndDispatchPointerDownOutsideEvent2;
 967            __name10(handleAndDispatchPointerDownOutsideEvent2, "handleAndDispatchPointerDownOutsideEvent");
 968            if (!shouldHandlePointerDownOutside(event.target)) {
 969              ownerDocument.removeEventListener("click", handleClickRef.current);
 970              resetOutsideInteraction();
 971              isPointerInsideReactTreeRef.current = false;
 972              return;
 973            }
 974            const eventDetail = { originalEvent: event };
 975            isPointerDownOutsideRef.current = true;
 976            isDeferredPointerDownOutsideRef.current = deferPointerDownOutside && event.button === 0;
 977            interceptedOutsideInteractionEventsRef.current.clear();
 978            if (!deferPointerDownOutside || event.button !== 0) {
 979              handleAndDispatchPointerDownOutsideEvent2();
 980            } else {
 981              ownerDocument.removeEventListener("click", handleClickRef.current);
 982              handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2;
 983              ownerDocument.addEventListener("click", handleClickRef.current, { once: true });
 984            }
 985          } else {
 986            ownerDocument.removeEventListener("click", handleClickRef.current);
 987            resetOutsideInteraction();
 988          }
 989          isPointerInsideReactTreeRef.current = false;
 990        }, "handlePointerDown");
 991        const outsideInteractionEvents = [
 992          "pointerup",
 993          "mousedown",
 994          "mouseup",
 995          "touchstart",
 996          "touchend",
 997          "click"
 998        ];
 999        for (const eventName of outsideInteractionEvents) {
1000          ownerDocument.addEventListener(eventName, handleInteractionCapture, true);
1001          ownerDocument.addEventListener(eventName, handleInteractionBubble);
1002        }
1003        const timerId = window.setTimeout(() => {
1004          ownerDocument.addEventListener("pointerdown", handlePointerDown);
1005        }, 0);
1006        return () => {
1007          window.clearTimeout(timerId);
1008          ownerDocument.removeEventListener("pointerdown", handlePointerDown);
1009          ownerDocument.removeEventListener("click", handleClickRef.current);
1010          for (const eventName of outsideInteractionEvents) {
1011            ownerDocument.removeEventListener(eventName, handleInteractionCapture, true);
1012            ownerDocument.removeEventListener(eventName, handleInteractionBubble);
1013          }
1014        };
1015      }, [
1016        ownerDocument,
1017        handlePointerDownOutside,
1018        deferPointerDownOutside,
1019        isDeferredPointerDownOutsideRef,
1020        dismissableSurfaces,
1021        shouldHandlePointerDownOutside
1022      ]);
1023      return {
1024        // ensures we check React component tree (not just DOM tree)
1025        onPointerDownCapture: /* @__PURE__ */ __name10(() => isPointerInsideReactTreeRef.current = true, "onPointerDownCapture")
1026      };
1027    }
1028    __name10(usePointerDownOutside, "usePointerDownOutside");
1029    function useFocusOutside(onFocusOutside, ownerDocument = globalThis?.document) {
1030      const handleFocusOutside = useCallbackRef(onFocusOutside);
1031      const isFocusInsideReactTreeRef = React10.useRef(false);
1032      React10.useEffect(() => {
1033        const handleFocus = /* @__PURE__ */ __name10((event) => {
1034          if (event.target && !isFocusInsideReactTreeRef.current) {
1035            const eventDetail = { originalEvent: event };
1036            handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {
1037              discrete: false
1038            });
1039          }
1040        }, "handleFocus");
1041        ownerDocument.addEventListener("focusin", handleFocus);
1042        return () => ownerDocument.removeEventListener("focusin", handleFocus);
1043      }, [ownerDocument, handleFocusOutside]);
1044      return {
1045        onFocusCapture: /* @__PURE__ */ __name10(() => isFocusInsideReactTreeRef.current = true, "onFocusCapture"),
1046        onBlurCapture: /* @__PURE__ */ __name10(() => isFocusInsideReactTreeRef.current = false, "onBlurCapture")
1047      };
1048    }
1049    __name10(useFocusOutside, "useFocusOutside");
1050    function dispatchUpdate() {
1051      const event = new CustomEvent(CONTEXT_UPDATE);
1052      document.dispatchEvent(event);
1053    }
1054    __name10(dispatchUpdate, "dispatchUpdate");
1055    function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) {
1056      const target = detail.originalEvent.target;
1057      const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });
1058      if (handler) target.addEventListener(name, handler, { once: true });
1059      if (discrete) {
1060        dispatchDiscreteCustomEvent(target, event);
1061      } else {
1062        target.dispatchEvent(event);
1063      }
1064    }
1065    __name10(handleAndDispatchCustomEvent, "handleAndDispatchCustomEvent");
1066  
1067    // node_modules/.store/@radix-ui/react-focus-scope@1.1.16-YPQp7Tv7wxmVoy-hNvj09g/node_modules/@radix-ui/react-focus-scope/dist/index.mjs
1068    var React11 = __toESM(require_react(), 1);
1069    var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
1070    var __defProp12 = Object.defineProperty;
1071    var __name11 = (target, value) => __defProp12(target, "name", { value, configurable: true });
1072    var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount";
1073    var AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount";
1074    var EVENT_OPTIONS = { bubbles: false, cancelable: true };
1075    var FocusScope = /* @__PURE__ */ React11.forwardRef(
1076      /* @__PURE__ */ __name11(function FocusScope2(props, forwardedRef) {
1077        const {
1078          loop = false,
1079          trapped = false,
1080          onMountAutoFocus: onMountAutoFocusProp,
1081          onUnmountAutoFocus: onUnmountAutoFocusProp,
1082          ...scopeProps
1083        } = props;
1084        const [container, setContainer] = React11.useState(null);
1085        const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);
1086        const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);
1087        const lastFocusedElementRef = React11.useRef(null);
1088        const composedRefs = useComposedRefs(forwardedRef, setContainer);
1089        const focusScope = React11.useRef({
1090          paused: false,
1091          pause() {
1092            this.paused = true;
1093          },
1094          resume() {
1095            this.paused = false;
1096          }
1097        }).current;
1098        React11.useEffect(() => {
1099          if (trapped) {
1100            let handleFocusIn2 = function(event) {
1101              if (focusScope.paused || !container) return;
1102              const target = event.target;
1103              if (container.contains(target)) {
1104                lastFocusedElementRef.current = target;
1105              } else {
1106                focus(lastFocusedElementRef.current, { select: true });
1107              }
1108            }, handleFocusOut2 = function(event) {
1109              if (focusScope.paused || !container) return;
1110              const relatedTarget = event.relatedTarget;
1111              if (relatedTarget === null) return;
1112              if (!container.contains(relatedTarget)) {
1113                focus(lastFocusedElementRef.current, { select: true });
1114              }
1115            }, handleMutations2 = function(mutations) {
1116              const focusedElement = document.activeElement;
1117              if (focusedElement !== document.body) return;
1118              for (const mutation of mutations) {
1119                if (mutation.removedNodes.length > 0) focus(container);
1120              }
1121            };
1122            var handleFocusIn = handleFocusIn2, handleFocusOut = handleFocusOut2, handleMutations = handleMutations2;
1123            __name11(handleFocusIn2, "handleFocusIn");
1124            __name11(handleFocusOut2, "handleFocusOut");
1125            __name11(handleMutations2, "handleMutations");
1126            document.addEventListener("focusin", handleFocusIn2);
1127            document.addEventListener("focusout", handleFocusOut2);
1128            const mutationObserver = new MutationObserver(handleMutations2);
1129            if (container) mutationObserver.observe(container, { childList: true, subtree: true });
1130            return () => {
1131              document.removeEventListener("focusin", handleFocusIn2);
1132              document.removeEventListener("focusout", handleFocusOut2);
1133              mutationObserver.disconnect();
1134            };
1135          }
1136        }, [trapped, container, focusScope.paused]);
1137        React11.useEffect(() => {
1138          if (container) {
1139            focusScopesStack.add(focusScope);
1140            const previouslyFocusedElement = document.activeElement;
1141            const hasFocusedCandidate = container.contains(previouslyFocusedElement);
1142            if (!hasFocusedCandidate) {
1143              const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);
1144              container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
1145              container.dispatchEvent(mountEvent);
1146              if (!mountEvent.defaultPrevented) {
1147                focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });
1148                if (document.activeElement === previouslyFocusedElement) {
1149                  focus(container);
1150                }
1151              }
1152            }
1153            return () => {
1154              container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);
1155              setTimeout(() => {
1156                const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);
1157                container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
1158                container.dispatchEvent(unmountEvent);
1159                if (!unmountEvent.defaultPrevented) {
1160                  focus(previouslyFocusedElement ?? document.body, { select: true });
1161                }
1162                container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);
1163                focusScopesStack.remove(focusScope);
1164              }, 0);
1165            };
1166          }
1167        }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);
1168        const handleKeyDown = React11.useCallback(
1169          (event) => {
1170            if (!loop && !trapped) return;
1171            if (focusScope.paused) return;
1172            const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey;
1173            const focusedElement = document.activeElement;
1174            if (isTabKey && focusedElement) {
1175              const container2 = event.currentTarget;
1176              const [first, last] = getTabbableEdges(container2);
1177              const hasTabbableElementsInside = first && last;
1178              if (!hasTabbableElementsInside) {
1179                if (focusedElement === container2) event.preventDefault();
1180              } else {
1181                if (!event.shiftKey && focusedElement === last) {
1182                  event.preventDefault();
1183                  if (loop) focus(first, { select: true });
1184                } else if (event.shiftKey && focusedElement === first) {
1185                  event.preventDefault();
1186                  if (loop) focus(last, { select: true });
1187                }
1188              }
1189            }
1190          },
1191          [loop, trapped, focusScope.paused]
1192        );
1193        return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown });
1194      }, "FocusScope")
1195    );
1196    function focusFirst(candidates, { select = false } = {}) {
1197      const previouslyFocusedElement = document.activeElement;
1198      for (const candidate of candidates) {
1199        focus(candidate, { select });
1200        if (document.activeElement !== previouslyFocusedElement) return;
1201      }
1202    }
1203    __name11(focusFirst, "focusFirst");
1204    function getTabbableEdges(container) {
1205      const candidates = getTabbableCandidates(container);
1206      const first = findVisible(candidates, container);
1207      const last = findVisible(candidates.reverse(), container);
1208      return [first, last];
1209    }
1210    __name11(getTabbableEdges, "getTabbableEdges");
1211    function getTabbableCandidates(container) {
1212      const nodes = [];
1213      const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
1214        acceptNode: /* @__PURE__ */ __name11((node) => {
1215          const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
1216          if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;
1217          return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
1218        }, "acceptNode")
1219      });
1220      while (walker.nextNode()) nodes.push(walker.currentNode);
1221      return nodes;
1222    }
1223    __name11(getTabbableCandidates, "getTabbableCandidates");
1224    function findVisible(elements, container) {
1225      const canUseCheckVisibility = typeof container.checkVisibility === "function" && container.checkVisibility({ checkVisibilityCSS: true });
1226      for (const element of elements) {
1227        const hidden = canUseCheckVisibility ? !element.checkVisibility({ checkVisibilityCSS: true }) : isHidden(element, { upTo: container });
1228        if (!hidden) {
1229          return element;
1230        }
1231      }
1232    }
1233    __name11(findVisible, "findVisible");
1234    function isHidden(node, { upTo }) {
1235      if (getComputedStyle(node).visibility === "hidden") return true;
1236      while (node) {
1237        if (upTo !== void 0 && node === upTo) return false;
1238        if (getComputedStyle(node).display === "none") return true;
1239        node = node.parentElement;
1240      }
1241      return false;
1242    }
1243    __name11(isHidden, "isHidden");
1244    function isSelectableInput(element) {
1245      return element instanceof HTMLInputElement && "select" in element;
1246    }
1247    __name11(isSelectableInput, "isSelectableInput");
1248    function focus(element, { select = false } = {}) {
1249      if (element && element.focus) {
1250        const previouslyFocusedElement = document.activeElement;
1251        element.focus({ preventScroll: true });
1252        if (element !== previouslyFocusedElement && isSelectableInput(element) && select)
1253          element.select();
1254      }
1255    }
1256    __name11(focus, "focus");
1257    var focusScopesStack = createFocusScopesStack();
1258    function createFocusScopesStack() {
1259      let stack = [];
1260      return {
1261        add(focusScope) {
1262          const activeFocusScope = stack[0];
1263          if (focusScope !== activeFocusScope) {
1264            activeFocusScope?.pause();
1265          }
1266          stack = arrayRemove(stack, focusScope);
1267          stack.unshift(focusScope);
1268        },
1269        remove(focusScope) {
1270          stack = arrayRemove(stack, focusScope);
1271          stack[0]?.resume();
1272        }
1273      };
1274    }
1275    __name11(createFocusScopesStack, "createFocusScopesStack");
1276    function arrayRemove(array, item) {
1277      const updatedArray = [...array];
1278      const index = updatedArray.indexOf(item);
1279      if (index !== -1) {
1280        updatedArray.splice(index, 1);
1281      }
1282      return updatedArray;
1283    }
1284    __name11(arrayRemove, "arrayRemove");
1285    function removeLinks(items) {
1286      return items.filter((item) => item.tagName !== "A");
1287    }
1288    __name11(removeLinks, "removeLinks");
1289  
1290    // node_modules/.store/@radix-ui/react-portal@1.1.17-c107g9qJPrY_oXR9dwaImg/node_modules/@radix-ui/react-portal/dist/index.mjs
1291    var React12 = __toESM(require_react(), 1);
1292    var ReactDOM2 = __toESM(require_react_dom(), 1);
1293    var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
1294    var __defProp13 = Object.defineProperty;
1295    var __name12 = (target, value) => __defProp13(target, "name", { value, configurable: true });
1296    var Portal = /* @__PURE__ */ React12.forwardRef(
1297      /* @__PURE__ */ __name12(function Portal2(props, forwardedRef) {
1298        const { container: containerProp, ...portalProps } = props;
1299        const [mounted, setMounted] = React12.useState(false);
1300        useLayoutEffect2(() => setMounted(true), []);
1301        const container = containerProp || mounted && globalThis?.document?.body;
1302        return container ? ReactDOM2.createPortal(/* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null;
1303      }, "Portal")
1304    );
1305  
1306    // node_modules/.store/@radix-ui/react-presence@1.1.10-HIhysypzaG_K5sVxhG5Wig/node_modules/@radix-ui/react-presence/dist/index.mjs
1307    var React23 = __toESM(require_react(), 1);
1308    var React13 = __toESM(require_react(), 1);
1309    var __defProp14 = Object.defineProperty;
1310    var __name13 = (target, value) => __defProp14(target, "name", { value, configurable: true });
1311    function useStateMachine(initialState, machine) {
1312      return React13.useReducer((state, event) => {
1313        const nextState = machine[state][event];
1314        return nextState ?? state;
1315      }, initialState);
1316    }
1317    __name13(useStateMachine, "useStateMachine");
1318    var Presence = /* @__PURE__ */ __name13((props) => {
1319      const { present, children } = props;
1320      const presence = usePresence(present);
1321      const child = typeof children === "function" ? children({ present: presence.isPresent }) : React23.Children.only(children);
1322      const ref = useStableComposedRefs(presence.ref, getElementRef2(child));
1323      const forceMount = typeof children === "function";
1324      return forceMount || presence.isPresent ? React23.cloneElement(child, { ref }) : null;
1325    }, "Presence");
1326    function usePresence(present) {
1327      const [node, setNode] = React23.useState();
1328      const stylesRef = React23.useRef(null);
1329      const prevPresentRef = React23.useRef(present);
1330      const prevAnimationNameRef = React23.useRef("none");
1331      const mountAnimationNameRef = React23.useRef(void 0);
1332      const initialState = present ? "mounted" : "unmounted";
1333      const [state, send] = useStateMachine(initialState, {
1334        mounted: {
1335          UNMOUNT: "unmounted",
1336          ANIMATION_OUT: "unmountSuspended"
1337        },
1338        unmountSuspended: {
1339          MOUNT: "mounted",
1340          ANIMATION_END: "unmounted"
1341        },
1342        unmounted: {
1343          MOUNT: "mounted"
1344        }
1345      });
1346      React23.useEffect(() => {
1347        if (state === "mounted") {
1348          prevAnimationNameRef.current = mountAnimationNameRef.current ?? getAnimationName(stylesRef.current);
1349          mountAnimationNameRef.current = void 0;
1350        } else {
1351          prevAnimationNameRef.current = "none";
1352        }
1353      }, [state]);
1354      useLayoutEffect2(() => {
1355        const styles = stylesRef.current;
1356        const wasPresent = prevPresentRef.current;
1357        const hasPresentChanged = wasPresent !== present;
1358        if (hasPresentChanged) {
1359          const prevAnimationName = prevAnimationNameRef.current;
1360          const currentAnimationName = getAnimationName(styles);
1361          if (present) {
1362            mountAnimationNameRef.current = currentAnimationName;
1363            send("MOUNT");
1364          } else if (currentAnimationName === "none" || styles?.display === "none") {
1365            send("UNMOUNT");
1366          } else {
1367            const isAnimating = prevAnimationName !== currentAnimationName;
1368            if (wasPresent && isAnimating) {
1369              send("ANIMATION_OUT");
1370            } else {
1371              send("UNMOUNT");
1372            }
1373          }
1374          prevPresentRef.current = present;
1375        }
1376      }, [present, send]);
1377      useLayoutEffect2(() => {
1378        if (node) {
1379          let timeoutId;
1380          const ownerWindow = node.ownerDocument.defaultView ?? window;
1381          const handleAnimationEnd = /* @__PURE__ */ __name13((event) => {
1382            const currentAnimationName = getAnimationName(stylesRef.current);
1383            const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName));
1384            if (event.target === node && isCurrentAnimation) {
1385              send("ANIMATION_END");
1386              if (!prevPresentRef.current) {
1387                const currentFillMode = node.style.animationFillMode;
1388                node.style.animationFillMode = "forwards";
1389                timeoutId = ownerWindow.setTimeout(() => {
1390                  if (node.style.animationFillMode === "forwards") {
1391                    node.style.animationFillMode = currentFillMode;
1392                  }
1393                });
1394              }
1395            }
1396          }, "handleAnimationEnd");
1397          const handleAnimationStart = /* @__PURE__ */ __name13((event) => {
1398            if (event.target === node) {
1399              prevAnimationNameRef.current = getAnimationName(stylesRef.current);
1400            }
1401          }, "handleAnimationStart");
1402          node.addEventListener("animationstart", handleAnimationStart);
1403          node.addEventListener("animationcancel", handleAnimationEnd);
1404          node.addEventListener("animationend", handleAnimationEnd);
1405          return () => {
1406            ownerWindow.clearTimeout(timeoutId);
1407            node.removeEventListener("animationstart", handleAnimationStart);
1408            node.removeEventListener("animationcancel", handleAnimationEnd);
1409            node.removeEventListener("animationend", handleAnimationEnd);
1410          };
1411        } else {
1412          send("ANIMATION_END");
1413        }
1414      }, [node, send]);
1415      return {
1416        isPresent: ["mounted", "unmountSuspended"].includes(state),
1417        ref: React23.useCallback((node2) => {
1418          if (node2) {
1419            const styles = getComputedStyle(node2);
1420            stylesRef.current = styles;
1421            mountAnimationNameRef.current = getAnimationName(styles);
1422          } else {
1423            stylesRef.current = null;
1424          }
1425          setNode(node2);
1426        }, [])
1427      };
1428    }
1429    __name13(usePresence, "usePresence");
1430    function setRef2(ref, value) {
1431      if (typeof ref === "function") {
1432        return ref(value);
1433      } else if (ref !== null && ref !== void 0) {
1434        ref.current = value;
1435      }
1436    }
1437    __name13(setRef2, "setRef");
1438    function useStableComposedRefs(...refs) {
1439      const refsRef = React23.useRef(refs);
1440      refsRef.current = refs;
1441      return React23.useCallback((node) => {
1442        const currentRefs = refsRef.current;
1443        let hasCleanup = false;
1444        const cleanups = currentRefs.map((ref) => {
1445          const cleanup = setRef2(ref, node);
1446          if (!hasCleanup && typeof cleanup === "function") {
1447            hasCleanup = true;
1448          }
1449          return cleanup;
1450        });
1451        if (hasCleanup) {
1452          return () => {
1453            for (let i = 0; i < cleanups.length; i++) {
1454              const cleanup = cleanups[i];
1455              if (typeof cleanup === "function") {
1456                cleanup();
1457              } else {
1458                setRef2(currentRefs[i], null);
1459              }
1460            }
1461          };
1462        }
1463      }, []);
1464    }
1465    __name13(useStableComposedRefs, "useStableComposedRefs");
1466    function getAnimationName(styles) {
1467      return styles?.animationName || "none";
1468    }
1469    __name13(getAnimationName, "getAnimationName");
1470    function getElementRef2(element) {
1471      let getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
1472      let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
1473      if (mayWarn) {
1474        return element.ref;
1475      }
1476      getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
1477      mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
1478      if (mayWarn) {
1479        return element.props.ref;
1480      }
1481      return element.props.ref || element.ref;
1482    }
1483    __name13(getElementRef2, "getElementRef");
1484  
1485    // node_modules/.store/@radix-ui/react-focus-guards@1.1.6-J8NRBkK6-zVq-z3xjKlU6Q/node_modules/@radix-ui/react-focus-guards/dist/index.mjs
1486    var React14 = __toESM(require_react(), 1);
1487    var __defProp15 = Object.defineProperty;
1488    var __name14 = (target, value) => __defProp15(target, "name", { value, configurable: true });
1489    var count2 = 0;
1490    var guards = null;
1491    function FocusGuards(props) {
1492      useFocusGuards();
1493      return props.children;
1494    }
1495    __name14(FocusGuards, "FocusGuards");
1496    function useFocusGuards() {
1497      React14.useEffect(() => {
1498        if (!guards) {
1499          guards = { start: createFocusGuard(), end: createFocusGuard() };
1500        }
1501        const { start, end } = guards;
1502        if (document.body.firstElementChild !== start) {
1503          document.body.insertAdjacentElement("afterbegin", start);
1504        }
1505        if (document.body.lastElementChild !== end) {
1506          document.body.insertAdjacentElement("beforeend", end);
1507        }
1508        count2++;
1509        return () => {
1510          if (count2 === 1) {
1511            guards?.start.remove();
1512            guards?.end.remove();
1513            guards = null;
1514          }
1515          count2 = Math.max(0, count2 - 1);
1516        };
1517      }, []);
1518    }
1519    __name14(useFocusGuards, "useFocusGuards");
1520    function createFocusGuard() {
1521      const element = document.createElement("span");
1522      element.setAttribute("data-radix-focus-guard", "");
1523      element.tabIndex = 0;
1524      element.style.outline = "none";
1525      element.style.opacity = "0";
1526      element.style.position = "fixed";
1527      element.style.pointerEvents = "none";
1528      return element;
1529    }
1530    __name14(createFocusGuard, "createFocusGuard");
1531  
1532    // node_modules/.store/tslib@2.8.1-LT-dxu1EkVy7OUDyVf5glQ/node_modules/tslib/tslib.es6.mjs
1533    var __assign = function() {
1534      __assign = Object.assign || function __assign2(t2) {
1535        for (var s, i = 1, n = arguments.length; i < n; i++) {
1536          s = arguments[i];
1537          for (var p2 in s) if (Object.prototype.hasOwnProperty.call(s, p2)) t2[p2] = s[p2];
1538        }
1539        return t2;
1540      };
1541      return __assign.apply(this, arguments);
1542    };
1543    function __rest(s, e) {
1544      var t2 = {};
1545      for (var p2 in s) if (Object.prototype.hasOwnProperty.call(s, p2) && e.indexOf(p2) < 0)
1546        t2[p2] = s[p2];
1547      if (s != null && typeof Object.getOwnPropertySymbols === "function")
1548        for (var i = 0, p2 = Object.getOwnPropertySymbols(s); i < p2.length; i++) {
1549          if (e.indexOf(p2[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p2[i]))
1550            t2[p2[i]] = s[p2[i]];
1551        }
1552      return t2;
1553    }
1554    function __spreadArray(to, from, pack) {
1555      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
1556        if (ar || !(i in from)) {
1557          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
1558          ar[i] = from[i];
1559        }
1560      }
1561      return to.concat(ar || Array.prototype.slice.call(from));
1562    }
1563  
1564    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/Combination.js
1565    var React21 = __toESM(require_react());
1566  
1567    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/UI.js
1568    var React17 = __toESM(require_react());
1569  
1570    // node_modules/.store/react-remove-scroll-bar@2.3.8-4TFmpYw1N_ya2Y7i0xBtxQ/node_modules/react-remove-scroll-bar/dist/es2015/constants.js
1571    var zeroRightClassName = "right-scroll-bar-position";
1572    var fullWidthClassName = "width-before-scroll-bar";
1573    var noScrollbarsClassName = "with-scroll-bars-hidden";
1574    var removedBarSizeVariable = "--removed-body-scroll-bar-size";
1575  
1576    // node_modules/.store/use-callback-ref@1.3.3-CY49Gx_8xVP_WAvrqWfBkg/node_modules/use-callback-ref/dist/es2015/assignRef.js
1577    function assignRef(ref, value) {
1578      if (typeof ref === "function") {
1579        ref(value);
1580      } else if (ref) {
1581        ref.current = value;
1582      }
1583      return ref;
1584    }
1585  
1586    // node_modules/.store/use-callback-ref@1.3.3-CY49Gx_8xVP_WAvrqWfBkg/node_modules/use-callback-ref/dist/es2015/useRef.js
1587    var import_react = __toESM(require_react());
1588    function useCallbackRef2(initialValue, callback) {
1589      var ref = (0, import_react.useState)(function() {
1590        return {
1591          // value
1592          value: initialValue,
1593          // last callback
1594          callback,
1595          // "memoized" public interface
1596          facade: {
1597            get current() {
1598              return ref.value;
1599            },
1600            set current(value) {
1601              var last = ref.value;
1602              if (last !== value) {
1603                ref.value = value;
1604                ref.callback(value, last);
1605              }
1606            }
1607          }
1608        };
1609      })[0];
1610      ref.callback = callback;
1611      return ref.facade;
1612    }
1613  
1614    // node_modules/.store/use-callback-ref@1.3.3-CY49Gx_8xVP_WAvrqWfBkg/node_modules/use-callback-ref/dist/es2015/useMergeRef.js
1615    var React15 = __toESM(require_react());
1616    var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React15.useLayoutEffect : React15.useEffect;
1617    var currentValues = /* @__PURE__ */ new WeakMap();
1618    function useMergeRefs(refs, defaultValue) {
1619      var callbackRef = useCallbackRef2(defaultValue || null, function(newValue) {
1620        return refs.forEach(function(ref) {
1621          return assignRef(ref, newValue);
1622        });
1623      });
1624      useIsomorphicLayoutEffect(function() {
1625        var oldValue = currentValues.get(callbackRef);
1626        if (oldValue) {
1627          var prevRefs_1 = new Set(oldValue);
1628          var nextRefs_1 = new Set(refs);
1629          var current_1 = callbackRef.current;
1630          prevRefs_1.forEach(function(ref) {
1631            if (!nextRefs_1.has(ref)) {
1632              assignRef(ref, null);
1633            }
1634          });
1635          nextRefs_1.forEach(function(ref) {
1636            if (!prevRefs_1.has(ref)) {
1637              assignRef(ref, current_1);
1638            }
1639          });
1640        }
1641        currentValues.set(callbackRef, refs);
1642      }, [refs]);
1643      return callbackRef;
1644    }
1645  
1646    // node_modules/.store/use-sidecar@1.1.3-6pQBe5oGIq-z4KtBgLaB5w/node_modules/use-sidecar/dist/es2015/medium.js
1647    function ItoI(a) {
1648      return a;
1649    }
1650    function innerCreateMedium(defaults, middleware) {
1651      if (middleware === void 0) {
1652        middleware = ItoI;
1653      }
1654      var buffer = [];
1655      var assigned = false;
1656      var medium = {
1657        read: function() {
1658          if (assigned) {
1659            throw new Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.");
1660          }
1661          if (buffer.length) {
1662            return buffer[buffer.length - 1];
1663          }
1664          return defaults;
1665        },
1666        useMedium: function(data) {
1667          var item = middleware(data, assigned);
1668          buffer.push(item);
1669          return function() {
1670            buffer = buffer.filter(function(x) {
1671              return x !== item;
1672            });
1673          };
1674        },
1675        assignSyncMedium: function(cb) {
1676          assigned = true;
1677          while (buffer.length) {
1678            var cbs = buffer;
1679            buffer = [];
1680            cbs.forEach(cb);
1681          }
1682          buffer = {
1683            push: function(x) {
1684              return cb(x);
1685            },
1686            filter: function() {
1687              return buffer;
1688            }
1689          };
1690        },
1691        assignMedium: function(cb) {
1692          assigned = true;
1693          var pendingQueue = [];
1694          if (buffer.length) {
1695            var cbs = buffer;
1696            buffer = [];
1697            cbs.forEach(cb);
1698            pendingQueue = buffer;
1699          }
1700          var executeQueue = function() {
1701            var cbs2 = pendingQueue;
1702            pendingQueue = [];
1703            cbs2.forEach(cb);
1704          };
1705          var cycle = function() {
1706            return Promise.resolve().then(executeQueue);
1707          };
1708          cycle();
1709          buffer = {
1710            push: function(x) {
1711              pendingQueue.push(x);
1712              cycle();
1713            },
1714            filter: function(filter) {
1715              pendingQueue = pendingQueue.filter(filter);
1716              return buffer;
1717            }
1718          };
1719        }
1720      };
1721      return medium;
1722    }
1723    function createSidecarMedium(options) {
1724      if (options === void 0) {
1725        options = {};
1726      }
1727      var medium = innerCreateMedium(null);
1728      medium.options = __assign({ async: true, ssr: false }, options);
1729      return medium;
1730    }
1731  
1732    // node_modules/.store/use-sidecar@1.1.3-6pQBe5oGIq-z4KtBgLaB5w/node_modules/use-sidecar/dist/es2015/exports.js
1733    var React16 = __toESM(require_react());
1734    var SideCar = function(_a) {
1735      var sideCar = _a.sideCar, rest = __rest(_a, ["sideCar"]);
1736      if (!sideCar) {
1737        throw new Error("Sidecar: please provide `sideCar` property to import the right car");
1738      }
1739      var Target = sideCar.read();
1740      if (!Target) {
1741        throw new Error("Sidecar medium not found");
1742      }
1743      return React16.createElement(Target, __assign({}, rest));
1744    };
1745    SideCar.isSideCarExport = true;
1746    function exportSidecar(medium, exported) {
1747      medium.useMedium(exported);
1748      return SideCar;
1749    }
1750  
1751    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/medium.js
1752    var effectCar = createSidecarMedium();
1753  
1754    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/UI.js
1755    var nothing = function() {
1756      return;
1757    };
1758    var RemoveScroll = React17.forwardRef(function(props, parentRef) {
1759      var ref = React17.useRef(null);
1760      var _a = React17.useState({
1761        onScrollCapture: nothing,
1762        onWheelCapture: nothing,
1763        onTouchMoveCapture: nothing
1764      }), callbacks = _a[0], setCallbacks = _a[1];
1765      var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noRelative = props.noRelative, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? "div" : _b, gapMode = props.gapMode, rest = __rest(props, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noRelative", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]);
1766      var SideCar2 = sideCar;
1767      var containerRef = useMergeRefs([ref, parentRef]);
1768      var containerProps = __assign(__assign({}, rest), callbacks);
1769      return React17.createElement(
1770        React17.Fragment,
1771        null,
1772        enabled && React17.createElement(SideCar2, { sideCar: effectCar, removeScrollBar, shards, noRelative, noIsolation, inert, setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref, gapMode }),
1773        forwardProps ? React17.cloneElement(React17.Children.only(children), __assign(__assign({}, containerProps), { ref: containerRef })) : React17.createElement(Container, __assign({}, containerProps, { className, ref: containerRef }), children)
1774      );
1775    });
1776    RemoveScroll.defaultProps = {
1777      enabled: true,
1778      removeScrollBar: true,
1779      inert: false
1780    };
1781    RemoveScroll.classNames = {
1782      fullWidth: fullWidthClassName,
1783      zeroRight: zeroRightClassName
1784    };
1785  
1786    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/SideEffect.js
1787    var React20 = __toESM(require_react());
1788  
1789    // node_modules/.store/react-remove-scroll-bar@2.3.8-4TFmpYw1N_ya2Y7i0xBtxQ/node_modules/react-remove-scroll-bar/dist/es2015/component.js
1790    var React19 = __toESM(require_react());
1791  
1792    // node_modules/.store/react-style-singleton@2.2.3-HhrrM8n2z-BDpx6IHTz-qw/node_modules/react-style-singleton/dist/es2015/hook.js
1793    var React18 = __toESM(require_react());
1794  
1795    // node_modules/.store/get-nonce@1.0.1-T9SDetHAbMT8POt0PFKPhQ/node_modules/get-nonce/dist/es2015/index.js
1796    var currentNonce;
1797    var getNonce = function() {
1798      if (currentNonce) {
1799        return currentNonce;
1800      }
1801      if (typeof __webpack_nonce__ !== "undefined") {
1802        return __webpack_nonce__;
1803      }
1804      return void 0;
1805    };
1806  
1807    // node_modules/.store/react-style-singleton@2.2.3-HhrrM8n2z-BDpx6IHTz-qw/node_modules/react-style-singleton/dist/es2015/singleton.js
1808    function makeStyleTag() {
1809      if (!document)
1810        return null;
1811      var tag = document.createElement("style");
1812      tag.type = "text/css";
1813      var nonce = getNonce();
1814      if (nonce) {
1815        tag.setAttribute("nonce", nonce);
1816      }
1817      return tag;
1818    }
1819    function injectStyles(tag, css) {
1820      if (tag.styleSheet) {
1821        tag.styleSheet.cssText = css;
1822      } else {
1823        tag.appendChild(document.createTextNode(css));
1824      }
1825    }
1826    function insertStyleTag(tag) {
1827      var head = document.head || document.getElementsByTagName("head")[0];
1828      head.appendChild(tag);
1829    }
1830    var stylesheetSingleton = function() {
1831      var counter = 0;
1832      var stylesheet = null;
1833      return {
1834        add: function(style) {
1835          if (counter == 0) {
1836            if (stylesheet = makeStyleTag()) {
1837              injectStyles(stylesheet, style);
1838              insertStyleTag(stylesheet);
1839            }
1840          }
1841          counter++;
1842        },
1843        remove: function() {
1844          counter--;
1845          if (!counter && stylesheet) {
1846            stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);
1847            stylesheet = null;
1848          }
1849        }
1850      };
1851    };
1852  
1853    // node_modules/.store/react-style-singleton@2.2.3-HhrrM8n2z-BDpx6IHTz-qw/node_modules/react-style-singleton/dist/es2015/hook.js
1854    var styleHookSingleton = function() {
1855      var sheet = stylesheetSingleton();
1856      return function(styles, isDynamic) {
1857        React18.useEffect(function() {
1858          sheet.add(styles);
1859          return function() {
1860            sheet.remove();
1861          };
1862        }, [styles && isDynamic]);
1863      };
1864    };
1865  
1866    // node_modules/.store/react-style-singleton@2.2.3-HhrrM8n2z-BDpx6IHTz-qw/node_modules/react-style-singleton/dist/es2015/component.js
1867    var styleSingleton = function() {
1868      var useStyle = styleHookSingleton();
1869      var Sheet = function(_a) {
1870        var styles = _a.styles, dynamic = _a.dynamic;
1871        useStyle(styles, dynamic);
1872        return null;
1873      };
1874      return Sheet;
1875    };
1876  
1877    // node_modules/.store/react-remove-scroll-bar@2.3.8-4TFmpYw1N_ya2Y7i0xBtxQ/node_modules/react-remove-scroll-bar/dist/es2015/utils.js
1878    var zeroGap = {
1879      left: 0,
1880      top: 0,
1881      right: 0,
1882      gap: 0
1883    };
1884    var parse = function(x) {
1885      return parseInt(x || "", 10) || 0;
1886    };
1887    var getOffset = function(gapMode) {
1888      var cs = window.getComputedStyle(document.body);
1889      var left = cs[gapMode === "padding" ? "paddingLeft" : "marginLeft"];
1890      var top = cs[gapMode === "padding" ? "paddingTop" : "marginTop"];
1891      var right = cs[gapMode === "padding" ? "paddingRight" : "marginRight"];
1892      return [parse(left), parse(top), parse(right)];
1893    };
1894    var getGapWidth = function(gapMode) {
1895      if (gapMode === void 0) {
1896        gapMode = "margin";
1897      }
1898      if (typeof window === "undefined") {
1899        return zeroGap;
1900      }
1901      var offsets = getOffset(gapMode);
1902      var documentWidth = document.documentElement.clientWidth;
1903      var windowWidth = window.innerWidth;
1904      return {
1905        left: offsets[0],
1906        top: offsets[1],
1907        right: offsets[2],
1908        gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0])
1909      };
1910    };
1911  
1912    // node_modules/.store/react-remove-scroll-bar@2.3.8-4TFmpYw1N_ya2Y7i0xBtxQ/node_modules/react-remove-scroll-bar/dist/es2015/component.js
1913    var Style = styleSingleton();
1914    var lockAttribute = "data-scroll-locked";
1915    var getStyles = function(_a, allowRelative, gapMode, important) {
1916      var left = _a.left, top = _a.top, right = _a.right, gap = _a.gap;
1917      if (gapMode === void 0) {
1918        gapMode = "margin";
1919      }
1920      return "\n  .".concat(noScrollbarsClassName, " {\n   overflow: hidden ").concat(important, ";\n   padding-right: ").concat(gap, "px ").concat(important, ";\n  }\n  body[").concat(lockAttribute, "] {\n    overflow: hidden ").concat(important, ";\n    overscroll-behavior: contain;\n    ").concat([
1921        allowRelative && "position: relative ".concat(important, ";"),
1922        gapMode === "margin" && "\n    padding-left: ".concat(left, "px;\n    padding-top: ").concat(top, "px;\n    padding-right: ").concat(right, "px;\n    margin-left:0;\n    margin-top:0;\n    margin-right: ").concat(gap, "px ").concat(important, ";\n    "),
1923        gapMode === "padding" && "padding-right: ".concat(gap, "px ").concat(important, ";")
1924      ].filter(Boolean).join(""), "\n  }\n  \n  .").concat(zeroRightClassName, " {\n    right: ").concat(gap, "px ").concat(important, ";\n  }\n  \n  .").concat(fullWidthClassName, " {\n    margin-right: ").concat(gap, "px ").concat(important, ";\n  }\n  \n  .").concat(zeroRightClassName, " .").concat(zeroRightClassName, " {\n    right: 0 ").concat(important, ";\n  }\n  \n  .").concat(fullWidthClassName, " .").concat(fullWidthClassName, " {\n    margin-right: 0 ").concat(important, ";\n  }\n  \n  body[").concat(lockAttribute, "] {\n    ").concat(removedBarSizeVariable, ": ").concat(gap, "px;\n  }\n");
1925    };
1926    var getCurrentUseCounter = function() {
1927      var counter = parseInt(document.body.getAttribute(lockAttribute) || "0", 10);
1928      return isFinite(counter) ? counter : 0;
1929    };
1930    var useLockAttribute = function() {
1931      React19.useEffect(function() {
1932        document.body.setAttribute(lockAttribute, (getCurrentUseCounter() + 1).toString());
1933        return function() {
1934          var newCounter = getCurrentUseCounter() - 1;
1935          if (newCounter <= 0) {
1936            document.body.removeAttribute(lockAttribute);
1937          } else {
1938            document.body.setAttribute(lockAttribute, newCounter.toString());
1939          }
1940        };
1941      }, []);
1942    };
1943    var RemoveScrollBar = function(_a) {
1944      var noRelative = _a.noRelative, noImportant = _a.noImportant, _b = _a.gapMode, gapMode = _b === void 0 ? "margin" : _b;
1945      useLockAttribute();
1946      var gap = React19.useMemo(function() {
1947        return getGapWidth(gapMode);
1948      }, [gapMode]);
1949      return React19.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? "!important" : "") });
1950    };
1951  
1952    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js
1953    var passiveSupported = false;
1954    if (typeof window !== "undefined") {
1955      try {
1956        options = Object.defineProperty({}, "passive", {
1957          get: function() {
1958            passiveSupported = true;
1959            return true;
1960          }
1961        });
1962        window.addEventListener("test", options, options);
1963        window.removeEventListener("test", options, options);
1964      } catch (err) {
1965        passiveSupported = false;
1966      }
1967    }
1968    var options;
1969    var nonPassive = passiveSupported ? { passive: false } : false;
1970  
1971    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/handleScroll.js
1972    var alwaysContainsScroll = function(node) {
1973      return node.tagName === "TEXTAREA";
1974    };
1975    var elementCanBeScrolled = function(node, overflow) {
1976      if (!(node instanceof Element)) {
1977        return false;
1978      }
1979      var styles = window.getComputedStyle(node);
1980      return (
1981        // not-not-scrollable
1982        styles[overflow] !== "hidden" && // contains scroll inside self
1983        !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === "visible")
1984      );
1985    };
1986    var elementCouldBeVScrolled = function(node) {
1987      return elementCanBeScrolled(node, "overflowY");
1988    };
1989    var elementCouldBeHScrolled = function(node) {
1990      return elementCanBeScrolled(node, "overflowX");
1991    };
1992    var locationCouldBeScrolled = function(axis, node) {
1993      var ownerDocument = node.ownerDocument;
1994      var current = node;
1995      do {
1996        if (typeof ShadowRoot !== "undefined" && current instanceof ShadowRoot) {
1997          current = current.host;
1998        }
1999        var isScrollable = elementCouldBeScrolled(axis, current);
2000        if (isScrollable) {
2001          var _a = getScrollVariables(axis, current), scrollHeight = _a[1], clientHeight = _a[2];
2002          if (scrollHeight > clientHeight) {
2003            return true;
2004          }
2005        }
2006        current = current.parentNode;
2007      } while (current && current !== ownerDocument.body);
2008      return false;
2009    };
2010    var getVScrollVariables = function(_a) {
2011      var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;
2012      return [
2013        scrollTop,
2014        scrollHeight,
2015        clientHeight
2016      ];
2017    };
2018    var getHScrollVariables = function(_a) {
2019      var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;
2020      return [
2021        scrollLeft,
2022        scrollWidth,
2023        clientWidth
2024      ];
2025    };
2026    var elementCouldBeScrolled = function(axis, node) {
2027      return axis === "v" ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);
2028    };
2029    var getScrollVariables = function(axis, node) {
2030      return axis === "v" ? getVScrollVariables(node) : getHScrollVariables(node);
2031    };
2032    var getDirectionFactor = function(axis, direction) {
2033      return axis === "h" && direction === "rtl" ? -1 : 1;
2034    };
2035    var handleScroll = function(axis, endTarget, event, sourceDelta, noOverscroll) {
2036      var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);
2037      var delta = directionFactor * sourceDelta;
2038      var target = event.target;
2039      var targetInLock = endTarget.contains(target);
2040      var shouldCancelScroll = false;
2041      var isDeltaPositive = delta > 0;
2042      var availableScroll = 0;
2043      var availableScrollTop = 0;
2044      do {
2045        if (!target) {
2046          break;
2047        }
2048        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];
2049        var elementScroll = scroll_1 - capacity - directionFactor * position;
2050        if (position || elementScroll) {
2051          if (elementCouldBeScrolled(axis, target)) {
2052            availableScroll += elementScroll;
2053            availableScrollTop += position;
2054          }
2055        }
2056        var parent_1 = target.parentNode;
2057        target = parent_1 && parent_1.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? parent_1.host : parent_1;
2058      } while (
2059        // portaled content
2060        !targetInLock && target !== document.body || // self content
2061        targetInLock && (endTarget.contains(target) || endTarget === target)
2062      );
2063      if (isDeltaPositive && (noOverscroll && Math.abs(availableScroll) < 1 || !noOverscroll && delta > availableScroll)) {
2064        shouldCancelScroll = true;
2065      } else if (!isDeltaPositive && (noOverscroll && Math.abs(availableScrollTop) < 1 || !noOverscroll && -delta > availableScrollTop)) {
2066        shouldCancelScroll = true;
2067      }
2068      return shouldCancelScroll;
2069    };
2070  
2071    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/SideEffect.js
2072    var getTouchXY = function(event) {
2073      return "changedTouches" in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];
2074    };
2075    var getDeltaXY = function(event) {
2076      return [event.deltaX, event.deltaY];
2077    };
2078    var extractRef = function(ref) {
2079      return ref && "current" in ref ? ref.current : ref;
2080    };
2081    var deltaCompare = function(x, y) {
2082      return x[0] === y[0] && x[1] === y[1];
2083    };
2084    var generateStyle = function(id) {
2085      return "\n  .block-interactivity-".concat(id, " {pointer-events: none;}\n  .allow-interactivity-").concat(id, " {pointer-events: all;}\n");
2086    };
2087    var idCounter = 0;
2088    var lockStack = [];
2089    function RemoveScrollSideCar(props) {
2090      var shouldPreventQueue = React20.useRef([]);
2091      var touchStartRef = React20.useRef([0, 0]);
2092      var activeAxis = React20.useRef();
2093      var id = React20.useState(idCounter++)[0];
2094      var Style2 = React20.useState(styleSingleton)[0];
2095      var lastProps = React20.useRef(props);
2096      React20.useEffect(function() {
2097        lastProps.current = props;
2098      }, [props]);
2099      React20.useEffect(function() {
2100        if (props.inert) {
2101          document.body.classList.add("block-interactivity-".concat(id));
2102          var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);
2103          allow_1.forEach(function(el) {
2104            return el.classList.add("allow-interactivity-".concat(id));
2105          });
2106          return function() {
2107            document.body.classList.remove("block-interactivity-".concat(id));
2108            allow_1.forEach(function(el) {
2109              return el.classList.remove("allow-interactivity-".concat(id));
2110            });
2111          };
2112        }
2113        return;
2114      }, [props.inert, props.lockRef.current, props.shards]);
2115      var shouldCancelEvent = React20.useCallback(function(event, parent) {
2116        if ("touches" in event && event.touches.length === 2 || event.type === "wheel" && event.ctrlKey) {
2117          return !lastProps.current.allowPinchZoom;
2118        }
2119        var touch = getTouchXY(event);
2120        var touchStart = touchStartRef.current;
2121        var deltaX = "deltaX" in event ? event.deltaX : touchStart[0] - touch[0];
2122        var deltaY = "deltaY" in event ? event.deltaY : touchStart[1] - touch[1];
2123        var currentAxis;
2124        var target = event.target;
2125        var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? "h" : "v";
2126        if ("touches" in event && moveDirection === "h" && target.type === "range") {
2127          return false;
2128        }
2129        var selection = window.getSelection();
2130        var anchorNode = selection && selection.anchorNode;
2131        var isTouchingSelection = anchorNode ? anchorNode === target || anchorNode.contains(target) : false;
2132        if (isTouchingSelection) {
2133          return false;
2134        }
2135        var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
2136        if (!canBeScrolledInMainDirection) {
2137          return true;
2138        }
2139        if (canBeScrolledInMainDirection) {
2140          currentAxis = moveDirection;
2141        } else {
2142          currentAxis = moveDirection === "v" ? "h" : "v";
2143          canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);
2144        }
2145        if (!canBeScrolledInMainDirection) {
2146          return false;
2147        }
2148        if (!activeAxis.current && "changedTouches" in event && (deltaX || deltaY)) {
2149          activeAxis.current = currentAxis;
2150        }
2151        if (!currentAxis) {
2152          return true;
2153        }
2154        var cancelingAxis = activeAxis.current || currentAxis;
2155        return handleScroll(cancelingAxis, parent, event, cancelingAxis === "h" ? deltaX : deltaY, true);
2156      }, []);
2157      var shouldPrevent = React20.useCallback(function(_event) {
2158        var event = _event;
2159        if (!lockStack.length || lockStack[lockStack.length - 1] !== Style2) {
2160          return;
2161        }
2162        var delta = "deltaY" in event ? getDeltaXY(event) : getTouchXY(event);
2163        var sourceEvent = shouldPreventQueue.current.filter(function(e) {
2164          return e.name === event.type && (e.target === event.target || event.target === e.shadowParent) && deltaCompare(e.delta, delta);
2165        })[0];
2166        if (sourceEvent && sourceEvent.should) {
2167          if (event.cancelable) {
2168            event.preventDefault();
2169          }
2170          return;
2171        }
2172        if (!sourceEvent) {
2173          var shardNodes = (lastProps.current.shards || []).map(extractRef).filter(Boolean).filter(function(node) {
2174            return node.contains(event.target);
2175          });
2176          var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;
2177          if (shouldStop) {
2178            if (event.cancelable) {
2179              event.preventDefault();
2180            }
2181          }
2182        }
2183      }, []);
2184      var shouldCancel = React20.useCallback(function(name, delta, target, should) {
2185        var event = { name, delta, target, should, shadowParent: getOutermostShadowParent(target) };
2186        shouldPreventQueue.current.push(event);
2187        setTimeout(function() {
2188          shouldPreventQueue.current = shouldPreventQueue.current.filter(function(e) {
2189            return e !== event;
2190          });
2191        }, 1);
2192      }, []);
2193      var scrollTouchStart = React20.useCallback(function(event) {
2194        touchStartRef.current = getTouchXY(event);
2195        activeAxis.current = void 0;
2196      }, []);
2197      var scrollWheel = React20.useCallback(function(event) {
2198        shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
2199      }, []);
2200      var scrollTouchMove = React20.useCallback(function(event) {
2201        shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));
2202      }, []);
2203      React20.useEffect(function() {
2204        lockStack.push(Style2);
2205        props.setCallbacks({
2206          onScrollCapture: scrollWheel,
2207          onWheelCapture: scrollWheel,
2208          onTouchMoveCapture: scrollTouchMove
2209        });
2210        document.addEventListener("wheel", shouldPrevent, nonPassive);
2211        document.addEventListener("touchmove", shouldPrevent, nonPassive);
2212        document.addEventListener("touchstart", scrollTouchStart, nonPassive);
2213        return function() {
2214          lockStack = lockStack.filter(function(inst) {
2215            return inst !== Style2;
2216          });
2217          document.removeEventListener("wheel", shouldPrevent, nonPassive);
2218          document.removeEventListener("touchmove", shouldPrevent, nonPassive);
2219          document.removeEventListener("touchstart", scrollTouchStart, nonPassive);
2220        };
2221      }, []);
2222      var removeScrollBar = props.removeScrollBar, inert = props.inert;
2223      return React20.createElement(
2224        React20.Fragment,
2225        null,
2226        inert ? React20.createElement(Style2, { styles: generateStyle(id) }) : null,
2227        removeScrollBar ? React20.createElement(RemoveScrollBar, { noRelative: props.noRelative, gapMode: props.gapMode }) : null
2228      );
2229    }
2230    function getOutermostShadowParent(node) {
2231      var shadowParent = null;
2232      while (node !== null) {
2233        if (node instanceof ShadowRoot) {
2234          shadowParent = node.host;
2235          node = node.host;
2236        }
2237        node = node.parentNode;
2238      }
2239      return shadowParent;
2240    }
2241  
2242    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/sidecar.js
2243    var sidecar_default = exportSidecar(effectCar, RemoveScrollSideCar);
2244  
2245    // node_modules/.store/react-remove-scroll@2.7.2-g5JjNH6M9u1FDMe3NHg_3Q/node_modules/react-remove-scroll/dist/es2015/Combination.js
2246    var ReactRemoveScroll = React21.forwardRef(function(props, ref) {
2247      return React21.createElement(RemoveScroll, __assign({}, props, { ref, sideCar: sidecar_default }));
2248    });
2249    ReactRemoveScroll.classNames = RemoveScroll.classNames;
2250    var Combination_default = ReactRemoveScroll;
2251  
2252    // node_modules/.store/aria-hidden@1.2.6--GO2Ve_nUkubj48l2T3YZg/node_modules/aria-hidden/dist/es2015/index.js
2253    var getDefaultParent = function(originalTarget) {
2254      if (typeof document === "undefined") {
2255        return null;
2256      }
2257      var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;
2258      return sampleTarget.ownerDocument.body;
2259    };
2260    var counterMap = /* @__PURE__ */ new WeakMap();
2261    var uncontrolledNodes = /* @__PURE__ */ new WeakMap();
2262    var markerMap = {};
2263    var lockCount = 0;
2264    var unwrapHost = function(node) {
2265      return node && (node.host || unwrapHost(node.parentNode));
2266    };
2267    var correctTargets = function(parent, targets) {
2268      return targets.map(function(target) {
2269        if (parent.contains(target)) {
2270          return target;
2271        }
2272        var correctedTarget = unwrapHost(target);
2273        if (correctedTarget && parent.contains(correctedTarget)) {
2274          return correctedTarget;
2275        }
2276        console.error("aria-hidden", target, "in not contained inside", parent, ". Doing nothing");
2277        return null;
2278      }).filter(function(x) {
2279        return Boolean(x);
2280      });
2281    };
2282    var applyAttributeToOthers = function(originalTarget, parentNode, markerName, controlAttribute) {
2283      var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
2284      if (!markerMap[markerName]) {
2285        markerMap[markerName] = /* @__PURE__ */ new WeakMap();
2286      }
2287      var markerCounter = markerMap[markerName];
2288      var hiddenNodes = [];
2289      var elementsToKeep = /* @__PURE__ */ new Set();
2290      var elementsToStop = new Set(targets);
2291      var keep = function(el) {
2292        if (!el || elementsToKeep.has(el)) {
2293          return;
2294        }
2295        elementsToKeep.add(el);
2296        keep(el.parentNode);
2297      };
2298      targets.forEach(keep);
2299      var deep = function(parent) {
2300        if (!parent || elementsToStop.has(parent)) {
2301          return;
2302        }
2303        Array.prototype.forEach.call(parent.children, function(node) {
2304          if (elementsToKeep.has(node)) {
2305            deep(node);
2306          } else {
2307            try {
2308              var attr = node.getAttribute(controlAttribute);
2309              var alreadyHidden = attr !== null && attr !== "false";
2310              var counterValue = (counterMap.get(node) || 0) + 1;
2311              var markerValue = (markerCounter.get(node) || 0) + 1;
2312              counterMap.set(node, counterValue);
2313              markerCounter.set(node, markerValue);
2314              hiddenNodes.push(node);
2315              if (counterValue === 1 && alreadyHidden) {
2316                uncontrolledNodes.set(node, true);
2317              }
2318              if (markerValue === 1) {
2319                node.setAttribute(markerName, "true");
2320              }
2321              if (!alreadyHidden) {
2322                node.setAttribute(controlAttribute, "true");
2323              }
2324            } catch (e) {
2325              console.error("aria-hidden: cannot operate on ", node, e);
2326            }
2327          }
2328        });
2329      };
2330      deep(parentNode);
2331      elementsToKeep.clear();
2332      lockCount++;
2333      return function() {
2334        hiddenNodes.forEach(function(node) {
2335          var counterValue = counterMap.get(node) - 1;
2336          var markerValue = markerCounter.get(node) - 1;
2337          counterMap.set(node, counterValue);
2338          markerCounter.set(node, markerValue);
2339          if (!counterValue) {
2340            if (!uncontrolledNodes.has(node)) {
2341              node.removeAttribute(controlAttribute);
2342            }
2343            uncontrolledNodes.delete(node);
2344          }
2345          if (!markerValue) {
2346            node.removeAttribute(markerName);
2347          }
2348        });
2349        lockCount--;
2350        if (!lockCount) {
2351          counterMap = /* @__PURE__ */ new WeakMap();
2352          counterMap = /* @__PURE__ */ new WeakMap();
2353          uncontrolledNodes = /* @__PURE__ */ new WeakMap();
2354          markerMap = {};
2355        }
2356      };
2357    };
2358    var hideOthers = function(originalTarget, parentNode, markerName) {
2359      if (markerName === void 0) {
2360        markerName = "data-aria-hidden";
2361      }
2362      var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);
2363      var activeParentNode = parentNode || getDefaultParent(originalTarget);
2364      if (!activeParentNode) {
2365        return function() {
2366          return null;
2367        };
2368      }
2369      targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll("[aria-live], script")));
2370      return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden");
2371    };
2372  
2373    // node_modules/.store/@radix-ui/react-dialog@1.1.23-ytDSaPyJAw3b9aD4KkIiOA/node_modules/@radix-ui/react-dialog/dist/index.mjs
2374    var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
2375    var __defProp16 = Object.defineProperty;
2376    var __name15 = (target, value) => __defProp16(target, "name", { value, configurable: true });
2377    var DIALOG_NAME = "Dialog";
2378    var [createDialogContext, createDialogScope] = createContextScope(DIALOG_NAME);
2379    var [DialogProvider, useDialogContext] = createDialogContext(DIALOG_NAME);
2380    var Dialog = /* @__PURE__ */ __name15((props) => {
2381      const {
2382        __scopeDialog,
2383        children,
2384        open: openProp,
2385        defaultOpen,
2386        onOpenChange,
2387        modal = true
2388      } = props;
2389      const triggerRef = React24.useRef(null);
2390      const contentRef = React24.useRef(null);
2391      const [open2, setOpen] = useControllableState({
2392        prop: openProp,
2393        defaultProp: defaultOpen ?? false,
2394        onChange: onOpenChange,
2395        caller: DIALOG_NAME
2396      });
2397      const [titleCount, setTitleCount] = React24.useState(0);
2398      const [descriptionCount, setDescriptionCount] = React24.useState(0);
2399      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
2400        DialogProvider,
2401        {
2402          scope: __scopeDialog,
2403          triggerRef,
2404          contentRef,
2405          contentId: useId(),
2406          titleId: useId(),
2407          descriptionId: useId(),
2408          titlePresent: titleCount > 0,
2409          descriptionPresent: descriptionCount > 0,
2410          setTitleCount,
2411          setDescriptionCount,
2412          open: open2,
2413          onOpenChange: setOpen,
2414          onOpenToggle: React24.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]),
2415          modal,
2416          children
2417        }
2418      );
2419    }, "Dialog");
2420    var PORTAL_NAME = "DialogPortal";
2421    var [PortalProvider, usePortalContext] = createDialogContext(PORTAL_NAME, {
2422      forceMount: void 0
2423    });
2424    var DialogPortal = /* @__PURE__ */ __name15((props) => {
2425      const { __scopeDialog, forceMount, children, container } = props;
2426      const context2 = useDialogContext(PORTAL_NAME, __scopeDialog);
2427      return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(PortalProvider, { scope: __scopeDialog, forceMount, children: React24.Children.map(children, (child) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Presence, { present: forceMount || context2.open, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Portal, { asChild: true, container, children: child }) })) });
2428    }, "DialogPortal");
2429    var OVERLAY_NAME = "DialogOverlay";
2430    var DialogOverlay = /* @__PURE__ */ React24.forwardRef(
2431      /* @__PURE__ */ __name15(function DialogOverlay2(props, forwardedRef) {
2432        const portalContext = usePortalContext(OVERLAY_NAME, props.__scopeDialog);
2433        const { forceMount = portalContext.forceMount, ...overlayProps } = props;
2434        const context2 = useDialogContext(OVERLAY_NAME, props.__scopeDialog);
2435        return context2.modal ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Presence, { present: forceMount || context2.open, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DialogOverlayImpl, { ...overlayProps, ref: forwardedRef }) }) : null;
2436      }, "DialogOverlay")
2437    );
2438    var Slot = createSlot("DialogOverlay.RemoveScroll");
2439    var DialogOverlayImpl = /* @__PURE__ */ React24.forwardRef(
2440      // blank line to reduce diff noise
2441      /* @__PURE__ */ __name15(function DialogOverlayImpl2(props, forwardedRef) {
2442        const { __scopeDialog, ...overlayProps } = props;
2443        const context2 = useDialogContext(OVERLAY_NAME, __scopeDialog);
2444        const registerDismissableSurface = useDismissableLayerSurface();
2445        const composedRefs = useComposedRefs(forwardedRef, registerDismissableSurface);
2446        return (
2447          // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll`
2448          // ie. when `Overlay` and `Content` are siblings
2449          /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Combination_default, { as: Slot, allowPinchZoom: true, shards: [context2.contentRef], children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
2450            Primitive.div,
2451            {
2452              "data-state": getState(context2.open),
2453              ...overlayProps,
2454              ref: composedRefs,
2455              style: { pointerEvents: "auto", ...overlayProps.style }
2456            }
2457          ) })
2458        );
2459      }, "DialogOverlayImpl")
2460    );
2461    var CONTENT_NAME = "DialogContent";
2462    var DialogContent = /* @__PURE__ */ React24.forwardRef(
2463      /* @__PURE__ */ __name15(function DialogContent2(props, forwardedRef) {
2464        const portalContext = usePortalContext(CONTENT_NAME, props.__scopeDialog);
2465        const { forceMount = portalContext.forceMount, ...contentProps } = props;
2466        const context2 = useDialogContext(CONTENT_NAME, props.__scopeDialog);
2467        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Presence, { present: forceMount || context2.open, children: context2.modal ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DialogContentModal, { ...contentProps, ref: forwardedRef }) : /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DialogContentNonModal, { ...contentProps, ref: forwardedRef }) });
2468      }, "DialogContent")
2469    );
2470    var DialogContentModal = /* @__PURE__ */ React24.forwardRef(
2471      // blank line to reduce diff noise
2472      /* @__PURE__ */ __name15(function DialogContentModal2(props, forwardedRef) {
2473        const context2 = useDialogContext(CONTENT_NAME, props.__scopeDialog);
2474        const contentRef = React24.useRef(null);
2475        const composedRefs = useComposedRefs(forwardedRef, context2.contentRef, contentRef);
2476        React24.useEffect(() => {
2477          const content = contentRef.current;
2478          if (content) return hideOthers(content);
2479        }, []);
2480        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
2481          DialogContentImpl,
2482          {
2483            ...props,
2484            ref: composedRefs,
2485            trapFocus: context2.open,
2486            disableOutsidePointerEvents: context2.open,
2487            onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => {
2488              event.preventDefault();
2489              context2.triggerRef.current?.focus();
2490            }),
2491            onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => {
2492              const originalEvent = event.detail.originalEvent;
2493              const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
2494              const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
2495              if (isRightClick) event.preventDefault();
2496            }),
2497            onFocusOutside: composeEventHandlers(
2498              props.onFocusOutside,
2499              (event) => event.preventDefault()
2500            )
2501          }
2502        );
2503      }, "DialogContentModal")
2504    );
2505    var DialogContentNonModal = /* @__PURE__ */ React24.forwardRef(
2506      // blank line to reduce diff noise
2507      /* @__PURE__ */ __name15(function DialogContentNonModal2(props, forwardedRef) {
2508        const context2 = useDialogContext(CONTENT_NAME, props.__scopeDialog);
2509        const hasInteractedOutsideRef = React24.useRef(false);
2510        const hasPointerDownOutsideRef = React24.useRef(false);
2511        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
2512          DialogContentImpl,
2513          {
2514            ...props,
2515            ref: forwardedRef,
2516            trapFocus: false,
2517            disableOutsidePointerEvents: false,
2518            onCloseAutoFocus: (event) => {
2519              props.onCloseAutoFocus?.(event);
2520              if (!event.defaultPrevented) {
2521                if (!hasInteractedOutsideRef.current) context2.triggerRef.current?.focus();
2522                event.preventDefault();
2523              }
2524              hasInteractedOutsideRef.current = false;
2525              hasPointerDownOutsideRef.current = false;
2526            },
2527            onInteractOutside: (event) => {
2528              props.onInteractOutside?.(event);
2529              if (!event.defaultPrevented) {
2530                hasInteractedOutsideRef.current = true;
2531                if (event.detail.originalEvent.type === "pointerdown") {
2532                  hasPointerDownOutsideRef.current = true;
2533                }
2534              }
2535              const target = event.target;
2536              const targetIsTrigger = context2.triggerRef.current?.contains(target);
2537              if (targetIsTrigger) event.preventDefault();
2538              if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) {
2539                event.preventDefault();
2540              }
2541            }
2542          }
2543        );
2544      }, "DialogContentNonModal")
2545    );
2546    var DialogContentImpl = /* @__PURE__ */ React24.forwardRef(
2547      // blank line to reduce diff noise
2548      /* @__PURE__ */ __name15(function DialogContentImpl2(props, forwardedRef) {
2549        const { __scopeDialog, trapFocus, onOpenAutoFocus, onCloseAutoFocus, ...contentProps } = props;
2550        const context2 = useDialogContext(CONTENT_NAME, __scopeDialog);
2551        useFocusGuards();
2552        return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
2553          FocusScope,
2554          {
2555            asChild: true,
2556            loop: true,
2557            trapped: trapFocus,
2558            onMountAutoFocus: onOpenAutoFocus,
2559            onUnmountAutoFocus: onCloseAutoFocus,
2560            children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
2561              DismissableLayer,
2562              {
2563                role: "dialog",
2564                id: context2.contentId,
2565                "aria-describedby": context2.descriptionPresent ? context2.descriptionId : void 0,
2566                "aria-labelledby": context2.titlePresent ? context2.titleId : void 0,
2567                "data-state": getState(context2.open),
2568                ...contentProps,
2569                ref: forwardedRef,
2570                deferPointerDownOutside: true,
2571                onDismiss: () => context2.onOpenChange(false)
2572              }
2573            )
2574          }
2575        ) });
2576      }, "DialogContentImpl")
2577    );
2578    function getState(open2) {
2579      return open2 ? "open" : "closed";
2580    }
2581    __name15(getState, "getState");
2582  
2583    // node_modules/.store/cmdk@1.1.1-2SvSjHrFhiqsPDore7Lelw/node_modules/cmdk/dist/index.mjs
2584    var t = __toESM(require_react(), 1);
2585    var N = '[cmdk-group=""]';
2586    var Y2 = '[cmdk-group-items=""]';
2587    var be = '[cmdk-group-heading=""]';
2588    var le = '[cmdk-item=""]';
2589    var ce = `$le}:not([aria-disabled="true"])`;
2590    var Z = "cmdk-item-select";
2591    var T = "data-value";
2592    var Re = (r2, o, n) => W(r2, o, n);
2593    var ue = t.createContext(void 0);
2594    var K2 = () => t.useContext(ue);
2595    var de = t.createContext(void 0);
2596    var ee = () => t.useContext(de);
2597    var fe = t.createContext(void 0);
2598    var me = t.forwardRef((r2, o) => {
2599      let n = L(() => {
2600        var e, a;
2601        return { search: "", value: (a = (e = r2.value) != null ? e : r2.defaultValue) != null ? a : "", selectedItemId: void 0, filtered: { count: 0, items: /* @__PURE__ */ new Map(), groups: /* @__PURE__ */ new Set() } };
2602      }), u2 = L(() => /* @__PURE__ */ new Set()), c = L(() => /* @__PURE__ */ new Map()), d = L(() => /* @__PURE__ */ new Map()), f = L(() => /* @__PURE__ */ new Set()), p2 = pe(r2), { label: b, children: m2, value: R, onValueChange: x, filter: C, shouldFilter: S, loop: A, disablePointerSelection: ge = false, vimBindings: j = true, ...O } = r2, $2 = useId(), q = useId(), _ = useId(), I = t.useRef(null), v = ke();
2603      k2(() => {
2604        if (R !== void 0) {
2605          let e = R.trim();
2606          n.current.value = e, E.emit();
2607        }
2608      }, [R]), k2(() => {
2609        v(6, ne);
2610      }, []);
2611      let E = t.useMemo(() => ({ subscribe: (e) => (f.current.add(e), () => f.current.delete(e)), snapshot: () => n.current, setState: (e, a, s) => {
2612        var i, l, g, y;
2613        if (!Object.is(n.current[e], a)) {
2614          if (n.current[e] = a, e === "search") J2(), z(), v(1, W2);
2615          else if (e === "value") {
2616            if (document.activeElement.hasAttribute("cmdk-input") || document.activeElement.hasAttribute("cmdk-root")) {
2617              let h = document.getElementById(_);
2618              h ? h.focus() : (i = document.getElementById($2)) == null || i.focus();
2619            }
2620            if (v(7, () => {
2621              var h;
2622              n.current.selectedItemId = (h = M()) == null ? void 0 : h.id, E.emit();
2623            }), s || v(5, ne), ((l = p2.current) == null ? void 0 : l.value) !== void 0) {
2624              let h = a != null ? a : "";
2625              (y = (g = p2.current).onValueChange) == null || y.call(g, h);
2626              return;
2627            }
2628          }
2629          E.emit();
2630        }
2631      }, emit: () => {
2632        f.current.forEach((e) => e());
2633      } }), []), U2 = t.useMemo(() => ({ value: (e, a, s) => {
2634        var i;
2635        a !== ((i = d.current.get(e)) == null ? void 0 : i.value) && (d.current.set(e, { value: a, keywords: s }), n.current.filtered.items.set(e, te(a, s)), v(2, () => {
2636          z(), E.emit();
2637        }));
2638      }, item: (e, a) => (u2.current.add(e), a && (c.current.has(a) ? c.current.get(a).add(e) : c.current.set(a, /* @__PURE__ */ new Set([e]))), v(3, () => {
2639        J2(), z(), n.current.value || W2(), E.emit();
2640      }), () => {
2641        d.current.delete(e), u2.current.delete(e), n.current.filtered.items.delete(e);
2642        let s = M();
2643        v(4, () => {
2644          J2(), (s == null ? void 0 : s.getAttribute("id")) === e && W2(), E.emit();
2645        });
2646      }), group: (e) => (c.current.has(e) || c.current.set(e, /* @__PURE__ */ new Set()), () => {
2647        d.current.delete(e), c.current.delete(e);
2648      }), filter: () => p2.current.shouldFilter, label: b || r2["aria-label"], getDisablePointerSelection: () => p2.current.disablePointerSelection, listId: $2, inputId: _, labelId: q, listInnerRef: I }), []);
2649      function te(e, a) {
2650        var i, l;
2651        let s = (l = (i = p2.current) == null ? void 0 : i.filter) != null ? l : Re;
2652        return e ? s(e, n.current.search, a) : 0;
2653      }
2654      function z() {
2655        if (!n.current.search || p2.current.shouldFilter === false) return;
2656        let e = n.current.filtered.items, a = [];
2657        n.current.filtered.groups.forEach((i) => {
2658          let l = c.current.get(i), g = 0;
2659          l.forEach((y) => {
2660            let h = e.get(y);
2661            g = Math.max(h, g);
2662          }), a.push([i, g]);
2663        });
2664        let s = I.current;
2665        V().sort((i, l) => {
2666          var h, F;
2667          let g = i.getAttribute("id"), y = l.getAttribute("id");
2668          return ((h = e.get(y)) != null ? h : 0) - ((F = e.get(g)) != null ? F : 0);
2669        }).forEach((i) => {
2670          let l = i.closest(Y2);
2671          l ? l.appendChild(i.parentElement === l ? i : i.closest(`$Y2} > *`)) : s.appendChild(i.parentElement === s ? i : i.closest(`$Y2} > *`));
2672        }), a.sort((i, l) => l[1] - i[1]).forEach((i) => {
2673          var g;
2674          let l = (g = I.current) == null ? void 0 : g.querySelector(`$N}[$T}="$encodeURIComponent(i[0])}"]`);
2675          l == null || l.parentElement.appendChild(l);
2676        });
2677      }
2678      function W2() {
2679        let e = V().find((s) => s.getAttribute("aria-disabled") !== "true"), a = e == null ? void 0 : e.getAttribute(T);
2680        E.setState("value", a || void 0);
2681      }
2682      function J2() {
2683        var a, s, i, l;
2684        if (!n.current.search || p2.current.shouldFilter === false) {
2685          n.current.filtered.count = u2.current.size;
2686          return;
2687        }
2688        n.current.filtered.groups = /* @__PURE__ */ new Set();
2689        let e = 0;
2690        for (let g of u2.current) {
2691          let y = (s = (a = d.current.get(g)) == null ? void 0 : a.value) != null ? s : "", h = (l = (i = d.current.get(g)) == null ? void 0 : i.keywords) != null ? l : [], F = te(y, h);
2692          n.current.filtered.items.set(g, F), F > 0 && e++;
2693        }
2694        for (let [g, y] of c.current) for (let h of y) if (n.current.filtered.items.get(h) > 0) {
2695          n.current.filtered.groups.add(g);
2696          break;
2697        }
2698        n.current.filtered.count = e;
2699      }
2700      function ne() {
2701        var a, s, i;
2702        let e = M();
2703        e && (((a = e.parentElement) == null ? void 0 : a.firstChild) === e && ((i = (s = e.closest(N)) == null ? void 0 : s.querySelector(be)) == null || i.scrollIntoView({ block: "nearest" })), e.scrollIntoView({ block: "nearest" }));
2704      }
2705      function M() {
2706        var e;
2707        return (e = I.current) == null ? void 0 : e.querySelector(`$le}[aria-selected="true"]`);
2708      }
2709      function V() {
2710        var e;
2711        return Array.from(((e = I.current) == null ? void 0 : e.querySelectorAll(ce)) || []);
2712      }
2713      function X2(e) {
2714        let s = V()[e];
2715        s && E.setState("value", s.getAttribute(T));
2716      }
2717      function Q(e) {
2718        var g;
2719        let a = M(), s = V(), i = s.findIndex((y) => y === a), l = s[i + e];
2720        (g = p2.current) != null && g.loop && (l = i + e < 0 ? s[s.length - 1] : i + e === s.length ? s[0] : s[i + e]), l && E.setState("value", l.getAttribute(T));
2721      }
2722      function re(e) {
2723        let a = M(), s = a == null ? void 0 : a.closest(N), i;
2724        for (; s && !i; ) s = e > 0 ? we(s, N) : De(s, N), i = s == null ? void 0 : s.querySelector(ce);
2725        i ? E.setState("value", i.getAttribute(T)) : Q(e);
2726      }
2727      let oe = () => X2(V().length - 1), ie = (e) => {
2728        e.preventDefault(), e.metaKey ? oe() : e.altKey ? re(1) : Q(1);
2729      }, se = (e) => {
2730        e.preventDefault(), e.metaKey ? X2(0) : e.altKey ? re(-1) : Q(-1);
2731      };
2732      return t.createElement(Primitive.div, { ref: o, tabIndex: -1, ...O, "cmdk-root": "", onKeyDown: (e) => {
2733        var s;
2734        (s = O.onKeyDown) == null || s.call(O, e);
2735        let a = e.nativeEvent.isComposing || e.keyCode === 229;
2736        if (!(e.defaultPrevented || a)) switch (e.key) {
2737          case "n":
2738          case "j": {
2739            j && e.ctrlKey && ie(e);
2740            break;
2741          }
2742          case "ArrowDown": {
2743            ie(e);
2744            break;
2745          }
2746          case "p":
2747          case "k": {
2748            j && e.ctrlKey && se(e);
2749            break;
2750          }
2751          case "ArrowUp": {
2752            se(e);
2753            break;
2754          }
2755          case "Home": {
2756            e.preventDefault(), X2(0);
2757            break;
2758          }
2759          case "End": {
2760            e.preventDefault(), oe();
2761            break;
2762          }
2763          case "Enter": {
2764            e.preventDefault();
2765            let i = M();
2766            if (i) {
2767              let l = new Event(Z);
2768              i.dispatchEvent(l);
2769            }
2770          }
2771        }
2772      } }, t.createElement("label", { "cmdk-label": "", htmlFor: U2.inputId, id: U2.labelId, style: Te }, b), B2(r2, (e) => t.createElement(de.Provider, { value: E }, t.createElement(ue.Provider, { value: U2 }, e))));
2773    });
2774    var he = t.forwardRef((r2, o) => {
2775      var _, I;
2776      let n = useId(), u2 = t.useRef(null), c = t.useContext(fe), d = K2(), f = pe(r2), p2 = (I = (_ = f.current) == null ? void 0 : _.forceMount) != null ? I : c == null ? void 0 : c.forceMount;
2777      k2(() => {
2778        if (!p2) return d.item(n, c == null ? void 0 : c.id);
2779      }, [p2]);
2780      let b = ve(n, u2, [r2.value, r2.children, u2], r2.keywords), m2 = ee(), R = P((v) => v.value && v.value === b.current), x = P((v) => p2 || d.filter() === false ? true : v.search ? v.filtered.items.get(n) > 0 : true);
2781      t.useEffect(() => {
2782        let v = u2.current;
2783        if (!(!v || r2.disabled)) return v.addEventListener(Z, C), () => v.removeEventListener(Z, C);
2784      }, [x, r2.onSelect, r2.disabled]);
2785      function C() {
2786        var v, E;
2787        S(), (E = (v = f.current).onSelect) == null || E.call(v, b.current);
2788      }
2789      function S() {
2790        m2.setState("value", b.current, true);
2791      }
2792      if (!x) return null;
2793      let { disabled: A, value: ge, onSelect: j, forceMount: O, keywords: $2, ...q } = r2;
2794      return t.createElement(Primitive.div, { ref: composeRefs(u2, o), ...q, id: n, "cmdk-item": "", role: "option", "aria-disabled": !!A, "aria-selected": !!R, "data-disabled": !!A, "data-selected": !!R, onPointerMove: A || d.getDisablePointerSelection() ? void 0 : S, onClick: A ? void 0 : C }, r2.children);
2795    });
2796    var Ee = t.forwardRef((r2, o) => {
2797      let { heading: n, children: u2, forceMount: c, ...d } = r2, f = useId(), p2 = t.useRef(null), b = t.useRef(null), m2 = useId(), R = K2(), x = P((S) => c || R.filter() === false ? true : S.search ? S.filtered.groups.has(f) : true);
2798      k2(() => R.group(f), []), ve(f, p2, [r2.value, r2.heading, b]);
2799      let C = t.useMemo(() => ({ id: f, forceMount: c }), [c]);
2800      return t.createElement(Primitive.div, { ref: composeRefs(p2, o), ...d, "cmdk-group": "", role: "presentation", hidden: x ? void 0 : true }, n && t.createElement("div", { ref: b, "cmdk-group-heading": "", "aria-hidden": true, id: m2 }, n), B2(r2, (S) => t.createElement("div", { "cmdk-group-items": "", role: "group", "aria-labelledby": n ? m2 : void 0 }, t.createElement(fe.Provider, { value: C }, S))));
2801    });
2802    var ye = t.forwardRef((r2, o) => {
2803      let { alwaysRender: n, ...u2 } = r2, c = t.useRef(null), d = P((f) => !f.search);
2804      return !n && !d ? null : t.createElement(Primitive.div, { ref: composeRefs(c, o), ...u2, "cmdk-separator": "", role: "separator" });
2805    });
2806    var Se = t.forwardRef((r2, o) => {
2807      let { onValueChange: n, ...u2 } = r2, c = r2.value != null, d = ee(), f = P((m2) => m2.search), p2 = P((m2) => m2.selectedItemId), b = K2();
2808      return t.useEffect(() => {
2809        r2.value != null && d.setState("search", r2.value);
2810      }, [r2.value]), t.createElement(Primitive.input, { ref: o, ...u2, "cmdk-input": "", autoComplete: "off", autoCorrect: "off", spellCheck: false, "aria-autocomplete": "list", role: "combobox", "aria-expanded": true, "aria-controls": b.listId, "aria-labelledby": b.labelId, "aria-activedescendant": p2, id: b.inputId, type: "text", value: c ? r2.value : f, onChange: (m2) => {
2811        c || d.setState("search", m2.target.value), n == null || n(m2.target.value);
2812      } });
2813    });
2814    var Ce = t.forwardRef((r2, o) => {
2815      let { children: n, label: u2 = "Suggestions", ...c } = r2, d = t.useRef(null), f = t.useRef(null), p2 = P((m2) => m2.selectedItemId), b = K2();
2816      return t.useEffect(() => {
2817        if (f.current && d.current) {
2818          let m2 = f.current, R = d.current, x, C = new ResizeObserver(() => {
2819            x = requestAnimationFrame(() => {
2820              let S = m2.offsetHeight;
2821              R.style.setProperty("--cmdk-list-height", S.toFixed(1) + "px");
2822            });
2823          });
2824          return C.observe(m2), () => {
2825            cancelAnimationFrame(x), C.unobserve(m2);
2826          };
2827        }
2828      }, []), t.createElement(Primitive.div, { ref: composeRefs(d, o), ...c, "cmdk-list": "", role: "listbox", tabIndex: -1, "aria-activedescendant": p2, "aria-label": u2, id: b.listId }, B2(r2, (m2) => t.createElement("div", { ref: composeRefs(f, b.listInnerRef), "cmdk-list-sizer": "" }, m2)));
2829    });
2830    var xe = t.forwardRef((r2, o) => {
2831      let { open: n, onOpenChange: u2, overlayClassName: c, contentClassName: d, container: f, ...p2 } = r2;
2832      return t.createElement(Dialog, { open: n, onOpenChange: u2 }, t.createElement(DialogPortal, { container: f }, t.createElement(DialogOverlay, { "cmdk-overlay": "", className: c }), t.createElement(DialogContent, { "aria-label": r2.label, "cmdk-dialog": "", className: d }, t.createElement(me, { ref: o, ...p2 }))));
2833    });
2834    var Ie = t.forwardRef((r2, o) => P((u2) => u2.filtered.count === 0) ? t.createElement(Primitive.div, { ref: o, ...r2, "cmdk-empty": "", role: "presentation" }) : null);
2835    var Pe = t.forwardRef((r2, o) => {
2836      let { progress: n, children: u2, label: c = "Loading...", ...d } = r2;
2837      return t.createElement(Primitive.div, { ref: o, ...d, "cmdk-loading": "", role: "progressbar", "aria-valuenow": n, "aria-valuemin": 0, "aria-valuemax": 100, "aria-label": c }, B2(r2, (f) => t.createElement("div", { "aria-hidden": true }, f)));
2838    });
2839    var _e = Object.assign(me, { List: Ce, Item: he, Input: Se, Group: Ee, Separator: ye, Dialog: xe, Empty: Ie, Loading: Pe });
2840    function we(r2, o) {
2841      let n = r2.nextElementSibling;
2842      for (; n; ) {
2843        if (n.matches(o)) return n;
2844        n = n.nextElementSibling;
2845      }
2846    }
2847    function De(r2, o) {
2848      let n = r2.previousElementSibling;
2849      for (; n; ) {
2850        if (n.matches(o)) return n;
2851        n = n.previousElementSibling;
2852      }
2853    }
2854    function pe(r2) {
2855      let o = t.useRef(r2);
2856      return k2(() => {
2857        o.current = r2;
2858      }), o;
2859    }
2860    var k2 = typeof window == "undefined" ? t.useEffect : t.useLayoutEffect;
2861    function L(r2) {
2862      let o = t.useRef();
2863      return o.current === void 0 && (o.current = r2()), o;
2864    }
2865    function P(r2) {
2866      let o = ee(), n = () => r2(o.snapshot());
2867      return t.useSyncExternalStore(o.subscribe, n, n);
2868    }
2869    function ve(r2, o, n, u2 = []) {
2870      let c = t.useRef(), d = K2();
2871      return k2(() => {
2872        var b;
2873        let f = (() => {
2874          var m2;
2875          for (let R of n) {
2876            if (typeof R == "string") return R.trim();
2877            if (typeof R == "object" && "current" in R) return R.current ? (m2 = R.current.textContent) == null ? void 0 : m2.trim() : c.current;
2878          }
2879        })(), p2 = u2.map((m2) => m2.trim());
2880        d.value(r2, f, p2), (b = o.current) == null || b.setAttribute(T, f), c.current = f;
2881      }), c;
2882    }
2883    var ke = () => {
2884      let [r2, o] = t.useState(), n = L(() => /* @__PURE__ */ new Map());
2885      return k2(() => {
2886        n.current.forEach((u2) => u2()), n.current = /* @__PURE__ */ new Map();
2887      }, [r2]), (u2, c) => {
2888        n.current.set(u2, c), o({});
2889      };
2890    };
2891    function Me(r2) {
2892      let o = r2.type;
2893      return typeof o == "function" ? o(r2.props) : "render" in o ? o.render(r2.props) : r2;
2894    }
2895    function B2({ asChild: r2, children: o }, n) {
2896      return r2 && t.isValidElement(o) ? t.cloneElement(Me(o), { ref: o.ref }, n(o.props.children)) : n(o);
2897    }
2898    var Te = { position: "absolute", width: "1px", height: "1px", padding: "0", margin: "-1px", overflow: "hidden", clip: "rect(0, 0, 0, 0)", whiteSpace: "nowrap", borderWidth: "0" };
2899  
2900    // node_modules/.store/clsx@2.1.1-XOLP1vUL9vEGfpiXm37fAw/node_modules/clsx/dist/clsx.mjs
2901    function r(e) {
2902      var t2, f, n = "";
2903      if ("string" == typeof e || "number" == typeof e) n += e;
2904      else if ("object" == typeof e) if (Array.isArray(e)) {
2905        var o = e.length;
2906        for (t2 = 0; t2 < o; t2++) e[t2] && (f = r(e[t2])) && (n && (n += " "), n += f);
2907      } else for (f in e) e[f] && (n && (n += " "), n += f);
2908      return n;
2909    }
2910    function clsx() {
2911      for (var e, t2, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t2 = r(e)) && (n && (n += " "), n += t2);
2912      return n;
2913    }
2914    var clsx_default = clsx;
2915  
2916    // packages/commands/build-module/components/command-menu.mjs
2917    var import_data5 = __toESM(require_data(), 1);
2918    var import_element3 = __toESM(require_element(), 1);
2919    var import_i18n = __toESM(require_i18n(), 1);
2920    var import_components = __toESM(require_components(), 1);
2921    var import_keyboard_shortcuts = __toESM(require_keyboard_shortcuts(), 1);
2922    var import_keycodes = __toESM(require_keycodes(), 1);
2923  
2924    // packages/icons/build-module/icon/index.mjs
2925    var import_element = __toESM(require_element(), 1);
2926    var icon_default = (0, import_element.forwardRef)(
2927      ({ icon, size = 24, style, ...props }, ref) => {
2928        const intrinsicStyle = icon.props.style;
2929        const mergedStyle = intrinsicStyle || style ? { ...intrinsicStyle, ...style } : void 0;
2930        return (0, import_element.cloneElement)(icon, {
2931          width: size,
2932          height: size,
2933          ...props,
2934          // Merge styles so the icon's intrinsic style (e.g. `fill: none` on
2935          // stroke-based icons) is preserved unless the consumer overrides
2936          // the same property explicitly.
2937          ...mergedStyle ? { style: mergedStyle } : {},
2938          ref
2939        });
2940      }
2941    );
2942  
2943    // packages/icons/build-module/library/arrow-right.mjs
2944    var import_primitives = __toESM(require_primitives(), 1);
2945    var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
2946    var arrow_right_default = /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_primitives.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_runtime7.jsx)(import_primitives.Path, { d: "M4 12L19 12M14 17L19 12L14 7" }) });
2947  
2948    // packages/icons/build-module/library/search.mjs
2949    var import_primitives2 = __toESM(require_primitives(), 1);
2950    var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
2951    var search_default = /* @__PURE__ */ (0, import_jsx_runtime8.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_runtime8.jsx)(import_primitives2.Path, { d: "M5 19L9.28769 14.7123M18.25 11C18.25 13.8995 15.8995 16.25 13 16.25C10.1005 16.25 7.75 13.8995 7.75 11C7.75 8.10051 10.1005 5.75 13 5.75C15.8995 5.75 18.25 8.10051 18.25 11Z" }) });
2952  
2953    // packages/commands/build-module/store/index.mjs
2954    var import_data3 = __toESM(require_data(), 1);
2955  
2956    // packages/commands/build-module/store/reducer.mjs
2957    var import_data = __toESM(require_data(), 1);
2958    function commands(state = {}, action) {
2959      switch (action.type) {
2960        case "REGISTER_COMMAND":
2961          return {
2962            ...state,
2963            [action.name]: {
2964              name: action.name,
2965              label: action.label,
2966              searchLabel: action.searchLabel,
2967              context: action.context,
2968              category: action.category,
2969              callback: action.callback,
2970              icon: action.icon,
2971              keywords: action.keywords
2972            }
2973          };
2974        case "UNREGISTER_COMMAND": {
2975          const { [action.name]: _, ...remainingState } = state;
2976          return remainingState;
2977        }
2978      }
2979      return state;
2980    }
2981    function commandLoaders(state = {}, action) {
2982      switch (action.type) {
2983        case "REGISTER_COMMAND_LOADER":
2984          return {
2985            ...state,
2986            [action.name]: {
2987              name: action.name,
2988              context: action.context,
2989              category: action.category,
2990              hook: action.hook
2991            }
2992          };
2993        case "UNREGISTER_COMMAND_LOADER": {
2994          const { [action.name]: _, ...remainingState } = state;
2995          return remainingState;
2996        }
2997      }
2998      return state;
2999    }
3000    function isOpen(state = false, action) {
3001      switch (action.type) {
3002        case "OPEN":
3003          return true;
3004        case "CLOSE":
3005          return false;
3006      }
3007      return state;
3008    }
3009    function context(state = "root", action) {
3010      switch (action.type) {
3011        case "SET_CONTEXT":
3012          return action.context;
3013      }
3014      return state;
3015    }
3016    function loaderStates(state = {}, action) {
3017      switch (action.type) {
3018        case "SET_LOADER_LOADING": {
3019          if (action.isLoading) {
3020            return { ...state, [action.name]: true };
3021          }
3022          if (!(action.name in state)) {
3023            return state;
3024          }
3025          const { [action.name]: _, ...remainingState } = state;
3026          return remainingState;
3027        }
3028      }
3029      return state;
3030    }
3031    var reducer = (0, import_data.combineReducers)({
3032      commands,
3033      commandLoaders,
3034      isOpen,
3035      context,
3036      loaderStates
3037    });
3038    var reducer_default = reducer;
3039  
3040    // packages/commands/build-module/store/actions.mjs
3041    var actions_exports = {};
3042    __export(actions_exports, {
3043      close: () => close,
3044      open: () => open,
3045      registerCommand: () => registerCommand,
3046      registerCommandLoader: () => registerCommandLoader,
3047      unregisterCommand: () => unregisterCommand,
3048      unregisterCommandLoader: () => unregisterCommandLoader
3049    });
3050    var REGISTERABLE_CATEGORIES = /* @__PURE__ */ new Set([
3051      "command",
3052      "view",
3053      "edit",
3054      "action"
3055    ]);
3056    function registerCommand(config) {
3057      let { category } = config;
3058      if (!category || !REGISTERABLE_CATEGORIES.has(category)) {
3059        category = "action";
3060      }
3061      return {
3062        type: "REGISTER_COMMAND",
3063        ...config,
3064        category
3065      };
3066    }
3067    function unregisterCommand(name) {
3068      return {
3069        type: "UNREGISTER_COMMAND",
3070        name
3071      };
3072    }
3073    function registerCommandLoader(config) {
3074      let { category } = config;
3075      if (!category || !REGISTERABLE_CATEGORIES.has(category)) {
3076        category = "action";
3077      }
3078      return {
3079        type: "REGISTER_COMMAND_LOADER",
3080        ...config,
3081        category
3082      };
3083    }
3084    function unregisterCommandLoader(name) {
3085      return {
3086        type: "UNREGISTER_COMMAND_LOADER",
3087        name
3088      };
3089    }
3090    function open() {
3091      return {
3092        type: "OPEN"
3093      };
3094    }
3095    function close() {
3096      return {
3097        type: "CLOSE"
3098      };
3099    }
3100  
3101    // packages/commands/build-module/store/selectors.mjs
3102    var selectors_exports = {};
3103    __export(selectors_exports, {
3104      getCommandLoaders: () => getCommandLoaders,
3105      getCommands: () => getCommands,
3106      getContext: () => getContext,
3107      isOpen: () => isOpen2
3108    });
3109    var import_data2 = __toESM(require_data(), 1);
3110    var getCommands = (0, import_data2.createSelector)(
3111      (state, contextual = false) => Object.values(state.commands).filter((command) => {
3112        const isContextual = command.context && command.context === state.context;
3113        return contextual ? isContextual : !isContextual;
3114      }),
3115      (state) => [state.commands, state.context]
3116    );
3117    var getCommandLoaders = (0, import_data2.createSelector)(
3118      (state, contextual = false) => Object.values(state.commandLoaders).filter((loader) => {
3119        const isContextual = loader.context && loader.context === state.context;
3120        return contextual ? isContextual : !isContextual;
3121      }),
3122      (state) => [state.commandLoaders, state.context]
3123    );
3124    function isOpen2(state) {
3125      return state.isOpen;
3126    }
3127    function getContext(state) {
3128      return state.context;
3129    }
3130  
3131    // packages/commands/build-module/store/private-actions.mjs
3132    var private_actions_exports = {};
3133    __export(private_actions_exports, {
3134      setContext: () => setContext,
3135      setLoaderLoading: () => setLoaderLoading
3136    });
3137    function setContext(context2) {
3138      return {
3139        type: "SET_CONTEXT",
3140        context: context2
3141      };
3142    }
3143    function setLoaderLoading(name, isLoading2) {
3144      return {
3145        type: "SET_LOADER_LOADING",
3146        name,
3147        isLoading: isLoading2
3148      };
3149    }
3150  
3151    // packages/commands/build-module/store/private-selectors.mjs
3152    var private_selectors_exports = {};
3153    __export(private_selectors_exports, {
3154      isLoading: () => isLoading
3155    });
3156    function isLoading(state) {
3157      return Object.entries(state.loaderStates).some(
3158        ([name, loading]) => loading && !!state.commandLoaders[name]
3159      );
3160    }
3161  
3162    // packages/commands/build-module/lock-unlock.mjs
3163    var import_private_apis = __toESM(require_private_apis(), 1);
3164    var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
3165      "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
3166      "@wordpress/commands"
3167    );
3168  
3169    // packages/commands/build-module/store/index.mjs
3170    var STORE_NAME = "core/commands";
3171    var store = (0, import_data3.createReduxStore)(STORE_NAME, {
3172      reducer: reducer_default,
3173      actions: actions_exports,
3174      selectors: selectors_exports
3175    });
3176    (0, import_data3.register)(store);
3177    unlock(store).registerPrivateActions(private_actions_exports);
3178    unlock(store).registerPrivateSelectors(private_selectors_exports);
3179  
3180    // packages/commands/build-module/components/use-recent-commands.mjs
3181    var import_data4 = __toESM(require_data(), 1);
3182    var import_preferences = __toESM(require_preferences(), 1);
3183    var import_element2 = __toESM(require_element(), 1);
3184    var MAX_RECENTLY_SAVED = 30;
3185    var MAX_RECENTLY_DISPLAYED = 5;
3186    var EMPTY_ARRAY = [];
3187    var EMPTY_COMMANDS = [];
3188    var EMPTY_SET = /* @__PURE__ */ new Set();
3189    function recordUsage(name) {
3190      const current = (0, import_data4.select)(import_preferences.store).get(
3191        "core/commands",
3192        "recentlyUsed"
3193      ) ?? [];
3194      const next = [name, ...current.filter((n) => n !== name)].slice(
3195        0,
3196        MAX_RECENTLY_SAVED
3197      );
3198      (0, import_data4.dispatch)(import_preferences.store).set("core/commands", "recentlyUsed", next);
3199    }
3200    function useLoaderLoadingState(name, loading) {
3201      const { setLoaderLoading: setLoaderLoading2 } = unlock((0, import_data4.useDispatch)(store));
3202      (0, import_element2.useEffect)(() => {
3203        setLoaderLoading2(name, loading);
3204      }, [setLoaderLoading2, name, loading]);
3205      (0, import_element2.useEffect)(() => {
3206        return () => setLoaderLoading2(name, false);
3207      }, [setLoaderLoading2, name]);
3208    }
3209    function useLoaderCollector(hook, name, filterNames, onResolved) {
3210      const { isLoading: loading, commands: commands2 = EMPTY_COMMANDS } = hook({ search: "" }) ?? {};
3211      useLoaderLoadingState(name, loading);
3212      const filtered = (0, import_element2.useMemo)(
3213        () => filterNames ? commands2.filter((c) => filterNames.has(c.name)) : commands2,
3214        [commands2, filterNames]
3215      );
3216      (0, import_element2.useEffect)(() => {
3217        onResolved(name, filtered);
3218      }, [onResolved, name, filtered]);
3219      (0, import_element2.useEffect)(() => {
3220        return () => onResolved(name, []);
3221      }, [onResolved, name]);
3222    }
3223    function useRecentCommands() {
3224      const {
3225        contextualCommands,
3226        staticCommands,
3227        contextualLoaders,
3228        staticLoaders,
3229        recentlyUsedNames = EMPTY_ARRAY
3230      } = (0, import_data4.useSelect)((select) => {
3231        const { getCommands: getCommands2, getCommandLoaders: getCommandLoaders2 } = select(store);
3232        return {
3233          contextualCommands: getCommands2(true),
3234          staticCommands: getCommands2(false),
3235          contextualLoaders: getCommandLoaders2(true),
3236          staticLoaders: getCommandLoaders2(false),
3237          recentlyUsedNames: select(import_preferences.store).get(
3238            "core/commands",
3239            "recentlyUsed"
3240          )
3241        };
3242      }, []);
3243      const [resolvedMap, setResolvedMap] = (0, import_element2.useState)(
3244        () => /* @__PURE__ */ new Map()
3245      );
3246      const onResolved = (0, import_element2.useCallback)((loaderName, cmds) => {
3247        setResolvedMap((prev) => {
3248          const prevCmds = prev.get(loaderName);
3249          if (prevCmds && prevCmds.length === cmds.length && prevCmds.every((c, i) => c.name === cmds[i].name)) {
3250            return prev;
3251          }
3252          const next = new Map(prev);
3253          next.set(loaderName, cmds);
3254          return next;
3255        });
3256      }, []);
3257      const { recentNames, recentSet } = (0, import_element2.useMemo)(() => {
3258        const names = recentlyUsedNames.slice(0, MAX_RECENTLY_DISPLAYED);
3259        return { recentNames: names, recentSet: new Set(names) };
3260      }, [recentlyUsedNames]);
3261      const loaders = (0, import_element2.useMemo)(
3262        () => [...contextualLoaders, ...staticLoaders],
3263        [contextualLoaders, staticLoaders]
3264      );
3265      const commands2 = (0, import_element2.useMemo)(() => {
3266        const allByName = /* @__PURE__ */ new Map();
3267        [...contextualCommands, ...staticCommands].forEach(
3268          (c) => allByName.set(c.name, c)
3269        );
3270        for (const cmds of resolvedMap.values()) {
3271          cmds.forEach((c) => {
3272            if (!allByName.has(c.name)) {
3273              allByName.set(c.name, c);
3274            }
3275          });
3276        }
3277        return recentNames.map((n) => allByName.get(n)).filter((c) => !!c);
3278      }, [contextualCommands, staticCommands, resolvedMap, recentNames]);
3279      if (!recentlyUsedNames.length) {
3280        return {
3281          commands: EMPTY_COMMANDS,
3282          loaders: [],
3283          recentSet: EMPTY_SET,
3284          onResolved
3285        };
3286      }
3287      return { commands: commands2, loaders, recentSet, onResolved };
3288    }
3289  
3290    // packages/commands/build-module/components/command-menu.mjs
3291    var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
3292    var ITEM_ID_PREFIX = "command-palette-item-";
3293    var inputLabel = (0, import_i18n.__)("Search commands and settings");
3294    var CATEGORY_FALLBACK_ICONS = {
3295      view: arrow_right_default
3296    };
3297    var CATEGORY_LABELS = {
3298      command: (0, import_i18n.__)("Command"),
3299      view: (0, import_i18n.__)("View"),
3300      edit: (0, import_i18n.__)("Edit"),
3301      action: (0, import_i18n.__)("Action"),
3302      workflow: (0, import_i18n.__)("Workflow")
3303    };
3304    function isValidIcon(icon) {
3305      return typeof icon === "string" && icon !== "" || typeof icon === "function" || (0, import_element3.isValidElement)(icon);
3306    }
3307    function CommandItem({
3308      command,
3309      search,
3310      category,
3311      valuePrefix
3312    }) {
3313      const { close: close2 } = (0, import_data5.useDispatch)(store);
3314      const commandCategory = category ?? command.category;
3315      const categoryLabel = commandCategory ? CATEGORY_LABELS[commandCategory] : void 0;
3316      const fallbackIcon = commandCategory ? CATEGORY_FALLBACK_ICONS[commandCategory] : void 0;
3317      const icon = isValidIcon(command.icon) ? command.icon : fallbackIcon;
3318      const label = command.searchLabel ?? command.label;
3319      const value = valuePrefix ? `$valuePrefix}$command.name}` : label;
3320      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3321        _e.Item,
3322        {
3323          id: `$ITEM_ID_PREFIX}$value.toLowerCase()}`,
3324          value,
3325          keywords: valuePrefix ? [...command.keywords ?? [], label] : command.keywords,
3326          onSelect: () => {
3327            recordUsage(command.name);
3328            command.callback({ close: close2 });
3329          },
3330          children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(
3331            import_components.__experimentalHStack,
3332            {
3333              alignment: "left",
3334              className: clsx_default("commands-command-menu__item", {
3335                "has-icon": !!icon
3336              }),
3337              children: [
3338                icon && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_components.Icon, { icon, size: 24 }),
3339                /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "commands-command-menu__item-label", children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3340                  import_components.TextHighlight,
3341                  {
3342                    text: command.label,
3343                    highlight: search
3344                  }
3345                ) }),
3346                categoryLabel && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { className: "commands-command-menu__item-category", children: categoryLabel })
3347              ]
3348            }
3349          )
3350        },
3351        command.name
3352      );
3353    }
3354    function CommandMenuLoader({
3355      name,
3356      search,
3357      hook,
3358      category,
3359      valuePrefix
3360    }) {
3361      const { isLoading: loading, commands: commands2 = [] } = hook({ search }) ?? {};
3362      useLoaderLoadingState(name, loading);
3363      if (!commands2.length) {
3364        return null;
3365      }
3366      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_jsx_runtime9.Fragment, { children: commands2.map((command) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3367        CommandItem,
3368        {
3369          command,
3370          search,
3371          category: command.category ?? category,
3372          valuePrefix
3373        },
3374        command.name
3375      )) });
3376    }
3377    function CommandMenuLoaderWrapper({
3378      hook,
3379      ...props
3380    }) {
3381      const currentLoaderRef = (0, import_element3.useRef)(hook);
3382      const [key, setKey] = (0, import_element3.useState)(0);
3383      (0, import_element3.useEffect)(() => {
3384        if (currentLoaderRef.current !== hook) {
3385          currentLoaderRef.current = hook;
3386          setKey((prevKey) => prevKey + 1);
3387        }
3388      }, [hook]);
3389      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3390        CommandMenuLoader,
3391        {
3392          hook: currentLoaderRef.current,
3393          ...props
3394        },
3395        key
3396      );
3397    }
3398    function CommandList({
3399      search,
3400      commands: commands2,
3401      loaders,
3402      valuePrefix
3403    }) {
3404      return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
3405        commands2.map((command) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3406          CommandItem,
3407          {
3408            command,
3409            search,
3410            valuePrefix
3411          },
3412          command.name
3413        )),
3414        loaders.map((loader) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3415          CommandMenuLoaderWrapper,
3416          {
3417            name: loader.name,
3418            search,
3419            hook: loader.hook,
3420            category: loader.category,
3421            valuePrefix
3422          },
3423          loader.name
3424        ))
3425      ] });
3426    }
3427    function RecentLoaderRunner({
3428      hook,
3429      name,
3430      filterNames,
3431      onResolved
3432    }) {
3433      useLoaderCollector(hook, name, filterNames, onResolved);
3434      return null;
3435    }
3436    function RecentGroup() {
3437      const { commands: commands2, loaders, recentSet, onResolved } = useRecentCommands();
3438      if (!commands2.length && !loaders.length) {
3439        return null;
3440      }
3441      return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(_e.Group, { heading: (0, import_i18n.__)("Recent"), children: [
3442        loaders.map((loader) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3443          RecentLoaderRunner,
3444          {
3445            name: loader.name,
3446            hook: loader.hook,
3447            filterNames: recentSet,
3448            onResolved
3449          },
3450          loader.name
3451        )),
3452        commands2.map((command) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3453          CommandItem,
3454          {
3455            command,
3456            search: "",
3457            valuePrefix: "recent-"
3458          },
3459          command.name
3460        ))
3461      ] });
3462    }
3463    function SuggestionsGroup() {
3464      const { commands: commands2, loaders } = (0, import_data5.useSelect)((select) => {
3465        const { getCommands: getCommands2, getCommandLoaders: getCommandLoaders2 } = select(store);
3466        return {
3467          commands: getCommands2(true),
3468          loaders: getCommandLoaders2(true)
3469        };
3470      }, []);
3471      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(_e.Group, { heading: (0, import_i18n.__)("Suggestions"), children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(CommandList, { search: "", commands: commands2, loaders }) });
3472    }
3473    function ResultsGroup({ search }) {
3474      const { commands: commands2, contextualCommands, loaders, contextualLoaders } = (0, import_data5.useSelect)((select) => {
3475        const { getCommands: getCommands2, getCommandLoaders: getCommandLoaders2 } = select(store);
3476        return {
3477          commands: getCommands2(false),
3478          contextualCommands: getCommands2(true),
3479          loaders: getCommandLoaders2(false),
3480          contextualLoaders: getCommandLoaders2(true)
3481        };
3482      }, []);
3483      return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(_e.Group, { heading: (0, import_i18n.__)("Results"), children: [
3484        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3485          CommandList,
3486          {
3487            search,
3488            commands: commands2,
3489            loaders
3490          }
3491        ),
3492        /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3493          CommandList,
3494          {
3495            search,
3496            commands: contextualCommands,
3497            loaders: contextualLoaders
3498          }
3499        )
3500      ] });
3501    }
3502    function CommandInput({ search, setSearch }) {
3503      const commandMenuInput = (0, import_element3.useRef)(null);
3504      const _value = P((state) => state.value);
3505      const selectedItemId = _value ? `$ITEM_ID_PREFIX}$_value}` : null;
3506      (0, import_element3.useEffect)(() => {
3507        commandMenuInput.current.focus();
3508      }, []);
3509      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3510        _e.Input,
3511        {
3512          ref: commandMenuInput,
3513          value: search,
3514          onValueChange: setSearch,
3515          placeholder: inputLabel,
3516          "aria-activedescendant": selectedItemId ?? void 0
3517        }
3518      );
3519    }
3520    function CommandMenu() {
3521      const { registerShortcut } = (0, import_data5.useDispatch)(import_keyboard_shortcuts.store);
3522      const [search, setSearch] = (0, import_element3.useState)("");
3523      const { isOpen: paletteIsOpen, loadersLoading } = (0, import_data5.useSelect)(
3524        (select) => ({
3525          isOpen: select(store).isOpen(),
3526          loadersLoading: unlock(select(store)).isLoading()
3527        }),
3528        []
3529      );
3530      const { open: open2, close: close2 } = (0, import_data5.useDispatch)(store);
3531      (0, import_element3.useEffect)(() => {
3532        registerShortcut({
3533          name: "core/commands",
3534          category: "global",
3535          description: (0, import_i18n.__)("Open the command palette."),
3536          keyCombination: {
3537            modifier: "primary",
3538            character: "k"
3539          }
3540        });
3541      }, [registerShortcut]);
3542      (0, import_keyboard_shortcuts.useShortcut)(
3543        "core/commands",
3544        (0, import_keycodes.withIgnoreIMEEvents)((event) => {
3545          if (event.defaultPrevented) {
3546            return;
3547          }
3548          event.preventDefault();
3549          if (paletteIsOpen) {
3550            close2();
3551          } else {
3552            open2();
3553          }
3554        })
3555      );
3556      const closeAndReset = () => {
3557        setSearch("");
3558        close2();
3559      };
3560      if (!paletteIsOpen) {
3561        return null;
3562      }
3563      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3564        import_components.Modal,
3565        {
3566          className: "commands-command-menu",
3567          overlayClassName: "commands-command-menu__overlay",
3568          onRequestClose: closeAndReset,
3569          __experimentalHideHeader: true,
3570          size: "medium",
3571          contentLabel: (0, import_i18n.__)("Command palette"),
3572          children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("div", { className: "commands-command-menu__container", children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(_e, { label: inputLabel, loop: true, children: [
3573            /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)("div", { className: "commands-command-menu__header", children: [
3574              /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3575                icon_default,
3576                {
3577                  className: "commands-command-menu__header-search-icon",
3578                  icon: search_default
3579                }
3580              ),
3581              /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
3582                CommandInput,
3583                {
3584                  search,
3585                  setSearch
3586                }
3587              )
3588            ] }),
3589            /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(_e.List, { label: (0, import_i18n.__)("Command suggestions"), children: [
3590              search && !loadersLoading && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(_e.Empty, { children: (0, import_i18n.__)("No results found.") }),
3591              !search && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(RecentGroup, {}),
3592              !search && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(SuggestionsGroup, {}),
3593              search && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(ResultsGroup, { search })
3594            ] })
3595          ] }) })
3596        }
3597      );
3598    }
3599  
3600    // packages/commands/build-module/hooks/use-command-context.mjs
3601    var import_element4 = __toESM(require_element(), 1);
3602    var import_data6 = __toESM(require_data(), 1);
3603    function useCommandContext(context2) {
3604      const { getContext: getContext2 } = (0, import_data6.useSelect)(store);
3605      const initialContext = (0, import_element4.useRef)(getContext2());
3606      const { setContext: setContext2 } = unlock((0, import_data6.useDispatch)(store));
3607      (0, import_element4.useEffect)(() => {
3608        setContext2(context2);
3609      }, [context2, setContext2]);
3610      (0, import_element4.useEffect)(() => {
3611        const initialContextRef = initialContext.current;
3612        return () => setContext2(initialContextRef);
3613      }, [setContext2]);
3614    }
3615  
3616    // packages/commands/build-module/private-apis.mjs
3617    var privateApis = {};
3618    lock(privateApis, {
3619      useCommandContext
3620    });
3621  
3622    // packages/commands/build-module/hooks/use-command.mjs
3623    var import_element5 = __toESM(require_element(), 1);
3624    var import_data7 = __toESM(require_data(), 1);
3625    function useCommand(command) {
3626      const { registerCommand: registerCommand2, unregisterCommand: unregisterCommand2 } = (0, import_data7.useDispatch)(store);
3627      const currentCallbackRef = (0, import_element5.useRef)(command.callback);
3628      (0, import_element5.useEffect)(() => {
3629        currentCallbackRef.current = command.callback;
3630      }, [command.callback]);
3631      (0, import_element5.useEffect)(() => {
3632        if (command.disabled) {
3633          return;
3634        }
3635        registerCommand2({
3636          name: command.name,
3637          context: command.context,
3638          category: command.category,
3639          label: command.label,
3640          searchLabel: command.searchLabel,
3641          icon: command.icon,
3642          keywords: command.keywords,
3643          callback: (...args) => currentCallbackRef.current(...args)
3644        });
3645        return () => {
3646          unregisterCommand2(command.name);
3647        };
3648      }, [
3649        command.name,
3650        command.label,
3651        command.searchLabel,
3652        command.icon,
3653        command.context,
3654        command.category,
3655        command.keywords,
3656        command.disabled,
3657        registerCommand2,
3658        unregisterCommand2
3659      ]);
3660    }
3661    function useCommands(commands2) {
3662      const { registerCommand: registerCommand2, unregisterCommand: unregisterCommand2 } = (0, import_data7.useDispatch)(store);
3663      const currentCallbacksRef = (0, import_element5.useRef)({});
3664      (0, import_element5.useEffect)(() => {
3665        if (!commands2) {
3666          return;
3667        }
3668        commands2.forEach((command) => {
3669          if (command.callback) {
3670            currentCallbacksRef.current[command.name] = command.callback;
3671          }
3672        });
3673      }, [commands2]);
3674      (0, import_element5.useEffect)(() => {
3675        if (!commands2) {
3676          return;
3677        }
3678        commands2.forEach((command) => {
3679          if (command.disabled) {
3680            return;
3681          }
3682          registerCommand2({
3683            name: command.name,
3684            context: command.context,
3685            category: command.category,
3686            label: command.label,
3687            searchLabel: command.searchLabel,
3688            icon: command.icon,
3689            keywords: command.keywords,
3690            callback: (...args) => {
3691              const callback = currentCallbacksRef.current[command.name];
3692              if (callback) {
3693                callback(...args);
3694              }
3695            }
3696          });
3697        });
3698        return () => {
3699          commands2.forEach((command) => {
3700            unregisterCommand2(command.name);
3701          });
3702        };
3703      }, [commands2, registerCommand2, unregisterCommand2]);
3704    }
3705  
3706    // packages/commands/build-module/hooks/use-command-loader.mjs
3707    var import_element6 = __toESM(require_element(), 1);
3708    var import_data8 = __toESM(require_data(), 1);
3709    function useCommandLoader(loader) {
3710      const { registerCommandLoader: registerCommandLoader2, unregisterCommandLoader: unregisterCommandLoader2 } = (0, import_data8.useDispatch)(store);
3711      const currentHookRef = (0, import_element6.useRef)(loader.hook);
3712      (0, import_element6.useEffect)(() => {
3713        currentHookRef.current = loader.hook;
3714      }, [loader.hook]);
3715      const hook = (0, import_element6.useCallback)(
3716        (...args) => currentHookRef.current(...args),
3717        []
3718      );
3719      (0, import_element6.useEffect)(() => {
3720        if (loader.disabled) {
3721          return;
3722        }
3723        registerCommandLoader2({
3724          name: loader.name,
3725          hook,
3726          context: loader.context,
3727          category: loader.category
3728        });
3729        return () => {
3730          unregisterCommandLoader2(loader.name);
3731        };
3732      }, [
3733        loader.name,
3734        hook,
3735        loader.context,
3736        loader.category,
3737        loader.disabled,
3738        registerCommandLoader2,
3739        unregisterCommandLoader2
3740      ]);
3741    }
3742    return __toCommonJS(index_exports);
3743  })();
3744  (window.wp ||= {}).commands = wp.commands;
3745  })();