[Summary view] [Print] [Text view]

   1  (function() {
   2  var wp;
   3  (wp ||= {}).editPost = (() => {
   4    var __create = Object.create;
   5    var __defProp = Object.defineProperty;
   6    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   7    var __getOwnPropNames = Object.getOwnPropertyNames;
   8    var __getProtoOf = Object.getPrototypeOf;
   9    var __hasOwnProp = Object.prototype.hasOwnProperty;
  10    var __commonJS = (cb, mod) => function __require() {
  11      return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  12    };
  13    var __export = (target, all) => {
  14      for (var name in all)
  15        __defProp(target, name, { get: all[name], enumerable: true });
  16    };
  17    var __copyProps = (to, from, except, desc) => {
  18      if (from && typeof from === "object" || typeof from === "function") {
  19        for (let key of __getOwnPropNames(from))
  20          if (!__hasOwnProp.call(to, key) && key !== except)
  21            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  22      }
  23      return to;
  24    };
  25    var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  26      // If the importer is in node compatibility mode or this is not an ESM
  27      // file that has been converted to a CommonJS file using a Babel-
  28      // compatible transform (i.e. "__esModule" has not been set), then set
  29      // "default" to the CommonJS "module.exports" for node compatibility.
  30      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  31      mod
  32    ));
  33    var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
  34  
  35    // package-external:@wordpress/blocks
  36    var require_blocks = __commonJS({
  37      "package-external:@wordpress/blocks"(exports, module) {
  38        module.exports = window.wp.blocks;
  39      }
  40    });
  41  
  42    // package-external:@wordpress/block-library
  43    var require_block_library = __commonJS({
  44      "package-external:@wordpress/block-library"(exports, module) {
  45        module.exports = window.wp.blockLibrary;
  46      }
  47    });
  48  
  49    // package-external:@wordpress/deprecated
  50    var require_deprecated = __commonJS({
  51      "package-external:@wordpress/deprecated"(exports, module) {
  52        module.exports = window.wp.deprecated;
  53      }
  54    });
  55  
  56    // package-external:@wordpress/element
  57    var require_element = __commonJS({
  58      "package-external:@wordpress/element"(exports, module) {
  59        module.exports = window.wp.element;
  60      }
  61    });
  62  
  63    // package-external:@wordpress/data
  64    var require_data = __commonJS({
  65      "package-external:@wordpress/data"(exports, module) {
  66        module.exports = window.wp.data;
  67      }
  68    });
  69  
  70    // package-external:@wordpress/preferences
  71    var require_preferences = __commonJS({
  72      "package-external:@wordpress/preferences"(exports, module) {
  73        module.exports = window.wp.preferences;
  74      }
  75    });
  76  
  77    // package-external:@wordpress/widgets
  78    var require_widgets = __commonJS({
  79      "package-external:@wordpress/widgets"(exports, module) {
  80        module.exports = window.wp.widgets;
  81      }
  82    });
  83  
  84    // package-external:@wordpress/editor
  85    var require_editor = __commonJS({
  86      "package-external:@wordpress/editor"(exports, module) {
  87        module.exports = window.wp.editor;
  88      }
  89    });
  90  
  91    // package-external:@wordpress/core-data
  92    var require_core_data = __commonJS({
  93      "package-external:@wordpress/core-data"(exports, module) {
  94        module.exports = window.wp.coreData;
  95      }
  96    });
  97  
  98    // package-external:@wordpress/api-fetch
  99    var require_api_fetch = __commonJS({
 100      "package-external:@wordpress/api-fetch"(exports, module) {
 101        module.exports = window.wp.apiFetch;
 102      }
 103    });
 104  
 105    // package-external:@wordpress/i18n
 106    var require_i18n = __commonJS({
 107      "package-external:@wordpress/i18n"(exports, module) {
 108        module.exports = window.wp.i18n;
 109      }
 110    });
 111  
 112    // vendor-external:react
 113    var require_react = __commonJS({
 114      "vendor-external:react"(exports, module) {
 115        module.exports = window.React;
 116      }
 117    });
 118  
 119    // vendor-external:react/jsx-runtime
 120    var require_jsx_runtime = __commonJS({
 121      "vendor-external:react/jsx-runtime"(exports, module) {
 122        module.exports = window.ReactJSXRuntime;
 123      }
 124    });
 125  
 126    // vendor-external:react-dom
 127    var require_react_dom = __commonJS({
 128      "vendor-external:react-dom"(exports, module) {
 129        module.exports = window.ReactDOM;
 130      }
 131    });
 132  
 133    // node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
 134    var require_use_sync_external_store_shim_development = __commonJS({
 135      "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
 136        "use strict";
 137        (function() {
 138          function is(x, y) {
 139            return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
 140          }
 141          function useSyncExternalStore$2(subscribe, getSnapshot) {
 142            didWarnOld18Alpha || void 0 === React48.startTransition || (didWarnOld18Alpha = true, console.error(
 143              "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
 144            ));
 145            var value = getSnapshot();
 146            if (!didWarnUncachedGetSnapshot) {
 147              var cachedValue = getSnapshot();
 148              objectIs(value, cachedValue) || (console.error(
 149                "The result of getSnapshot should be cached to avoid an infinite loop"
 150              ), didWarnUncachedGetSnapshot = true);
 151            }
 152            cachedValue = useState16({
 153              inst: { value, getSnapshot }
 154            });
 155            var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
 156            useLayoutEffect4(
 157              function() {
 158                inst.value = value;
 159                inst.getSnapshot = getSnapshot;
 160                checkIfSnapshotChanged(inst) && forceUpdate({ inst });
 161              },
 162              [subscribe, value, getSnapshot]
 163            );
 164            useEffect17(
 165              function() {
 166                checkIfSnapshotChanged(inst) && forceUpdate({ inst });
 167                return subscribe(function() {
 168                  checkIfSnapshotChanged(inst) && forceUpdate({ inst });
 169                });
 170              },
 171              [subscribe]
 172            );
 173            useDebugValue2(value);
 174            return value;
 175          }
 176          function checkIfSnapshotChanged(inst) {
 177            var latestGetSnapshot = inst.getSnapshot;
 178            inst = inst.value;
 179            try {
 180              var nextValue = latestGetSnapshot();
 181              return !objectIs(inst, nextValue);
 182            } catch (error) {
 183              return true;
 184            }
 185          }
 186          function useSyncExternalStore$1(subscribe, getSnapshot) {
 187            return getSnapshot();
 188          }
 189          "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
 190          var React48 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState16 = React48.useState, useEffect17 = React48.useEffect, useLayoutEffect4 = React48.useLayoutEffect, useDebugValue2 = React48.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
 191          exports.useSyncExternalStore = void 0 !== React48.useSyncExternalStore ? React48.useSyncExternalStore : shim;
 192          "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
 193        })();
 194      }
 195    });
 196  
 197    // node_modules/use-sync-external-store/shim/index.js
 198    var require_shim = __commonJS({
 199      "node_modules/use-sync-external-store/shim/index.js"(exports, module) {
 200        "use strict";
 201        if (false) {
 202          module.exports = null;
 203        } else {
 204          module.exports = require_use_sync_external_store_shim_development();
 205        }
 206      }
 207    });
 208  
 209    // node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js
 210    var require_with_selector_development = __commonJS({
 211      "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js"(exports) {
 212        "use strict";
 213        (function() {
 214          function is(x, y) {
 215            return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
 216          }
 217          "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
 218          var React48 = require_react(), shim = require_shim(), objectIs = "function" === typeof Object.is ? Object.is : is, useSyncExternalStore3 = shim.useSyncExternalStore, useRef22 = React48.useRef, useEffect17 = React48.useEffect, useMemo17 = React48.useMemo, useDebugValue2 = React48.useDebugValue;
 219          exports.useSyncExternalStoreWithSelector = function(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
 220            var instRef = useRef22(null);
 221            if (null === instRef.current) {
 222              var inst = { hasValue: false, value: null };
 223              instRef.current = inst;
 224            } else inst = instRef.current;
 225            instRef = useMemo17(
 226              function() {
 227                function memoizedSelector(nextSnapshot) {
 228                  if (!hasMemo) {
 229                    hasMemo = true;
 230                    memoizedSnapshot = nextSnapshot;
 231                    nextSnapshot = selector(nextSnapshot);
 232                    if (void 0 !== isEqual && inst.hasValue) {
 233                      var currentSelection = inst.value;
 234                      if (isEqual(currentSelection, nextSnapshot))
 235                        return memoizedSelection = currentSelection;
 236                    }
 237                    return memoizedSelection = nextSnapshot;
 238                  }
 239                  currentSelection = memoizedSelection;
 240                  if (objectIs(memoizedSnapshot, nextSnapshot))
 241                    return currentSelection;
 242                  var nextSelection = selector(nextSnapshot);
 243                  if (void 0 !== isEqual && isEqual(currentSelection, nextSelection))
 244                    return memoizedSnapshot = nextSnapshot, currentSelection;
 245                  memoizedSnapshot = nextSnapshot;
 246                  return memoizedSelection = nextSelection;
 247                }
 248                var hasMemo = false, memoizedSnapshot, memoizedSelection, maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
 249                return [
 250                  function() {
 251                    return memoizedSelector(getSnapshot());
 252                  },
 253                  null === maybeGetServerSnapshot ? void 0 : function() {
 254                    return memoizedSelector(maybeGetServerSnapshot());
 255                  }
 256                ];
 257              },
 258              [getSnapshot, getServerSnapshot, selector, isEqual]
 259            );
 260            var value = useSyncExternalStore3(subscribe, instRef[0], instRef[1]);
 261            useEffect17(
 262              function() {
 263                inst.hasValue = true;
 264                inst.value = value;
 265              },
 266              [value]
 267            );
 268            useDebugValue2(value);
 269            return value;
 270          };
 271          "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
 272        })();
 273      }
 274    });
 275  
 276    // node_modules/use-sync-external-store/shim/with-selector.js
 277    var require_with_selector = __commonJS({
 278      "node_modules/use-sync-external-store/shim/with-selector.js"(exports, module) {
 279        "use strict";
 280        if (false) {
 281          module.exports = null;
 282        } else {
 283          module.exports = require_with_selector_development();
 284        }
 285      }
 286    });
 287  
 288    // package-external:@wordpress/compose
 289    var require_compose = __commonJS({
 290      "package-external:@wordpress/compose"(exports, module) {
 291        module.exports = window.wp.compose;
 292      }
 293    });
 294  
 295    // package-external:@wordpress/theme
 296    var require_theme = __commonJS({
 297      "package-external:@wordpress/theme"(exports, module) {
 298        module.exports = window.wp.theme;
 299      }
 300    });
 301  
 302    // package-external:@wordpress/private-apis
 303    var require_private_apis = __commonJS({
 304      "package-external:@wordpress/private-apis"(exports, module) {
 305        module.exports = window.wp.privateApis;
 306      }
 307    });
 308  
 309    // package-external:@wordpress/primitives
 310    var require_primitives = __commonJS({
 311      "package-external:@wordpress/primitives"(exports, module) {
 312        module.exports = window.wp.primitives;
 313      }
 314    });
 315  
 316    // package-external:@wordpress/components
 317    var require_components = __commonJS({
 318      "package-external:@wordpress/components"(exports, module) {
 319        module.exports = window.wp.components;
 320      }
 321    });
 322  
 323    // package-external:@wordpress/block-editor
 324    var require_block_editor = __commonJS({
 325      "package-external:@wordpress/block-editor"(exports, module) {
 326        module.exports = window.wp.blockEditor;
 327      }
 328    });
 329  
 330    // package-external:@wordpress/style-engine
 331    var require_style_engine = __commonJS({
 332      "package-external:@wordpress/style-engine"(exports, module) {
 333        module.exports = window.wp.styleEngine;
 334      }
 335    });
 336  
 337    // package-external:@wordpress/plugins
 338    var require_plugins = __commonJS({
 339      "package-external:@wordpress/plugins"(exports, module) {
 340        module.exports = window.wp.plugins;
 341      }
 342    });
 343  
 344    // package-external:@wordpress/notices
 345    var require_notices = __commonJS({
 346      "package-external:@wordpress/notices"(exports, module) {
 347        module.exports = window.wp.notices;
 348      }
 349    });
 350  
 351    // package-external:@wordpress/commands
 352    var require_commands = __commonJS({
 353      "package-external:@wordpress/commands"(exports, module) {
 354        module.exports = window.wp.commands;
 355      }
 356    });
 357  
 358    // package-external:@wordpress/url
 359    var require_url = __commonJS({
 360      "package-external:@wordpress/url"(exports, module) {
 361        module.exports = window.wp.url;
 362      }
 363    });
 364  
 365    // package-external:@wordpress/html-entities
 366    var require_html_entities = __commonJS({
 367      "package-external:@wordpress/html-entities"(exports, module) {
 368        module.exports = window.wp.htmlEntities;
 369      }
 370    });
 371  
 372    // package-external:@wordpress/keyboard-shortcuts
 373    var require_keyboard_shortcuts = __commonJS({
 374      "package-external:@wordpress/keyboard-shortcuts"(exports, module) {
 375        module.exports = window.wp.keyboardShortcuts;
 376      }
 377    });
 378  
 379    // package-external:@wordpress/hooks
 380    var require_hooks = __commonJS({
 381      "package-external:@wordpress/hooks"(exports, module) {
 382        module.exports = window.wp.hooks;
 383      }
 384    });
 385  
 386    // package-external:@wordpress/keycodes
 387    var require_keycodes = __commonJS({
 388      "package-external:@wordpress/keycodes"(exports, module) {
 389        module.exports = window.wp.keycodes;
 390      }
 391    });
 392  
 393    // packages/edit-post/build-module/index.mjs
 394    var index_exports = {};
 395    __export(index_exports, {
 396      PluginBlockSettingsMenuItem: () => PluginBlockSettingsMenuItem,
 397      PluginDocumentSettingPanel: () => PluginDocumentSettingPanel,
 398      PluginMoreMenuItem: () => PluginMoreMenuItem,
 399      PluginPostPublishPanel: () => PluginPostPublishPanel,
 400      PluginPostStatusInfo: () => PluginPostStatusInfo,
 401      PluginPrePublishPanel: () => PluginPrePublishPanel,
 402      PluginSidebar: () => PluginSidebar,
 403      PluginSidebarMoreMenuItem: () => PluginSidebarMoreMenuItem,
 404      __experimentalFullscreenModeClose: () => fullscreen_mode_close_default,
 405      __experimentalMainDashboardButton: () => __experimentalMainDashboardButton,
 406      __experimentalPluginPostExcerpt: () => __experimentalPluginPostExcerpt,
 407      initializeEditor: () => initializeEditor,
 408      reinitializeEditor: () => reinitializeEditor,
 409      store: () => store
 410    });
 411    var import_blocks2 = __toESM(require_blocks(), 1);
 412    var import_block_library = __toESM(require_block_library(), 1);
 413    var import_deprecated4 = __toESM(require_deprecated(), 1);
 414    var import_element30 = __toESM(require_element(), 1);
 415    var import_data27 = __toESM(require_data(), 1);
 416    var import_preferences11 = __toESM(require_preferences(), 1);
 417    var import_widgets = __toESM(require_widgets(), 1);
 418    var import_editor21 = __toESM(require_editor(), 1);
 419    var import_core_data10 = __toESM(require_core_data(), 1);
 420    var import_api_fetch2 = __toESM(require_api_fetch(), 1);
 421  
 422    // node_modules/clsx/dist/clsx.mjs
 423    function r(e) {
 424      var t, f, n = "";
 425      if ("string" == typeof e || "number" == typeof e) n += e;
 426      else if ("object" == typeof e) if (Array.isArray(e)) {
 427        var o = e.length;
 428        for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
 429      } else for (f in e) e[f] && (n && (n += " "), n += f);
 430      return n;
 431    }
 432    function clsx() {
 433      for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
 434      return n;
 435    }
 436    var clsx_default = clsx;
 437  
 438    // node_modules/@base-ui/utils/safeReact.mjs
 439    var React = __toESM(require_react(), 1);
 440    var SafeReact = {
 441      ...React
 442    };
 443  
 444    // node_modules/@base-ui/utils/useRefWithInit.mjs
 445    var React2 = __toESM(require_react(), 1);
 446    var UNINITIALIZED = {};
 447    function useRefWithInit(init, initArg) {
 448      const ref = React2.useRef(UNINITIALIZED);
 449      if (ref.current === UNINITIALIZED) {
 450        ref.current = init(initArg);
 451      }
 452      return ref;
 453    }
 454  
 455    // node_modules/@base-ui/utils/useStableCallback.mjs
 456    var useInsertionEffect = SafeReact.useInsertionEffect;
 457    var useSafeInsertionEffect = (
 458      // React 17 doesn't have useInsertionEffect.
 459      useInsertionEffect && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
 460      useInsertionEffect !== SafeReact.useLayoutEffect ? useInsertionEffect : (fn) => fn()
 461    );
 462    function useStableCallback(callback) {
 463      const stable = useRefWithInit(createStableCallback).current;
 464      stable.next = callback;
 465      useSafeInsertionEffect(stable.effect);
 466      return stable.trampoline;
 467    }
 468    function createStableCallback() {
 469      const stable = {
 470        next: void 0,
 471        callback: assertNotCalled,
 472        trampoline: (...args) => stable.callback?.(...args),
 473        effect: () => {
 474          stable.callback = stable.next;
 475        }
 476      };
 477      return stable;
 478    }
 479    function assertNotCalled() {
 480      if (true) {
 481        throw (
 482          /* minify-error-disabled */
 483          new Error("Base UI: Cannot call an event handler while rendering.")
 484        );
 485      }
 486    }
 487  
 488    // node_modules/@base-ui/utils/warn.mjs
 489    var set;
 490    if (true) {
 491      set = /* @__PURE__ */ new Set();
 492    }
 493    function warn(...messages) {
 494      if (true) {
 495        const messageKey = messages.join(" ");
 496        if (!set.has(messageKey)) {
 497          set.add(messageKey);
 498          console.warn(`Base UI: $messageKey}`);
 499        }
 500      }
 501    }
 502  
 503    // node_modules/@base-ui/utils/useIsoLayoutEffect.mjs
 504    var React3 = __toESM(require_react(), 1);
 505    var noop = () => {
 506    };
 507    var useIsoLayoutEffect = typeof document !== "undefined" ? React3.useLayoutEffect : noop;
 508  
 509    // node_modules/@base-ui/react/internals/useRenderElement.mjs
 510    var React6 = __toESM(require_react(), 1);
 511  
 512    // node_modules/@base-ui/utils/useMergedRefs.mjs
 513    function useMergedRefs(a, b, c, d) {
 514      const forkRef = useRefWithInit(createForkRef).current;
 515      if (didChange(forkRef, a, b, c, d)) {
 516        update(forkRef, [a, b, c, d]);
 517      }
 518      return forkRef.callback;
 519    }
 520    function useMergedRefsN(refs) {
 521      const forkRef = useRefWithInit(createForkRef).current;
 522      if (didChangeN(forkRef, refs)) {
 523        update(forkRef, refs);
 524      }
 525      return forkRef.callback;
 526    }
 527    function createForkRef() {
 528      return {
 529        callback: null,
 530        cleanup: null,
 531        refs: []
 532      };
 533    }
 534    function didChange(forkRef, a, b, c, d) {
 535      return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
 536    }
 537    function didChangeN(forkRef, newRefs) {
 538      return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index2) => ref !== newRefs[index2]);
 539    }
 540    function update(forkRef, refs) {
 541      forkRef.refs = refs;
 542      if (refs.every((ref) => ref == null)) {
 543        forkRef.callback = null;
 544        return;
 545      }
 546      forkRef.callback = (instance) => {
 547        if (forkRef.cleanup) {
 548          forkRef.cleanup();
 549          forkRef.cleanup = null;
 550        }
 551        if (instance != null) {
 552          const cleanupCallbacks = Array(refs.length).fill(null);
 553          for (let i = 0; i < refs.length; i += 1) {
 554            const ref = refs[i];
 555            if (ref == null) {
 556              continue;
 557            }
 558            switch (typeof ref) {
 559              case "function": {
 560                const refCleanup = ref(instance);
 561                if (typeof refCleanup === "function") {
 562                  cleanupCallbacks[i] = refCleanup;
 563                }
 564                break;
 565              }
 566              case "object": {
 567                ref.current = instance;
 568                break;
 569              }
 570              default:
 571            }
 572          }
 573          forkRef.cleanup = () => {
 574            for (let i = 0; i < refs.length; i += 1) {
 575              const ref = refs[i];
 576              if (ref == null) {
 577                continue;
 578              }
 579              switch (typeof ref) {
 580                case "function": {
 581                  const cleanupCallback = cleanupCallbacks[i];
 582                  if (typeof cleanupCallback === "function") {
 583                    cleanupCallback();
 584                  } else {
 585                    void ref(null);
 586                  }
 587                  break;
 588                }
 589                case "object": {
 590                  ref.current = null;
 591                  break;
 592                }
 593                default:
 594              }
 595            }
 596          };
 597        }
 598      };
 599    }
 600  
 601    // node_modules/@base-ui/utils/getReactElementRef.mjs
 602    var React5 = __toESM(require_react(), 1);
 603  
 604    // node_modules/@base-ui/utils/reactVersion.mjs
 605    var React4 = __toESM(require_react(), 1);
 606    var majorVersion = parseInt(React4.version, 10);
 607    function isReactVersionAtLeast(reactVersionToCheck) {
 608      return majorVersion >= reactVersionToCheck;
 609    }
 610  
 611    // node_modules/@base-ui/utils/getReactElementRef.mjs
 612    function getReactElementRef(element) {
 613      if (!/* @__PURE__ */ React5.isValidElement(element)) {
 614        return null;
 615      }
 616      const reactElement = element;
 617      const propsWithRef = reactElement.props;
 618      return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
 619    }
 620  
 621    // node_modules/@base-ui/utils/mergeObjects.mjs
 622    function mergeObjects(a, b) {
 623      if (a && !b) {
 624        return a;
 625      }
 626      if (!a && b) {
 627        return b;
 628      }
 629      if (a || b) {
 630        return {
 631          ...a,
 632          ...b
 633        };
 634      }
 635      return void 0;
 636    }
 637  
 638    // node_modules/@base-ui/utils/empty.mjs
 639    function NOOP() {
 640    }
 641    var EMPTY_ARRAY = Object.freeze([]);
 642    var EMPTY_OBJECT = Object.freeze({});
 643  
 644    // node_modules/@base-ui/react/internals/getStateAttributesProps.mjs
 645    function getStateAttributesProps(state, customMapping) {
 646      const props = {};
 647      for (const key in state) {
 648        const value = state[key];
 649        if (customMapping?.hasOwnProperty(key)) {
 650          const customProps = customMapping[key](value);
 651          if (customProps != null) {
 652            Object.assign(props, customProps);
 653          }
 654          continue;
 655        }
 656        if (value === true) {
 657          props[`data-$key.toLowerCase()}`] = "";
 658        } else if (value) {
 659          props[`data-$key.toLowerCase()}`] = value.toString();
 660        }
 661      }
 662      return props;
 663    }
 664  
 665    // node_modules/@base-ui/react/utils/resolveClassName.mjs
 666    function resolveClassName(className, state) {
 667      return typeof className === "function" ? className(state) : className;
 668    }
 669  
 670    // node_modules/@base-ui/react/utils/resolveStyle.mjs
 671    function resolveStyle(style, state) {
 672      return typeof style === "function" ? style(state) : style;
 673    }
 674  
 675    // node_modules/@base-ui/react/merge-props/mergeProps.mjs
 676    var EMPTY_PROPS = {};
 677    function mergeProps(a, b, c, d, e) {
 678      if (!c && !d && !e && !a) {
 679        return createInitialMergedProps(b);
 680      }
 681      let merged = createInitialMergedProps(a);
 682      if (b) {
 683        merged = mergeInto(merged, b);
 684      }
 685      if (c) {
 686        merged = mergeInto(merged, c);
 687      }
 688      if (d) {
 689        merged = mergeInto(merged, d);
 690      }
 691      if (e) {
 692        merged = mergeInto(merged, e);
 693      }
 694      return merged;
 695    }
 696    function mergePropsN(props) {
 697      if (props.length === 0) {
 698        return EMPTY_PROPS;
 699      }
 700      if (props.length === 1) {
 701        return createInitialMergedProps(props[0]);
 702      }
 703      let merged = createInitialMergedProps(props[0]);
 704      for (let i = 1; i < props.length; i += 1) {
 705        merged = mergeInto(merged, props[i]);
 706      }
 707      return merged;
 708    }
 709    function createInitialMergedProps(inputProps) {
 710      if (isPropsGetter(inputProps)) {
 711        return {
 712          ...resolvePropsGetter(inputProps, EMPTY_PROPS)
 713        };
 714      }
 715      return copyInitialProps(inputProps);
 716    }
 717    function mergeInto(merged, inputProps) {
 718      if (isPropsGetter(inputProps)) {
 719        return resolvePropsGetter(inputProps, merged);
 720      }
 721      return mutablyMergeInto(merged, inputProps);
 722    }
 723    function copyInitialProps(inputProps) {
 724      const copiedProps = {
 725        ...inputProps
 726      };
 727      for (const propName in copiedProps) {
 728        const propValue = copiedProps[propName];
 729        if (isEventHandler(propName, propValue)) {
 730          copiedProps[propName] = wrapEventHandler(propValue);
 731        }
 732      }
 733      return copiedProps;
 734    }
 735    function mutablyMergeInto(mergedProps, externalProps) {
 736      if (!externalProps) {
 737        return mergedProps;
 738      }
 739      for (const propName in externalProps) {
 740        const externalPropValue = externalProps[propName];
 741        switch (propName) {
 742          case "style": {
 743            mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
 744            break;
 745          }
 746          case "className": {
 747            mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
 748            break;
 749          }
 750          default: {
 751            if (isEventHandler(propName, externalPropValue)) {
 752              mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
 753            } else {
 754              mergedProps[propName] = externalPropValue;
 755            }
 756          }
 757        }
 758      }
 759      return mergedProps;
 760    }
 761    function isEventHandler(key, value) {
 762      const code0 = key.charCodeAt(0);
 763      const code1 = key.charCodeAt(1);
 764      const code2 = key.charCodeAt(2);
 765      return code0 === 111 && code1 === 110 && code2 >= 65 && code2 <= 90 && (typeof value === "function" || typeof value === "undefined");
 766    }
 767    function isPropsGetter(inputProps) {
 768      return typeof inputProps === "function";
 769    }
 770    function resolvePropsGetter(inputProps, previousProps) {
 771      if (isPropsGetter(inputProps)) {
 772        return inputProps(previousProps);
 773      }
 774      return inputProps ?? EMPTY_PROPS;
 775    }
 776    function mergeEventHandlers(ourHandler, theirHandler) {
 777      if (!theirHandler) {
 778        return ourHandler;
 779      }
 780      if (!ourHandler) {
 781        return wrapEventHandler(theirHandler);
 782      }
 783      return (...args) => {
 784        const event = args[0];
 785        if (isSyntheticEvent(event)) {
 786          const baseUIEvent = event;
 787          makeEventPreventable(baseUIEvent);
 788          const result2 = theirHandler(...args);
 789          if (!baseUIEvent.baseUIHandlerPrevented) {
 790            ourHandler?.(...args);
 791          }
 792          return result2;
 793        }
 794        const result = theirHandler(...args);
 795        ourHandler?.(...args);
 796        return result;
 797      };
 798    }
 799    function wrapEventHandler(handler) {
 800      if (!handler) {
 801        return handler;
 802      }
 803      return (...args) => {
 804        const event = args[0];
 805        if (isSyntheticEvent(event)) {
 806          makeEventPreventable(event);
 807        }
 808        return handler(...args);
 809      };
 810    }
 811    function makeEventPreventable(event) {
 812      event.preventBaseUIHandler = () => {
 813        event.baseUIHandlerPrevented = true;
 814      };
 815      return event;
 816    }
 817    function mergeClassNames(ourClassName, theirClassName) {
 818      if (theirClassName) {
 819        if (ourClassName) {
 820          return theirClassName + " " + ourClassName;
 821        }
 822        return theirClassName;
 823      }
 824      return ourClassName;
 825    }
 826    function isSyntheticEvent(event) {
 827      return event != null && typeof event === "object" && "nativeEvent" in event;
 828    }
 829  
 830    // node_modules/@base-ui/react/internals/useRenderElement.mjs
 831    var import_react = __toESM(require_react(), 1);
 832    function useRenderElement(element, componentProps, params = {}) {
 833      const renderProp = componentProps.render;
 834      const outProps = useRenderElementProps(componentProps, params);
 835      if (params.enabled === false) {
 836        return null;
 837      }
 838      const state = params.state ?? EMPTY_OBJECT;
 839      return evaluateRenderProp(element, renderProp, outProps, state);
 840    }
 841    function useRenderElementProps(componentProps, params = {}) {
 842      const {
 843        className: classNameProp,
 844        style: styleProp,
 845        render: renderProp
 846      } = componentProps;
 847      const {
 848        state = EMPTY_OBJECT,
 849        ref,
 850        props,
 851        stateAttributesMapping,
 852        enabled = true
 853      } = params;
 854      const className = enabled ? resolveClassName(classNameProp, state) : void 0;
 855      const style = enabled ? resolveStyle(styleProp, state) : void 0;
 856      const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
 857      const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0;
 858      const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
 859      if (typeof document !== "undefined") {
 860        if (!enabled) {
 861          void useMergedRefs(null, null);
 862        } else if (Array.isArray(ref)) {
 863          outProps.ref = useMergedRefsN([outProps.ref, getReactElementRef(renderProp), ...ref]);
 864        } else {
 865          outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
 866        }
 867      }
 868      if (!enabled) {
 869        return EMPTY_OBJECT;
 870      }
 871      if (className !== void 0) {
 872        outProps.className = mergeClassNames(outProps.className, className);
 873      }
 874      if (style !== void 0) {
 875        outProps.style = mergeObjects(outProps.style, style);
 876      }
 877      return outProps;
 878    }
 879    function resolveRenderFunctionProps(props) {
 880      if (Array.isArray(props)) {
 881        return mergePropsN(props);
 882      }
 883      return mergeProps(void 0, props);
 884    }
 885    var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
 886    var COMPONENT_IDENTIFIER_PATTERN = /^[A-Z][A-Za-z0-9$]*$/;
 887    var LOWERCASE_CHARACTER_PATTERN = /[a-z]/;
 888    function evaluateRenderProp(element, render, props, state) {
 889      if (render) {
 890        if (typeof render === "function") {
 891          if (true) {
 892            warnIfRenderPropLooksLikeComponent(render);
 893          }
 894          return render(props, state);
 895        }
 896        const mergedProps = mergeProps(props, render.props);
 897        mergedProps.ref = props.ref;
 898        let newElement = render;
 899        if (newElement?.$$typeof === REACT_LAZY_TYPE) {
 900          const children = React6.Children.toArray(render);
 901          newElement = children[0];
 902        }
 903        if (true) {
 904          if (!/* @__PURE__ */ React6.isValidElement(newElement)) {
 905            throw new Error(["Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.", "A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.", "https://base-ui.com/r/invalid-render-prop"].join("\n"));
 906          }
 907        }
 908        return /* @__PURE__ */ React6.cloneElement(newElement, mergedProps);
 909      }
 910      if (element) {
 911        if (typeof element === "string") {
 912          return renderTag(element, props);
 913        }
 914      }
 915      throw new Error(true ? "Base UI: Render element or function are not defined." : formatErrorMessage_default(8));
 916    }
 917    function warnIfRenderPropLooksLikeComponent(renderFn) {
 918      const functionName = renderFn.name;
 919      if (functionName.length === 0) {
 920        return;
 921      }
 922      if (!COMPONENT_IDENTIFIER_PATTERN.test(functionName)) {
 923        return;
 924      }
 925      if (!LOWERCASE_CHARACTER_PATTERN.test(functionName)) {
 926        return;
 927      }
 928      warn(`The \`render\` prop received a function named \`$functionName}\` that starts with an uppercase letter.`, "This usually means a React component was passed directly as `render={Component}`.", "Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.", "If this is an intentional render callback, rename it to start with a lowercase letter.", "Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.", "https://base-ui.com/r/invalid-render-prop");
 929    }
 930    function renderTag(Tag, props) {
 931      if (Tag === "button") {
 932        return /* @__PURE__ */ (0, import_react.createElement)("button", {
 933          type: "button",
 934          ...props,
 935          key: props.key
 936        });
 937      }
 938      if (Tag === "img") {
 939        return /* @__PURE__ */ (0, import_react.createElement)("img", {
 940          alt: "",
 941          ...props,
 942          key: props.key
 943        });
 944      }
 945      return /* @__PURE__ */ React6.createElement(Tag, props);
 946    }
 947  
 948    // node_modules/@base-ui/utils/useId.mjs
 949    var React7 = __toESM(require_react(), 1);
 950    var globalId = 0;
 951    function useGlobalId(idOverride, prefix = "mui") {
 952      const [defaultId, setDefaultId] = React7.useState(idOverride);
 953      const id = idOverride || defaultId;
 954      React7.useEffect(() => {
 955        if (defaultId == null) {
 956          globalId += 1;
 957          setDefaultId(`$prefix}-$globalId}`);
 958        }
 959      }, [defaultId, prefix]);
 960      return id;
 961    }
 962    var maybeReactUseId = SafeReact.useId;
 963    function useId(idOverride, prefix) {
 964      if (maybeReactUseId !== void 0) {
 965        const reactId = maybeReactUseId();
 966        return idOverride ?? (prefix ? `$prefix}-$reactId}` : reactId);
 967      }
 968      return useGlobalId(idOverride, prefix);
 969    }
 970  
 971    // node_modules/@base-ui/react/internals/useBaseUiId.mjs
 972    function useBaseUiId(idOverride) {
 973      return useId(idOverride, "base-ui");
 974    }
 975  
 976    // node_modules/@base-ui/react/internals/reason-parts.mjs
 977    var reason_parts_exports = {};
 978    __export(reason_parts_exports, {
 979      cancelOpen: () => cancelOpen,
 980      chipRemovePress: () => chipRemovePress,
 981      clearPress: () => clearPress,
 982      closePress: () => closePress,
 983      closeWatcher: () => closeWatcher,
 984      decrementPress: () => decrementPress,
 985      disabled: () => disabled,
 986      drag: () => drag,
 987      escapeKey: () => escapeKey,
 988      focusOut: () => focusOut,
 989      imperativeAction: () => imperativeAction,
 990      incrementPress: () => incrementPress,
 991      initial: () => initial,
 992      inputBlur: () => inputBlur,
 993      inputChange: () => inputChange,
 994      inputClear: () => inputClear,
 995      inputPaste: () => inputPaste,
 996      inputPress: () => inputPress,
 997      itemPress: () => itemPress,
 998      keyboard: () => keyboard,
 999      linkPress: () => linkPress,
1000      listNavigation: () => listNavigation,
1001      missing: () => missing,
1002      none: () => none,
1003      outsidePress: () => outsidePress,
1004      pointer: () => pointer,
1005      scrub: () => scrub,
1006      siblingOpen: () => siblingOpen,
1007      swipe: () => swipe,
1008      trackPress: () => trackPress,
1009      triggerFocus: () => triggerFocus,
1010      triggerHover: () => triggerHover,
1011      triggerPress: () => triggerPress,
1012      wheel: () => wheel,
1013      windowResize: () => windowResize
1014    });
1015    var none = "none";
1016    var triggerPress = "trigger-press";
1017    var triggerHover = "trigger-hover";
1018    var triggerFocus = "trigger-focus";
1019    var outsidePress = "outside-press";
1020    var itemPress = "item-press";
1021    var closePress = "close-press";
1022    var linkPress = "link-press";
1023    var clearPress = "clear-press";
1024    var chipRemovePress = "chip-remove-press";
1025    var trackPress = "track-press";
1026    var incrementPress = "increment-press";
1027    var decrementPress = "decrement-press";
1028    var inputChange = "input-change";
1029    var inputClear = "input-clear";
1030    var inputBlur = "input-blur";
1031    var inputPaste = "input-paste";
1032    var inputPress = "input-press";
1033    var focusOut = "focus-out";
1034    var escapeKey = "escape-key";
1035    var closeWatcher = "close-watcher";
1036    var listNavigation = "list-navigation";
1037    var keyboard = "keyboard";
1038    var pointer = "pointer";
1039    var drag = "drag";
1040    var wheel = "wheel";
1041    var scrub = "scrub";
1042    var cancelOpen = "cancel-open";
1043    var siblingOpen = "sibling-open";
1044    var disabled = "disabled";
1045    var missing = "missing";
1046    var initial = "initial";
1047    var imperativeAction = "imperative-action";
1048    var swipe = "swipe";
1049    var windowResize = "window-resize";
1050  
1051    // node_modules/@base-ui/react/internals/createBaseUIEventDetails.mjs
1052    function createChangeEventDetails(reason, event, trigger, customProperties) {
1053      let canceled = false;
1054      let allowPropagation = false;
1055      const custom = customProperties ?? EMPTY_OBJECT;
1056      const details = {
1057        reason,
1058        event: event ?? new Event("base-ui"),
1059        cancel() {
1060          canceled = true;
1061        },
1062        allowPropagation() {
1063          allowPropagation = true;
1064        },
1065        get isCanceled() {
1066          return canceled;
1067        },
1068        get isPropagationAllowed() {
1069          return allowPropagation;
1070        },
1071        trigger,
1072        ...custom
1073      };
1074      return details;
1075    }
1076  
1077    // node_modules/@base-ui/react/internals/useTransitionStatus.mjs
1078    var React9 = __toESM(require_react(), 1);
1079  
1080    // node_modules/@base-ui/utils/useOnMount.mjs
1081    var React8 = __toESM(require_react(), 1);
1082    function useOnMount(fn) {
1083      React8.useEffect(fn, EMPTY_ARRAY);
1084    }
1085  
1086    // node_modules/@base-ui/utils/useAnimationFrame.mjs
1087    var EMPTY = null;
1088    var LAST_RAF = globalThis.requestAnimationFrame;
1089    var Scheduler = class {
1090      /* This implementation uses an array as a backing data-structure for frame callbacks.
1091       * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
1092       * never calls the native `cancelAnimationFrame` if there are no frames left. This can
1093       * be much more efficient if there is a call pattern that alterns as
1094       * "request-cancel-request-cancel-…".
1095       * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
1096       * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
1097      callbacks = [];
1098      callbacksCount = 0;
1099      nextId = 1;
1100      startId = 1;
1101      isScheduled = false;
1102      tick = (timestamp) => {
1103        this.isScheduled = false;
1104        const currentCallbacks = this.callbacks;
1105        const currentCallbacksCount = this.callbacksCount;
1106        this.callbacks = [];
1107        this.callbacksCount = 0;
1108        this.startId = this.nextId;
1109        if (currentCallbacksCount > 0) {
1110          for (let i = 0; i < currentCallbacks.length; i += 1) {
1111            currentCallbacks[i]?.(timestamp);
1112          }
1113        }
1114      };
1115      request(fn) {
1116        const id = this.nextId;
1117        this.nextId += 1;
1118        this.callbacks.push(fn);
1119        this.callbacksCount += 1;
1120        const didRAFChange = LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);
1121        if (!this.isScheduled || didRAFChange) {
1122          requestAnimationFrame(this.tick);
1123          this.isScheduled = true;
1124        }
1125        return id;
1126      }
1127      cancel(id) {
1128        const index2 = id - this.startId;
1129        if (index2 < 0 || index2 >= this.callbacks.length) {
1130          return;
1131        }
1132        this.callbacks[index2] = null;
1133        this.callbacksCount -= 1;
1134      }
1135    };
1136    var scheduler = new Scheduler();
1137    var AnimationFrame = class _AnimationFrame {
1138      static create() {
1139        return new _AnimationFrame();
1140      }
1141      static request(fn) {
1142        return scheduler.request(fn);
1143      }
1144      static cancel(id) {
1145        return scheduler.cancel(id);
1146      }
1147      currentId = EMPTY;
1148      /**
1149       * Executes `fn` after `delay`, clearing any previously scheduled call.
1150       */
1151      request(fn) {
1152        this.cancel();
1153        this.currentId = scheduler.request(() => {
1154          this.currentId = EMPTY;
1155          fn();
1156        });
1157      }
1158      cancel = () => {
1159        if (this.currentId !== EMPTY) {
1160          scheduler.cancel(this.currentId);
1161          this.currentId = EMPTY;
1162        }
1163      };
1164      disposeEffect = () => {
1165        return this.cancel;
1166      };
1167    };
1168    function useAnimationFrame() {
1169      const timeout = useRefWithInit(AnimationFrame.create).current;
1170      useOnMount(timeout.disposeEffect);
1171      return timeout;
1172    }
1173  
1174    // node_modules/@base-ui/react/internals/useTransitionStatus.mjs
1175    function useTransitionStatus(open, enableIdleState = false, deferEndingState = false) {
1176      const [transitionStatus, setTransitionStatus] = React9.useState(open && enableIdleState ? "idle" : void 0);
1177      const [mounted, setMounted] = React9.useState(open);
1178      if (open && !mounted) {
1179        setMounted(true);
1180        setTransitionStatus("starting");
1181      }
1182      if (!open && mounted && transitionStatus !== "ending" && !deferEndingState) {
1183        setTransitionStatus("ending");
1184      }
1185      if (!open && !mounted && transitionStatus === "ending") {
1186        setTransitionStatus(void 0);
1187      }
1188      useIsoLayoutEffect(() => {
1189        if (!open && mounted && transitionStatus !== "ending" && deferEndingState) {
1190          const frame = AnimationFrame.request(() => {
1191            setTransitionStatus("ending");
1192          });
1193          return () => {
1194            AnimationFrame.cancel(frame);
1195          };
1196        }
1197        return void 0;
1198      }, [open, mounted, transitionStatus, deferEndingState]);
1199      useIsoLayoutEffect(() => {
1200        if (!open || enableIdleState) {
1201          return void 0;
1202        }
1203        const frame = AnimationFrame.request(() => {
1204          setTransitionStatus(void 0);
1205        });
1206        return () => {
1207          AnimationFrame.cancel(frame);
1208        };
1209      }, [enableIdleState, open]);
1210      useIsoLayoutEffect(() => {
1211        if (!open || !enableIdleState) {
1212          return void 0;
1213        }
1214        if (open && mounted && transitionStatus !== "idle") {
1215          setTransitionStatus("starting");
1216        }
1217        const frame = AnimationFrame.request(() => {
1218          setTransitionStatus("idle");
1219        });
1220        return () => {
1221          AnimationFrame.cancel(frame);
1222        };
1223      }, [enableIdleState, open, mounted, transitionStatus]);
1224      return {
1225        mounted,
1226        setMounted,
1227        transitionStatus
1228      };
1229    }
1230  
1231    // node_modules/@base-ui/react/internals/stateAttributesMapping.mjs
1232    var TransitionStatusDataAttributes = /* @__PURE__ */ (function(TransitionStatusDataAttributes2) {
1233      TransitionStatusDataAttributes2["startingStyle"] = "data-starting-style";
1234      TransitionStatusDataAttributes2["endingStyle"] = "data-ending-style";
1235      return TransitionStatusDataAttributes2;
1236    })({});
1237    var STARTING_HOOK = {
1238      "data-starting-style": ""
1239    };
1240    var ENDING_HOOK = {
1241      "data-ending-style": ""
1242    };
1243    var transitionStatusMapping = {
1244      transitionStatus(value) {
1245        if (value === "starting") {
1246          return STARTING_HOOK;
1247        }
1248        if (value === "ending") {
1249          return ENDING_HOOK;
1250        }
1251        return null;
1252      }
1253    };
1254  
1255    // node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
1256    function hasWindow() {
1257      return typeof window !== "undefined";
1258    }
1259    function getNodeName(node) {
1260      if (isNode(node)) {
1261        return (node.nodeName || "").toLowerCase();
1262      }
1263      return "#document";
1264    }
1265    function getWindow(node) {
1266      var _node$ownerDocument;
1267      return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
1268    }
1269    function getDocumentElement(node) {
1270      var _ref;
1271      return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
1272    }
1273    function isNode(value) {
1274      if (!hasWindow()) {
1275        return false;
1276      }
1277      return value instanceof Node || value instanceof getWindow(value).Node;
1278    }
1279    function isElement(value) {
1280      if (!hasWindow()) {
1281        return false;
1282      }
1283      return value instanceof Element || value instanceof getWindow(value).Element;
1284    }
1285    function isHTMLElement(value) {
1286      if (!hasWindow()) {
1287        return false;
1288      }
1289      return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
1290    }
1291    function isShadowRoot(value) {
1292      if (!hasWindow() || typeof ShadowRoot === "undefined") {
1293        return false;
1294      }
1295      return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
1296    }
1297    function isOverflowElement(element) {
1298      const {
1299        overflow,
1300        overflowX,
1301        overflowY,
1302        display
1303      } = getComputedStyle2(element);
1304      return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents";
1305    }
1306    function isTableElement(element) {
1307      return /^(table|td|th)$/.test(getNodeName(element));
1308    }
1309    function isTopLayer(element) {
1310      try {
1311        if (element.matches(":popover-open")) {
1312          return true;
1313        }
1314      } catch (_e) {
1315      }
1316      try {
1317        return element.matches(":modal");
1318      } catch (_e) {
1319        return false;
1320      }
1321    }
1322    var willChangeRe = /transform|translate|scale|rotate|perspective|filter/;
1323    var containRe = /paint|layout|strict|content/;
1324    var isNotNone = (value) => !!value && value !== "none";
1325    var isWebKitValue;
1326    function isContainingBlock(elementOrCss) {
1327      const css = isElement(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
1328      return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || "");
1329    }
1330    function getContainingBlock(element) {
1331      let currentNode = getParentNode(element);
1332      while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
1333        if (isContainingBlock(currentNode)) {
1334          return currentNode;
1335        } else if (isTopLayer(currentNode)) {
1336          return null;
1337        }
1338        currentNode = getParentNode(currentNode);
1339      }
1340      return null;
1341    }
1342    function isWebKit() {
1343      if (isWebKitValue == null) {
1344        isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none");
1345      }
1346      return isWebKitValue;
1347    }
1348    function isLastTraversableNode(node) {
1349      return /^(html|body|#document)$/.test(getNodeName(node));
1350    }
1351    function getComputedStyle2(element) {
1352      return getWindow(element).getComputedStyle(element);
1353    }
1354    function getNodeScroll(element) {
1355      if (isElement(element)) {
1356        return {
1357          scrollLeft: element.scrollLeft,
1358          scrollTop: element.scrollTop
1359        };
1360      }
1361      return {
1362        scrollLeft: element.scrollX,
1363        scrollTop: element.scrollY
1364      };
1365    }
1366    function getParentNode(node) {
1367      if (getNodeName(node) === "html") {
1368        return node;
1369      }
1370      const result = (
1371        // Step into the shadow DOM of the parent of a slotted node.
1372        node.assignedSlot || // DOM Element detected.
1373        node.parentNode || // ShadowRoot detected.
1374        isShadowRoot(node) && node.host || // Fallback.
1375        getDocumentElement(node)
1376      );
1377      return isShadowRoot(result) ? result.host : result;
1378    }
1379    function getNearestOverflowAncestor(node) {
1380      const parentNode = getParentNode(node);
1381      if (isLastTraversableNode(parentNode)) {
1382        return (node.ownerDocument || node).body;
1383      }
1384      if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
1385        return parentNode;
1386      }
1387      return getNearestOverflowAncestor(parentNode);
1388    }
1389    function getOverflowAncestors(node, list, traverseIframes) {
1390      var _node$ownerDocument2;
1391      if (list === void 0) {
1392        list = [];
1393      }
1394      if (traverseIframes === void 0) {
1395        traverseIframes = true;
1396      }
1397      const scrollableAncestor = getNearestOverflowAncestor(node);
1398      const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
1399      const win = getWindow(scrollableAncestor);
1400      if (isBody) {
1401        const frameElement = getFrameElement(win);
1402        return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
1403      } else {
1404        return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
1405      }
1406    }
1407    function getFrameElement(win) {
1408      return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
1409    }
1410  
1411    // node_modules/@base-ui/utils/owner.mjs
1412    function ownerDocument(node) {
1413      return node?.ownerDocument || document;
1414    }
1415  
1416    // node_modules/@base-ui/utils/addEventListener.mjs
1417    function addEventListener(target, type, listener, options) {
1418      target.addEventListener(type, listener, options);
1419      return () => {
1420        target.removeEventListener(type, listener, options);
1421      };
1422    }
1423  
1424    // node_modules/@base-ui/utils/useValueAsRef.mjs
1425    function useValueAsRef(value) {
1426      const latest = useRefWithInit(createLatestRef, value).current;
1427      latest.next = value;
1428      useIsoLayoutEffect(latest.effect);
1429      return latest;
1430    }
1431    function createLatestRef(value) {
1432      const latest = {
1433        current: value,
1434        next: value,
1435        effect: () => {
1436          latest.current = latest.next;
1437        }
1438      };
1439      return latest;
1440    }
1441  
1442    // node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
1443    var React10 = __toESM(require_react(), 1);
1444  
1445    // node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
1446    var ReactDOM = __toESM(require_react_dom(), 1);
1447  
1448    // node_modules/@base-ui/react/utils/resolveRef.mjs
1449    function resolveRef(maybeRef) {
1450      if (maybeRef == null) {
1451        return maybeRef;
1452      }
1453      return "current" in maybeRef ? maybeRef.current : maybeRef;
1454    }
1455  
1456    // node_modules/@base-ui/react/internals/useAnimationsFinished.mjs
1457    function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false) {
1458      const frame = useAnimationFrame();
1459      return useStableCallback((fnToExecute, signal = null) => {
1460        frame.cancel();
1461        const element = resolveRef(elementOrRef);
1462        if (element == null) {
1463          return;
1464        }
1465        const resolvedElement = element;
1466        const done = () => {
1467          ReactDOM.flushSync(fnToExecute);
1468        };
1469        if (typeof resolvedElement.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
1470          fnToExecute();
1471          return;
1472        }
1473        function exec() {
1474          Promise.all(resolvedElement.getAnimations().map((animation) => animation.finished)).then(() => {
1475            if (!signal?.aborted) {
1476              done();
1477            }
1478          }, () => {
1479            if (signal?.aborted) {
1480              return;
1481            }
1482            const currentAnimations = resolvedElement.getAnimations();
1483            if (currentAnimations.some((animation) => animation.pending || animation.playState !== "finished")) {
1484              exec();
1485              return;
1486            }
1487            done();
1488          });
1489        }
1490        if (waitForStartingStyleRemoved) {
1491          const startingStyleAttribute = "data-starting-style";
1492          if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
1493            frame.request(exec);
1494            return;
1495          }
1496          const attributeObserver = new MutationObserver(() => {
1497            if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
1498              attributeObserver.disconnect();
1499              exec();
1500            }
1501          });
1502          attributeObserver.observe(resolvedElement, {
1503            attributes: true,
1504            attributeFilter: [startingStyleAttribute]
1505          });
1506          signal?.addEventListener("abort", () => attributeObserver.disconnect(), {
1507            once: true
1508          });
1509          return;
1510        }
1511        frame.request(exec);
1512      });
1513    }
1514  
1515    // node_modules/@base-ui/react/internals/useOpenChangeComplete.mjs
1516    function useOpenChangeComplete(parameters) {
1517      const {
1518        enabled = true,
1519        open,
1520        ref,
1521        onComplete: onCompleteParam
1522      } = parameters;
1523      const onComplete = useStableCallback(onCompleteParam);
1524      const runOnceAnimationsFinish = useAnimationsFinished(ref, open);
1525      React10.useEffect(() => {
1526        if (!enabled) {
1527          return void 0;
1528        }
1529        const abortController = new AbortController();
1530        runOnceAnimationsFinish(onComplete, abortController.signal);
1531        return () => {
1532          abortController.abort();
1533        };
1534      }, [enabled, open, onComplete, runOnceAnimationsFinish]);
1535    }
1536  
1537    // node_modules/@base-ui/utils/platform/parts.mjs
1538    var parts_exports = {};
1539    __export(parts_exports, {
1540      engine: () => engine_exports,
1541      env: () => env_exports,
1542      os: () => os_exports,
1543      screenReader: () => screen_reader_exports
1544    });
1545  
1546    // node_modules/@base-ui/utils/platform/os.mjs
1547    var os_exports = {};
1548    __export(os_exports, {
1549      android: () => android,
1550      apple: () => apple,
1551      ios: () => ios,
1552      linux: () => linux,
1553      mac: () => mac,
1554      windows: () => windows
1555    });
1556  
1557    // node_modules/@base-ui/utils/platform/shared.mjs
1558    function readRawData() {
1559      if (typeof navigator === "undefined") {
1560        return {
1561          userAgent: "",
1562          platform: "",
1563          maxTouchPoints: 0
1564        };
1565      }
1566      if (true) {
1567        const uaData = navigator.userAgentData;
1568        if (uaData && Array.isArray(uaData.brands)) {
1569          return {
1570            userAgent: uaData.brands.map(({
1571              brand,
1572              version: version2
1573            }) => `$brand}/$version2}`).join(" "),
1574            platform: uaData.platform ?? navigator.platform ?? "",
1575            maxTouchPoints: navigator.maxTouchPoints ?? 0
1576          };
1577        }
1578      }
1579      return {
1580        userAgent: navigator.userAgent,
1581        platform: navigator.platform ?? "",
1582        maxTouchPoints: navigator.maxTouchPoints ?? 0
1583      };
1584    }
1585    var {
1586      userAgent,
1587      platform,
1588      maxTouchPoints
1589    } = readRawData();
1590    var lowerUserAgent = userAgent.toLowerCase();
1591    var lowerPlatform = platform.toLowerCase();
1592  
1593    // node_modules/@base-ui/utils/platform/os.mjs
1594    var ios = /^i(os$|p)/.test(lowerPlatform) || lowerPlatform === "macintel" && maxTouchPoints > 1;
1595    var ANDROID_STRING = "android";
1596    var android = lowerPlatform === ANDROID_STRING || lowerUserAgent.includes(ANDROID_STRING);
1597    var mac = !ios && lowerPlatform.startsWith("mac");
1598    var windows = lowerPlatform.startsWith("win");
1599    var linux = !android && /^(linux|chrome os)/.test(lowerPlatform);
1600    var apple = mac || ios;
1601  
1602    // node_modules/@base-ui/utils/platform/engine.mjs
1603    var engine_exports = {};
1604    __export(engine_exports, {
1605      blink: () => blink,
1606      gecko: () => gecko,
1607      webkit: () => webkit
1608    });
1609    var webkit = typeof CSS !== "undefined" && !!CSS.supports?.("-webkit-backdrop-filter:none");
1610    var gecko = !webkit && lowerUserAgent.includes("firefox");
1611    var blink = !webkit && lowerUserAgent.includes("chrom");
1612  
1613    // node_modules/@base-ui/utils/platform/screen-reader.mjs
1614    var screen_reader_exports = {};
1615    __export(screen_reader_exports, {
1616      voiceOver: () => voiceOver
1617    });
1618    var voiceOver = apple;
1619  
1620    // node_modules/@base-ui/utils/platform/env.mjs
1621    var env_exports = {};
1622    __export(env_exports, {
1623      jsdom: () => jsdom
1624    });
1625    var jsdom = /jsdom|happydom/.test(lowerUserAgent);
1626  
1627    // node_modules/@base-ui/utils/useTimeout.mjs
1628    var EMPTY2 = 0;
1629    var Timeout = class _Timeout {
1630      static create() {
1631        return new _Timeout();
1632      }
1633      currentId = EMPTY2;
1634      /**
1635       * Executes `fn` after `delay`, clearing any previously scheduled call.
1636       */
1637      start(delay, fn) {
1638        this.clear();
1639        this.currentId = setTimeout(() => {
1640          this.currentId = EMPTY2;
1641          fn();
1642        }, delay);
1643      }
1644      isStarted() {
1645        return this.currentId !== EMPTY2;
1646      }
1647      clear = () => {
1648        if (this.currentId !== EMPTY2) {
1649          clearTimeout(this.currentId);
1650          this.currentId = EMPTY2;
1651        }
1652      };
1653      disposeEffect = () => {
1654        return this.clear;
1655      };
1656    };
1657    function useTimeout() {
1658      const timeout = useRefWithInit(Timeout.create).current;
1659      useOnMount(timeout.disposeEffect);
1660      return timeout;
1661    }
1662  
1663    // node_modules/@base-ui/react/floating-ui-react/components/FloatingDelayGroup.mjs
1664    var React11 = __toESM(require_react(), 1);
1665  
1666    // node_modules/@base-ui/react/floating-ui-react/utils/event.mjs
1667    function isReactEvent(event) {
1668      return "nativeEvent" in event;
1669    }
1670    function isMouseLikePointerType(pointerType, strict) {
1671      const values = ["mouse", "pen"];
1672      if (!strict) {
1673        values.push("", void 0);
1674      }
1675      return values.includes(pointerType);
1676    }
1677    function isClickLikeEvent(event) {
1678      const type = event.type;
1679      return type === "click" || type === "mousedown" || type === "keydown" || type === "keyup";
1680    }
1681  
1682    // node_modules/@base-ui/react/floating-ui-react/utils/constants.mjs
1683    var FOCUSABLE_ATTRIBUTE = "data-base-ui-focusable";
1684    var TYPEABLE_SELECTOR = "input:not([type='hidden']):not([disabled]),[contenteditable]:not([contenteditable='false']),textarea:not([disabled])";
1685  
1686    // node_modules/@base-ui/react/internals/shadowDom.mjs
1687    function activeElement(doc) {
1688      let element = doc.activeElement;
1689      while (element?.shadowRoot?.activeElement != null) {
1690        element = element.shadowRoot.activeElement;
1691      }
1692      return element;
1693    }
1694    function contains(parent, child) {
1695      if (!parent || !child) {
1696        return false;
1697      }
1698      const rootNode = child.getRootNode?.();
1699      if (parent.contains(child)) {
1700        return true;
1701      }
1702      if (rootNode && isShadowRoot(rootNode)) {
1703        let next = child;
1704        while (next) {
1705          if (parent === next) {
1706            return true;
1707          }
1708          next = next.parentNode || next.host;
1709        }
1710      }
1711      return false;
1712    }
1713    function getTarget(event) {
1714      if ("composedPath" in event) {
1715        return event.composedPath()[0];
1716      }
1717      return event.target;
1718    }
1719  
1720    // node_modules/@base-ui/react/floating-ui-react/utils/element.mjs
1721    function isTargetInsideEnabledTrigger(target, triggerElements) {
1722      if (!isElement(target)) {
1723        return false;
1724      }
1725      const targetElement = target;
1726      if (triggerElements.hasElement(targetElement)) {
1727        return !targetElement.hasAttribute("data-trigger-disabled");
1728      }
1729      for (const [, trigger] of triggerElements.entries()) {
1730        if (contains(trigger, targetElement)) {
1731          return !trigger.hasAttribute("data-trigger-disabled");
1732        }
1733      }
1734      return false;
1735    }
1736    function isEventTargetWithin(event, node) {
1737      if (node == null) {
1738        return false;
1739      }
1740      if ("composedPath" in event) {
1741        return event.composedPath().includes(node);
1742      }
1743      const eventAgain = event;
1744      return eventAgain.target != null && node.contains(eventAgain.target);
1745    }
1746    function isRootElement(element) {
1747      return element.matches("html,body");
1748    }
1749    function isTypeableElement(element) {
1750      return isHTMLElement(element) && element.matches(TYPEABLE_SELECTOR);
1751    }
1752    function isInteractiveElement(element) {
1753      return element?.closest(`button,a[href],[role="button"],select,[tabindex]:not([tabindex="-1"]),$TYPEABLE_SELECTOR}`) != null;
1754    }
1755    function matchesFocusVisible(element) {
1756      if (!element || parts_exports.env.jsdom) {
1757        return true;
1758      }
1759      try {
1760        return element.matches(":focus-visible");
1761      } catch (_e) {
1762        return true;
1763      }
1764    }
1765  
1766    // node_modules/@base-ui/react/floating-ui-react/hooks/useHoverShared.mjs
1767    function resolveValue(value, pointerType) {
1768      if (pointerType != null && !isMouseLikePointerType(pointerType)) {
1769        return 0;
1770      }
1771      if (typeof value === "function") {
1772        return value();
1773      }
1774      return value;
1775    }
1776    function getDelay(value, prop, pointerType) {
1777      const result = resolveValue(value, pointerType);
1778      if (typeof result === "number") {
1779        return result;
1780      }
1781      return result?.[prop];
1782    }
1783    function getRestMs(value) {
1784      if (typeof value === "function") {
1785        return value();
1786      }
1787      return value;
1788    }
1789    function isClickLikeOpenEvent(openEventType, interactedInside) {
1790      return interactedInside || openEventType === "click" || openEventType === "mousedown";
1791    }
1792    function isHoverOpenEvent(openEventType) {
1793      return openEventType?.includes("mouse") && openEventType !== "mousedown";
1794    }
1795  
1796    // node_modules/@base-ui/react/floating-ui-react/components/FloatingDelayGroup.mjs
1797    var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
1798    var FloatingDelayGroupContext = /* @__PURE__ */ React11.createContext({
1799      hasProvider: false,
1800      timeoutMs: 0,
1801      delayRef: {
1802        current: 0
1803      },
1804      initialDelayRef: {
1805        current: 0
1806      },
1807      timeout: new Timeout(),
1808      currentIdRef: {
1809        current: null
1810      },
1811      currentContextRef: {
1812        current: null
1813      }
1814    });
1815    if (true) FloatingDelayGroupContext.displayName = "FloatingDelayGroupContext";
1816    function resetDelayRef(delayRef, initialDelayRef) {
1817      delayRef.current = initialDelayRef.current;
1818    }
1819    function FloatingDelayGroup(props) {
1820      const {
1821        children,
1822        delay,
1823        timeoutMs = 0
1824      } = props;
1825      const delayRef = React11.useRef(delay);
1826      const initialDelayRef = React11.useRef(delay);
1827      const currentIdRef = React11.useRef(null);
1828      const currentContextRef = React11.useRef(null);
1829      const timeout = useTimeout();
1830      useIsoLayoutEffect(() => {
1831        initialDelayRef.current = delay;
1832        if (!currentIdRef.current) {
1833          delayRef.current = delay;
1834          return;
1835        }
1836        delayRef.current = {
1837          open: getDelay(delayRef.current, "open"),
1838          close: getDelay(delay, "close")
1839        };
1840      }, [delay, currentIdRef, delayRef, initialDelayRef]);
1841      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FloatingDelayGroupContext.Provider, {
1842        value: React11.useMemo(() => ({
1843          hasProvider: true,
1844          delayRef,
1845          initialDelayRef,
1846          currentIdRef,
1847          timeoutMs,
1848          currentContextRef,
1849          timeout
1850        }), [timeoutMs, timeout]),
1851        children
1852      });
1853    }
1854    function useDelayGroup(context, options = {
1855      open: false
1856    }) {
1857      const {
1858        open
1859      } = options;
1860      const store2 = "rootStore" in context ? context.rootStore : context;
1861      const floatingId = store2.useState("floatingId");
1862      const groupContext = React11.useContext(FloatingDelayGroupContext);
1863      const {
1864        currentIdRef,
1865        delayRef,
1866        timeoutMs,
1867        initialDelayRef,
1868        currentContextRef,
1869        hasProvider,
1870        timeout
1871      } = groupContext;
1872      const [isInstantPhase, setIsInstantPhase] = React11.useState(false);
1873      const openRef = React11.useRef(open);
1874      useIsoLayoutEffect(() => {
1875        openRef.current = open;
1876      }, [open]);
1877      useIsoLayoutEffect(() => {
1878        function unset() {
1879          currentContextRef.current?.setIsInstantPhase(false);
1880          currentIdRef.current = null;
1881          currentContextRef.current = null;
1882          delayRef.current = initialDelayRef.current;
1883          timeout.clear();
1884        }
1885        if (!currentIdRef.current) {
1886          return void 0;
1887        }
1888        if (!open && currentIdRef.current === floatingId) {
1889          setIsInstantPhase(false);
1890          if (timeoutMs) {
1891            const closingId = floatingId;
1892            timeout.start(timeoutMs, () => {
1893              if (store2.select("open") || currentIdRef.current && currentIdRef.current !== closingId) {
1894                return;
1895              }
1896              unset();
1897            });
1898            return () => {
1899              if (openRef.current || currentIdRef.current !== closingId) {
1900                timeout.clear();
1901              }
1902            };
1903          }
1904          unset();
1905        }
1906        return void 0;
1907      }, [open, floatingId, currentIdRef, delayRef, timeoutMs, initialDelayRef, currentContextRef, timeout, store2]);
1908      useIsoLayoutEffect(() => {
1909        if (!open) {
1910          return;
1911        }
1912        const prevContext = currentContextRef.current;
1913        const prevId = currentIdRef.current;
1914        timeout.clear();
1915        currentContextRef.current = {
1916          onOpenChange: store2.setOpen,
1917          setIsInstantPhase
1918        };
1919        currentIdRef.current = floatingId;
1920        delayRef.current = {
1921          open: 0,
1922          close: getDelay(initialDelayRef.current, "close")
1923        };
1924        if (prevId !== null && prevId !== floatingId) {
1925          setIsInstantPhase(true);
1926          prevContext?.setIsInstantPhase(true);
1927          prevContext?.onOpenChange(false, createChangeEventDetails(reason_parts_exports.none));
1928        } else {
1929          setIsInstantPhase(false);
1930          prevContext?.setIsInstantPhase(false);
1931        }
1932      }, [open, floatingId, store2, currentIdRef, delayRef, initialDelayRef, currentContextRef, timeout]);
1933      useIsoLayoutEffect(() => {
1934        return () => {
1935          if (currentIdRef.current === floatingId) {
1936            currentContextRef.current = null;
1937            if (!openRef.current) {
1938              return;
1939            }
1940            currentIdRef.current = null;
1941            resetDelayRef(delayRef, initialDelayRef);
1942            timeout.clear();
1943          }
1944        };
1945      }, [currentContextRef, currentIdRef, delayRef, floatingId, initialDelayRef, timeout]);
1946      return React11.useMemo(() => ({
1947        hasProvider,
1948        delayRef,
1949        isInstantPhase
1950      }), [hasProvider, delayRef, isInstantPhase]);
1951    }
1952  
1953    // node_modules/@base-ui/utils/mergeCleanups.mjs
1954    function mergeCleanups(...cleanups) {
1955      return () => {
1956        for (let i = 0; i < cleanups.length; i += 1) {
1957          const cleanup = cleanups[i];
1958          if (cleanup) {
1959            cleanup();
1960          }
1961        }
1962      };
1963    }
1964  
1965    // node_modules/@base-ui/react/utils/FocusGuard.mjs
1966    var React12 = __toESM(require_react(), 1);
1967  
1968    // node_modules/@base-ui/utils/visuallyHidden.mjs
1969    var visuallyHiddenBase = {
1970      clipPath: "inset(50%)",
1971      overflow: "hidden",
1972      whiteSpace: "nowrap",
1973      border: 0,
1974      padding: 0,
1975      width: 1,
1976      height: 1,
1977      margin: -1
1978    };
1979    var visuallyHidden = {
1980      ...visuallyHiddenBase,
1981      position: "fixed",
1982      top: 0,
1983      left: 0
1984    };
1985    var visuallyHiddenInput = {
1986      ...visuallyHiddenBase,
1987      position: "absolute"
1988    };
1989  
1990    // node_modules/@base-ui/react/utils/FocusGuard.mjs
1991    var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
1992    var FocusGuard = /* @__PURE__ */ React12.forwardRef(function FocusGuard2(props, ref) {
1993      const [role, setRole] = React12.useState();
1994      useIsoLayoutEffect(() => {
1995        if (parts_exports.screenReader.voiceOver && parts_exports.engine.webkit) {
1996          setRole("button");
1997        }
1998      }, []);
1999      const restProps = {
2000        tabIndex: 0,
2001        // Role is only for VoiceOver
2002        role
2003      };
2004      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", {
2005        ...props,
2006        ref,
2007        style: visuallyHidden,
2008        "aria-hidden": role ? void 0 : true,
2009        ...restProps,
2010        "data-base-ui-focus-guard": ""
2011      });
2012    });
2013    if (true) FocusGuard.displayName = "FocusGuard";
2014  
2015    // node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
2016    var min = Math.min;
2017    var max = Math.max;
2018    var round = Math.round;
2019    var floor = Math.floor;
2020    var createCoords = (v) => ({
2021      x: v,
2022      y: v
2023    });
2024    var oppositeSideMap = {
2025      left: "right",
2026      right: "left",
2027      bottom: "top",
2028      top: "bottom"
2029    };
2030    function clamp(start, value, end) {
2031      return max(start, min(value, end));
2032    }
2033    function evaluate(value, param) {
2034      return typeof value === "function" ? value(param) : value;
2035    }
2036    function getSide(placement) {
2037      return placement.split("-")[0];
2038    }
2039    function getAlignment(placement) {
2040      return placement.split("-")[1];
2041    }
2042    function getOppositeAxis(axis) {
2043      return axis === "x" ? "y" : "x";
2044    }
2045    function getAxisLength(axis) {
2046      return axis === "y" ? "height" : "width";
2047    }
2048    function getSideAxis(placement) {
2049      const firstChar = placement[0];
2050      return firstChar === "t" || firstChar === "b" ? "y" : "x";
2051    }
2052    function getAlignmentAxis(placement) {
2053      return getOppositeAxis(getSideAxis(placement));
2054    }
2055    function getAlignmentSides(placement, rects, rtl) {
2056      if (rtl === void 0) {
2057        rtl = false;
2058      }
2059      const alignment = getAlignment(placement);
2060      const alignmentAxis = getAlignmentAxis(placement);
2061      const length = getAxisLength(alignmentAxis);
2062      let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
2063      if (rects.reference[length] > rects.floating[length]) {
2064        mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
2065      }
2066      return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
2067    }
2068    function getExpandedPlacements(placement) {
2069      const oppositePlacement = getOppositePlacement(placement);
2070      return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
2071    }
2072    function getOppositeAlignmentPlacement(placement) {
2073      return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start");
2074    }
2075    var lrPlacement = ["left", "right"];
2076    var rlPlacement = ["right", "left"];
2077    var tbPlacement = ["top", "bottom"];
2078    var btPlacement = ["bottom", "top"];
2079    function getSideList(side, isStart, rtl) {
2080      switch (side) {
2081        case "top":
2082        case "bottom":
2083          if (rtl) return isStart ? rlPlacement : lrPlacement;
2084          return isStart ? lrPlacement : rlPlacement;
2085        case "left":
2086        case "right":
2087          return isStart ? tbPlacement : btPlacement;
2088        default:
2089          return [];
2090      }
2091    }
2092    function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
2093      const alignment = getAlignment(placement);
2094      let list = getSideList(getSide(placement), direction === "start", rtl);
2095      if (alignment) {
2096        list = list.map((side) => side + "-" + alignment);
2097        if (flipAlignment) {
2098          list = list.concat(list.map(getOppositeAlignmentPlacement));
2099        }
2100      }
2101      return list;
2102    }
2103    function getOppositePlacement(placement) {
2104      const side = getSide(placement);
2105      return oppositeSideMap[side] + placement.slice(side.length);
2106    }
2107    function expandPaddingObject(padding) {
2108      var _padding$top, _padding$right, _padding$bottom, _padding$left;
2109      return {
2110        top: (_padding$top = padding.top) != null ? _padding$top : 0,
2111        right: (_padding$right = padding.right) != null ? _padding$right : 0,
2112        bottom: (_padding$bottom = padding.bottom) != null ? _padding$bottom : 0,
2113        left: (_padding$left = padding.left) != null ? _padding$left : 0
2114      };
2115    }
2116    function getPaddingObject(padding) {
2117      return typeof padding !== "number" ? expandPaddingObject(padding) : {
2118        top: padding,
2119        right: padding,
2120        bottom: padding,
2121        left: padding
2122      };
2123    }
2124    function rectToClientRect(rect) {
2125      const {
2126        x,
2127        y,
2128        width,
2129        height
2130      } = rect;
2131      return {
2132        width,
2133        height,
2134        top: y,
2135        left: x,
2136        right: x + width,
2137        bottom: y + height,
2138        x,
2139        y
2140      };
2141    }
2142  
2143    // node_modules/@base-ui/react/floating-ui-react/utils/composite.mjs
2144    function isHiddenByStyles(styles) {
2145      return styles.visibility === "hidden" || styles.visibility === "collapse";
2146    }
2147    function isElementVisible(element, styles = element ? getComputedStyle2(element) : null) {
2148      if (!element || !element.isConnected || !styles || isHiddenByStyles(styles)) {
2149        return false;
2150      }
2151      if (typeof element.checkVisibility === "function") {
2152        return element.checkVisibility();
2153      }
2154      return styles.display !== "none" && styles.display !== "contents";
2155    }
2156  
2157    // node_modules/@base-ui/react/floating-ui-react/utils/tabbable.mjs
2158    var CANDIDATE_SELECTOR = 'a[href],button,input,select,textarea,summary,details,iframe,object,embed,[tabindex],[contenteditable]:not([contenteditable="false"]),audio[controls],video[controls]';
2159    function getParentElement(element) {
2160      const assignedSlot = element.assignedSlot;
2161      if (assignedSlot) {
2162        return assignedSlot;
2163      }
2164      if (element.parentElement) {
2165        return element.parentElement;
2166      }
2167      const rootNode = element.getRootNode();
2168      return isShadowRoot(rootNode) ? rootNode.host : null;
2169    }
2170    function getDetailsSummary(details) {
2171      for (const child of Array.from(details.children)) {
2172        if (getNodeName(child) === "summary") {
2173          return child;
2174        }
2175      }
2176      return null;
2177    }
2178    function isWithinOpenDetailsSummary(element, details) {
2179      const summary = getDetailsSummary(details);
2180      return !!summary && (element === summary || contains(summary, element));
2181    }
2182    function isFocusableCandidate(element) {
2183      const nodeName = element ? getNodeName(element) : "";
2184      return element != null && element.matches(CANDIDATE_SELECTOR) && (nodeName !== "summary" || element.parentElement != null && getNodeName(element.parentElement) === "details" && getDetailsSummary(element.parentElement) === element) && (nodeName !== "details" || getDetailsSummary(element) == null) && (nodeName !== "input" || element.type !== "hidden");
2185    }
2186    function isFocusableElement(element) {
2187      if (!isFocusableCandidate(element) || !element.isConnected || element.matches(":disabled")) {
2188        return false;
2189      }
2190      for (let current = element; current; current = getParentElement(current)) {
2191        const isAncestor = current !== element;
2192        const isSlot = getNodeName(current) === "slot";
2193        if (current.hasAttribute("inert")) {
2194          return false;
2195        }
2196        if (isAncestor && getNodeName(current) === "details" && !current.open && !isWithinOpenDetailsSummary(element, current) || current.hasAttribute("hidden") || !isSlot && !isVisibleInTabbableTree(current, isAncestor)) {
2197          return false;
2198        }
2199      }
2200      return true;
2201    }
2202    function isVisibleInTabbableTree(element, isAncestor) {
2203      const styles = getComputedStyle2(element);
2204      if (!isAncestor) {
2205        return isElementVisible(element, styles);
2206      }
2207      return styles.display !== "none";
2208    }
2209    function getTabIndex(element) {
2210      const tabIndex = element.tabIndex;
2211      if (tabIndex < 0) {
2212        const nodeName = getNodeName(element);
2213        if (nodeName === "details" || nodeName === "audio" || nodeName === "video" || isHTMLElement(element) && element.isContentEditable) {
2214          return 0;
2215        }
2216      }
2217      return tabIndex;
2218    }
2219    function getNamedRadioInput(element) {
2220      if (getNodeName(element) !== "input") {
2221        return null;
2222      }
2223      const input = element;
2224      return input.type === "radio" && input.name !== "" ? input : null;
2225    }
2226    function isTabbableRadio(element, candidates) {
2227      const input = getNamedRadioInput(element);
2228      if (!input) {
2229        return true;
2230      }
2231      const checkedRadio = candidates.find((candidate) => {
2232        const radio = getNamedRadioInput(candidate);
2233        return radio?.name === input.name && radio.form === input.form && radio.checked;
2234      });
2235      if (checkedRadio) {
2236        return checkedRadio === input;
2237      }
2238      return candidates.find((candidate) => {
2239        const radio = getNamedRadioInput(candidate);
2240        return radio?.name === input.name && radio.form === input.form;
2241      }) === input;
2242    }
2243    function getComposedChildren(container) {
2244      if (isHTMLElement(container) && getNodeName(container) === "slot") {
2245        const assignedElements = container.assignedElements({
2246          flatten: true
2247        });
2248        if (assignedElements.length > 0) {
2249          return assignedElements;
2250        }
2251      }
2252      if (isHTMLElement(container) && container.shadowRoot) {
2253        return Array.from(container.shadowRoot.children);
2254      }
2255      return Array.from(container.children);
2256    }
2257    function appendCandidates(container, list) {
2258      getComposedChildren(container).forEach((child) => {
2259        if (isFocusableCandidate(child)) {
2260          list.push(child);
2261        }
2262        appendCandidates(child, list);
2263      });
2264    }
2265    function appendMatchingElements(container, selector, list) {
2266      getComposedChildren(container).forEach((child) => {
2267        if (isHTMLElement(child) && child.matches(selector)) {
2268          list.push(child);
2269        }
2270        appendMatchingElements(child, selector, list);
2271      });
2272    }
2273    function focusable(container) {
2274      const candidates = [];
2275      appendCandidates(container, candidates);
2276      return candidates.filter(isFocusableElement);
2277    }
2278    function tabbable(container) {
2279      const candidates = focusable(container);
2280      return candidates.filter((element) => getTabIndex(element) >= 0 && isTabbableRadio(element, candidates));
2281    }
2282    function getTabbableIn(container, dir) {
2283      const list = tabbable(container);
2284      const len = list.length;
2285      if (len === 0) {
2286        return void 0;
2287      }
2288      const active = activeElement(ownerDocument(container));
2289      const index2 = list.indexOf(active);
2290      const nextIndex = index2 === -1 ? dir === 1 ? 0 : len - 1 : index2 + dir;
2291      return list[nextIndex];
2292    }
2293    function getNextTabbable(referenceElement) {
2294      return getTabbableIn(ownerDocument(referenceElement).body, 1) || referenceElement;
2295    }
2296    function getPreviousTabbable(referenceElement) {
2297      return getTabbableIn(ownerDocument(referenceElement).body, -1) || referenceElement;
2298    }
2299    function isOutsideEvent(event, container) {
2300      const containerElement = container || event.currentTarget;
2301      const relatedTarget = event.relatedTarget;
2302      return !relatedTarget || !contains(containerElement, relatedTarget);
2303    }
2304    function disableFocusInside(container) {
2305      const tabbableElements = tabbable(container);
2306      tabbableElements.forEach((element) => {
2307        element.dataset.tabindex = element.getAttribute("tabindex") || "";
2308        element.setAttribute("tabindex", "-1");
2309      });
2310    }
2311    function enableFocusInside(container) {
2312      const elements = [];
2313      appendMatchingElements(container, "[data-tabindex]", elements);
2314      elements.forEach((element) => {
2315        const tabindex = element.dataset.tabindex;
2316        delete element.dataset.tabindex;
2317        if (tabindex) {
2318          element.setAttribute("tabindex", tabindex);
2319        } else {
2320          element.removeAttribute("tabindex");
2321        }
2322      });
2323    }
2324  
2325    // node_modules/@base-ui/react/floating-ui-react/utils/nodes.mjs
2326    function getNodeChildren(nodes, id, onlyOpenChildren = true) {
2327      const directChildren = nodes.filter((node) => node.parentId === id);
2328      return directChildren.flatMap((child) => [...!onlyOpenChildren || child.context?.open ? [child] : [], ...getNodeChildren(nodes, child.id, onlyOpenChildren)]);
2329    }
2330  
2331    // node_modules/@base-ui/react/floating-ui-react/utils/createAttribute.mjs
2332    function createAttribute(name) {
2333      return `data-base-ui-$name}`;
2334    }
2335  
2336    // node_modules/@base-ui/react/floating-ui-react/components/FloatingPortal.mjs
2337    var React13 = __toESM(require_react(), 1);
2338    var ReactDOM2 = __toESM(require_react_dom(), 1);
2339  
2340    // node_modules/@base-ui/react/internals/constants.mjs
2341    var DISABLED_TRANSITIONS_STYLE = {
2342      style: {
2343        transition: "none"
2344      }
2345    };
2346    var BASE_UI_SWIPE_IGNORE_ATTRIBUTE = "data-base-ui-swipe-ignore";
2347    var LEGACY_SWIPE_IGNORE_ATTRIBUTE = "data-swipe-ignore";
2348    var BASE_UI_SWIPE_IGNORE_SELECTOR = `[$BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
2349    var LEGACY_SWIPE_IGNORE_SELECTOR = `[$LEGACY_SWIPE_IGNORE_ATTRIBUTE}]`;
2350    var POPUP_COLLISION_AVOIDANCE = {
2351      fallbackAxisSide: "end"
2352    };
2353    var ownerVisuallyHidden = {
2354      clipPath: "inset(50%)",
2355      position: "fixed",
2356      top: 0,
2357      left: 0
2358    };
2359  
2360    // node_modules/@base-ui/react/floating-ui-react/components/FloatingPortal.mjs
2361    var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
2362    var PortalContext = /* @__PURE__ */ React13.createContext(null);
2363    if (true) PortalContext.displayName = "PortalContext";
2364    var usePortalContext = () => React13.useContext(PortalContext);
2365    var attr = createAttribute("portal");
2366    function useFloatingPortalNode(props = {}) {
2367      const {
2368        ref,
2369        container: containerProp,
2370        componentProps = EMPTY_OBJECT,
2371        elementProps
2372      } = props;
2373      const uniqueId = useId();
2374      const portalContext = usePortalContext();
2375      const parentPortalNode = portalContext?.portalNode;
2376      const [containerElement, setContainerElement] = React13.useState(null);
2377      const [portalNode, setPortalNode] = React13.useState(null);
2378      const setPortalNodeRef = useStableCallback((node) => {
2379        if (node !== null) {
2380          setPortalNode(node);
2381        }
2382      });
2383      const containerRef = React13.useRef(null);
2384      useIsoLayoutEffect(() => {
2385        if (containerProp === null) {
2386          if (containerRef.current) {
2387            containerRef.current = null;
2388            setPortalNode(null);
2389            setContainerElement(null);
2390          }
2391          return;
2392        }
2393        const resolvedContainer = (containerProp && (isNode(containerProp) ? containerProp : containerProp.current)) ?? parentPortalNode ?? document.body;
2394        if (resolvedContainer == null) {
2395          if (containerRef.current) {
2396            containerRef.current = null;
2397            setPortalNode(null);
2398            setContainerElement(null);
2399          }
2400          return;
2401        }
2402        if (containerRef.current !== resolvedContainer) {
2403          containerRef.current = resolvedContainer;
2404          setPortalNode(null);
2405          setContainerElement(resolvedContainer);
2406        }
2407      }, [containerProp, parentPortalNode]);
2408      const portalElement = useRenderElement("div", componentProps, {
2409        ref: [ref, setPortalNodeRef],
2410        props: [{
2411          id: uniqueId,
2412          [attr]: ""
2413        }, elementProps]
2414      });
2415      const portalSubtree = containerElement && portalElement ? /* @__PURE__ */ ReactDOM2.createPortal(portalElement, containerElement) : null;
2416      return {
2417        node: portalNode,
2418        // `id` and `render` props can override or remove the generated ID. Use the exact
2419        // rendered value so `aria-owns` never points at an ID absent from the DOM.
2420        nodeId: /* @__PURE__ */ React13.isValidElement(portalElement) ? portalElement.props.id : void 0,
2421        subtree: portalSubtree
2422      };
2423    }
2424    var FloatingPortal = /* @__PURE__ */ React13.forwardRef(function FloatingPortal2(componentProps, forwardedRef) {
2425      const {
2426        render,
2427        className,
2428        style,
2429        children,
2430        container,
2431        ...elementProps
2432      } = componentProps;
2433      const {
2434        node: portalNode,
2435        nodeId: portalNodeId,
2436        subtree: portalSubtree
2437      } = useFloatingPortalNode({
2438        container,
2439        ref: forwardedRef,
2440        componentProps,
2441        elementProps
2442      });
2443      const beforeOutsideRef = React13.useRef(null);
2444      const afterOutsideRef = React13.useRef(null);
2445      const beforeInsideRef = React13.useRef(null);
2446      const afterInsideRef = React13.useRef(null);
2447      const [focusManagerState, setFocusManagerState] = React13.useState(null);
2448      const focusInsideDisabledRef = React13.useRef(false);
2449      const modal = focusManagerState?.modal;
2450      const open = focusManagerState?.open;
2451      const shouldRenderGuards = !!focusManagerState && !focusManagerState.modal && focusManagerState.open && !!portalNode;
2452      React13.useEffect(() => {
2453        if (!portalNode || modal) {
2454          return void 0;
2455        }
2456        function onFocus(event) {
2457          if (portalNode && event.relatedTarget && isOutsideEvent(event)) {
2458            if (event.type === "focusin") {
2459              if (focusInsideDisabledRef.current) {
2460                enableFocusInside(portalNode);
2461                focusInsideDisabledRef.current = false;
2462              }
2463            } else {
2464              disableFocusInside(portalNode);
2465              focusInsideDisabledRef.current = true;
2466            }
2467          }
2468        }
2469        return mergeCleanups(addEventListener(portalNode, "focusin", onFocus, true), addEventListener(portalNode, "focusout", onFocus, true));
2470      }, [portalNode, modal]);
2471      useIsoLayoutEffect(() => {
2472        if (!portalNode || open !== true || !focusInsideDisabledRef.current) {
2473          return;
2474        }
2475        enableFocusInside(portalNode);
2476        focusInsideDisabledRef.current = false;
2477      }, [open, portalNode]);
2478      const portalContextValue = React13.useMemo(() => ({
2479        beforeOutsideRef,
2480        afterOutsideRef,
2481        beforeInsideRef,
2482        afterInsideRef,
2483        portalNode,
2484        setFocusManagerState
2485      }), [portalNode]);
2486      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(React13.Fragment, {
2487        children: [portalSubtree, /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(PortalContext.Provider, {
2488          value: portalContextValue,
2489          children: [shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(FocusGuard, {
2490            "data-type": "outside",
2491            ref: beforeOutsideRef,
2492            onFocus: (event) => {
2493              if (isOutsideEvent(event, portalNode)) {
2494                beforeInsideRef.current?.focus();
2495              } else {
2496                const domReference = focusManagerState ? focusManagerState.domReference : null;
2497                const prevTabbable = getPreviousTabbable(domReference);
2498                prevTabbable?.focus();
2499              }
2500            }
2501          }), shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", {
2502            "aria-owns": portalNodeId,
2503            style: ownerVisuallyHidden
2504          }), portalNode && /* @__PURE__ */ ReactDOM2.createPortal(children, portalNode), shouldRenderGuards && portalNode && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(FocusGuard, {
2505            "data-type": "outside",
2506            ref: afterOutsideRef,
2507            onFocus: (event) => {
2508              if (isOutsideEvent(event, portalNode)) {
2509                afterInsideRef.current?.focus();
2510              } else {
2511                const domReference = focusManagerState ? focusManagerState.domReference : null;
2512                const nextTabbable = getNextTabbable(domReference);
2513                nextTabbable?.focus();
2514                if (focusManagerState?.closeOnFocusOut) {
2515                  focusManagerState?.onOpenChange(false, createChangeEventDetails(reason_parts_exports.focusOut, event.nativeEvent));
2516                }
2517              }
2518            }
2519          })]
2520        })]
2521      });
2522    });
2523    if (true) FloatingPortal.displayName = "FloatingPortal";
2524  
2525    // node_modules/@base-ui/react/floating-ui-react/components/FloatingTree.mjs
2526    var React14 = __toESM(require_react(), 1);
2527  
2528    // node_modules/@base-ui/react/floating-ui-react/utils/createEventEmitter.mjs
2529    function createEventEmitter() {
2530      const map = /* @__PURE__ */ new Map();
2531      return {
2532        emit(event, data) {
2533          map.get(event)?.forEach((listener) => listener(data));
2534        },
2535        on(event, listener) {
2536          if (!map.has(event)) {
2537            map.set(event, /* @__PURE__ */ new Set());
2538          }
2539          map.get(event).add(listener);
2540        },
2541        off(event, listener) {
2542          map.get(event)?.delete(listener);
2543        }
2544      };
2545    }
2546  
2547    // node_modules/@base-ui/react/floating-ui-react/components/FloatingTree.mjs
2548    var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
2549    var FloatingNodeContext = /* @__PURE__ */ React14.createContext(null);
2550    if (true) FloatingNodeContext.displayName = "FloatingNodeContext";
2551    var FloatingTreeContext = /* @__PURE__ */ React14.createContext(null);
2552    if (true) FloatingTreeContext.displayName = "FloatingTreeContext";
2553    var useFloatingParentNodeId = () => React14.useContext(FloatingNodeContext)?.id || null;
2554    var useFloatingTree = (externalTree) => {
2555      const contextTree = React14.useContext(FloatingTreeContext);
2556      return externalTree ?? contextTree;
2557    };
2558  
2559    // node_modules/@base-ui/react/floating-ui-react/hooks/useClientPoint.mjs
2560    var React15 = __toESM(require_react(), 1);
2561    function createVirtualElement(domElement, data) {
2562      let offsetX = null;
2563      let offsetY = null;
2564      let isAutoUpdateEvent = false;
2565      return {
2566        contextElement: domElement || void 0,
2567        getBoundingClientRect() {
2568          const domRect = domElement?.getBoundingClientRect() || {
2569            width: 0,
2570            height: 0,
2571            x: 0,
2572            y: 0
2573          };
2574          const isXAxis = data.axis === "x" || data.axis === "both";
2575          const isYAxis = data.axis === "y" || data.axis === "both";
2576          const canTrackCursorOnAutoUpdate = ["mouseenter", "mousemove"].includes(data.dataRef.current.openEvent?.type || "") && data.pointerType !== "touch";
2577          let width = domRect.width;
2578          let height = domRect.height;
2579          let x = domRect.x;
2580          let y = domRect.y;
2581          if (offsetX == null && data.x && isXAxis) {
2582            offsetX = domRect.x - data.x;
2583          }
2584          if (offsetY == null && data.y && isYAxis) {
2585            offsetY = domRect.y - data.y;
2586          }
2587          x -= offsetX || 0;
2588          y -= offsetY || 0;
2589          width = 0;
2590          height = 0;
2591          if (!isAutoUpdateEvent || canTrackCursorOnAutoUpdate) {
2592            width = data.axis === "y" ? domRect.width : 0;
2593            height = data.axis === "x" ? domRect.height : 0;
2594            x = isXAxis && data.x != null ? data.x : x;
2595            y = isYAxis && data.y != null ? data.y : y;
2596          } else if (isAutoUpdateEvent && !canTrackCursorOnAutoUpdate) {
2597            height = data.axis === "x" ? domRect.height : height;
2598            width = data.axis === "y" ? domRect.width : width;
2599          }
2600          isAutoUpdateEvent = true;
2601          return {
2602            width,
2603            height,
2604            x,
2605            y,
2606            top: y,
2607            right: x + width,
2608            bottom: y + height,
2609            left: x
2610          };
2611        }
2612      };
2613    }
2614    function isMouseBasedEvent(event) {
2615      return event != null && event.clientX != null;
2616    }
2617    function useClientPoint(context, props = {}) {
2618      const {
2619        enabled = true,
2620        axis = "both"
2621      } = props;
2622      const store2 = "rootStore" in context ? context.rootStore : context;
2623      const open = store2.useState("open");
2624      const floating = store2.useState("floatingElement");
2625      const domReference = store2.useState("domReferenceElement");
2626      const dataRef = store2.context.dataRef;
2627      const initialRef = React15.useRef(false);
2628      const cleanupListenerRef = React15.useRef(null);
2629      const [pointerType, setPointerType] = React15.useState();
2630      const [reactive, setReactive] = React15.useState([]);
2631      const resetReference = useStableCallback((reference2) => {
2632        store2.set("positionReference", reference2);
2633      });
2634      const setReference = useStableCallback((newX, newY, referenceElement) => {
2635        if (initialRef.current) {
2636          return;
2637        }
2638        if (dataRef.current.openEvent && !isMouseBasedEvent(dataRef.current.openEvent)) {
2639          return;
2640        }
2641        store2.set("positionReference", createVirtualElement(referenceElement ?? domReference, {
2642          x: newX,
2643          y: newY,
2644          axis,
2645          dataRef,
2646          pointerType
2647        }));
2648      });
2649      const handleReferenceEnterOrMove = useStableCallback((event) => {
2650        if (!open) {
2651          setReference(event.clientX, event.clientY, event.currentTarget);
2652        } else if (!cleanupListenerRef.current) {
2653          setReference(event.clientX, event.clientY, event.currentTarget);
2654          setReactive([]);
2655        }
2656      });
2657      const openCheck = isMouseLikePointerType(pointerType) ? floating : open;
2658      React15.useEffect(() => {
2659        if (!enabled) {
2660          resetReference(domReference);
2661          return void 0;
2662        }
2663        if (!openCheck) {
2664          return void 0;
2665        }
2666        function cleanupListener() {
2667          cleanupListenerRef.current?.();
2668          cleanupListenerRef.current = null;
2669        }
2670        const win = getWindow(floating);
2671        function handleMouseMove(event) {
2672          const target = getTarget(event);
2673          if (!contains(floating, target)) {
2674            setReference(event.clientX, event.clientY);
2675          } else {
2676            cleanupListener();
2677          }
2678        }
2679        if (!dataRef.current.openEvent || isMouseBasedEvent(dataRef.current.openEvent)) {
2680          cleanupListenerRef.current = addEventListener(win, "mousemove", handleMouseMove);
2681        } else {
2682          resetReference(domReference);
2683        }
2684        return cleanupListener;
2685      }, [openCheck, enabled, floating, dataRef, domReference, store2, setReference, resetReference, reactive]);
2686      React15.useEffect(() => () => {
2687        store2.set("positionReference", null);
2688      }, [store2]);
2689      React15.useEffect(() => {
2690        if (enabled && !floating) {
2691          initialRef.current = false;
2692        }
2693      }, [enabled, floating]);
2694      React15.useEffect(() => {
2695        if (!enabled && open) {
2696          initialRef.current = true;
2697        }
2698      }, [enabled, open]);
2699      const reference = React15.useMemo(() => {
2700        function setPointerTypeRef(event) {
2701          setPointerType(event.pointerType);
2702        }
2703        return {
2704          onPointerDown: setPointerTypeRef,
2705          onPointerEnter: setPointerTypeRef,
2706          onMouseMove: handleReferenceEnterOrMove,
2707          onMouseEnter: handleReferenceEnterOrMove
2708        };
2709      }, [handleReferenceEnterOrMove]);
2710      return React15.useMemo(() => enabled ? {
2711        reference,
2712        trigger: reference
2713      } : {}, [enabled, reference]);
2714    }
2715  
2716    // node_modules/@base-ui/react/floating-ui-react/hooks/useDismiss.mjs
2717    var React16 = __toESM(require_react(), 1);
2718    function alwaysFalse() {
2719      return false;
2720    }
2721    function normalizeProp(normalizable) {
2722      return {
2723        escapeKey: typeof normalizable === "boolean" ? normalizable : normalizable?.escapeKey ?? false,
2724        outsidePress: typeof normalizable === "boolean" ? normalizable : normalizable?.outsidePress ?? true
2725      };
2726    }
2727    function useDismiss(context, props = {}) {
2728      const {
2729        enabled = true,
2730        escapeKey: escapeKey2 = true,
2731        outsidePress: outsidePressProp = true,
2732        outsidePressEvent = "sloppy",
2733        referencePress = alwaysFalse,
2734        bubbles,
2735        externalTree
2736      } = props;
2737      const store2 = "rootStore" in context ? context.rootStore : context;
2738      const open = store2.useState("open");
2739      const floatingElement = store2.useState("floatingElement");
2740      const {
2741        dataRef
2742      } = store2.context;
2743      const tree = useFloatingTree(externalTree);
2744      const outsidePressFn = useStableCallback(typeof outsidePressProp === "function" ? outsidePressProp : () => false);
2745      const outsidePress2 = typeof outsidePressProp === "function" ? outsidePressFn : outsidePressProp;
2746      const outsidePressEnabled = outsidePress2 !== false;
2747      const getOutsidePressEventProp = useStableCallback(() => outsidePressEvent);
2748      const {
2749        escapeKey: escapeKeyBubbles,
2750        outsidePress: outsidePressBubbles
2751      } = normalizeProp(bubbles);
2752      const pressStartedInsideRef = React16.useRef(false);
2753      const pressStartPreventedRef = React16.useRef(false);
2754      const suppressNextOutsideClickRef = React16.useRef(false);
2755      const isComposingRef = React16.useRef(false);
2756      const currentPointerTypeRef = React16.useRef("");
2757      const touchStateRef = React16.useRef(null);
2758      const cancelDismissOnEndTimeout = useTimeout();
2759      const clearInsideReactTreeTimeout = useTimeout();
2760      const clearInsideReactTree = useStableCallback(() => {
2761        clearInsideReactTreeTimeout.clear();
2762        dataRef.current.insideReactTree = false;
2763      });
2764      const hasBlockingChild = useStableCallback((bubbleKey) => {
2765        const nodeId = dataRef.current.floatingContext?.nodeId;
2766        const children = tree ? getNodeChildren(tree.nodesRef.current, nodeId) : [];
2767        return children.some((child) => child.context?.open && !child.context.dataRef.current[bubbleKey]);
2768      });
2769      const isEventWithinOwnElements = useStableCallback((event) => {
2770        return isEventTargetWithin(event, store2.select("floatingElement")) || isEventTargetWithin(event, store2.select("domReferenceElement"));
2771      });
2772      const closeOnReferencePress = useStableCallback((event) => {
2773        if (!referencePress()) {
2774          return;
2775        }
2776        store2.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerPress, event.nativeEvent));
2777      });
2778      const closeOnEscapeKeyDown = useStableCallback((event) => {
2779        if (!open || !enabled || !escapeKey2 || event.key !== "Escape") {
2780          return;
2781        }
2782        if (isComposingRef.current) {
2783          return;
2784        }
2785        if (!escapeKeyBubbles && hasBlockingChild("__escapeKeyBubbles")) {
2786          return;
2787        }
2788        const native = isReactEvent(event) ? event.nativeEvent : event;
2789        const eventDetails = createChangeEventDetails(reason_parts_exports.escapeKey, native);
2790        store2.setOpen(false, eventDetails);
2791        if (!eventDetails.isCanceled) {
2792          event.preventDefault();
2793        }
2794        if (!escapeKeyBubbles && !eventDetails.isPropagationAllowed) {
2795          event.stopPropagation();
2796        }
2797      });
2798      const markInsideReactTree = useStableCallback(() => {
2799        dataRef.current.insideReactTree = true;
2800        clearInsideReactTreeTimeout.start(0, clearInsideReactTree);
2801      });
2802      const markPressStartedInsideReactTree = useStableCallback((event) => {
2803        if (!open || !enabled || event.button !== 0) {
2804          return;
2805        }
2806        const target = getTarget(event.nativeEvent);
2807        if (!contains(store2.select("floatingElement"), target)) {
2808          return;
2809        }
2810        if (!pressStartedInsideRef.current) {
2811          pressStartedInsideRef.current = true;
2812          pressStartPreventedRef.current = false;
2813        }
2814      });
2815      const markInsidePressStartPrevented = useStableCallback((event) => {
2816        if (!open || !enabled) {
2817          return;
2818        }
2819        if (!(event.defaultPrevented || event.nativeEvent.defaultPrevented)) {
2820          return;
2821        }
2822        if (pressStartedInsideRef.current) {
2823          pressStartPreventedRef.current = true;
2824        }
2825      });
2826      React16.useEffect(() => {
2827        if (!open || !enabled) {
2828          return clearInsideReactTree;
2829        }
2830        dataRef.current.__escapeKeyBubbles = escapeKeyBubbles;
2831        dataRef.current.__outsidePressBubbles = outsidePressBubbles;
2832        const compositionTimeout = new Timeout();
2833        const preventedPressSuppressionTimeout = new Timeout();
2834        function handleCompositionStart() {
2835          compositionTimeout.clear();
2836          isComposingRef.current = true;
2837        }
2838        function handleCompositionEnd() {
2839          compositionTimeout.start(
2840            // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
2841            // Only apply to WebKit for the test to remain 0ms.
2842            parts_exports.engine.webkit ? 5 : 0,
2843            () => {
2844              isComposingRef.current = false;
2845            }
2846          );
2847        }
2848        function suppressImmediateOutsideClickAfterPreventedStart() {
2849          suppressNextOutsideClickRef.current = true;
2850          preventedPressSuppressionTimeout.start(0, () => {
2851            suppressNextOutsideClickRef.current = false;
2852          });
2853        }
2854        function resetPressStartState() {
2855          pressStartedInsideRef.current = false;
2856          pressStartPreventedRef.current = false;
2857        }
2858        function getOutsidePressEvent() {
2859          const type = currentPointerTypeRef.current;
2860          const computedType = type === "pen" || !type ? "mouse" : type;
2861          const outsidePressEventValue = getOutsidePressEventProp();
2862          const resolved = typeof outsidePressEventValue === "function" ? outsidePressEventValue() : outsidePressEventValue;
2863          if (typeof resolved === "string") {
2864            return resolved;
2865          }
2866          return resolved[computedType];
2867        }
2868        function shouldIgnoreEvent(event) {
2869          const computedOutsidePressEvent = getOutsidePressEvent();
2870          return computedOutsidePressEvent === "intentional" && event.type !== "click" || computedOutsidePressEvent === "sloppy" && event.type === "click";
2871        }
2872        function isEventWithinFloatingTree(event) {
2873          const nodeId = dataRef.current.floatingContext?.nodeId;
2874          const targetIsInsideChildren = tree && getNodeChildren(tree.nodesRef.current, nodeId).some((node) => isEventTargetWithin(event, node.context?.elements.floating));
2875          return isEventWithinOwnElements(event) || targetIsInsideChildren;
2876        }
2877        function closeOnPressOutside(event) {
2878          if (shouldIgnoreEvent(event)) {
2879            if (event.type !== "click" && !isEventWithinOwnElements(event)) {
2880              preventedPressSuppressionTimeout.clear();
2881              suppressNextOutsideClickRef.current = false;
2882            }
2883            clearInsideReactTree();
2884            return;
2885          }
2886          if (dataRef.current.insideReactTree) {
2887            clearInsideReactTree();
2888            return;
2889          }
2890          const target = getTarget(event);
2891          const inertSelector = `[$createAttribute("inert")}]`;
2892          const targetRoot = isElement(target) ? target.getRootNode() : null;
2893          const markers = Array.from((isShadowRoot(targetRoot) ? targetRoot : ownerDocument(store2.select("floatingElement"))).querySelectorAll(inertSelector));
2894          const triggers = store2.context.triggerElements;
2895          if (target && (triggers.hasElement(target) || triggers.hasMatchingElement((trigger) => contains(trigger, target)))) {
2896            return;
2897          }
2898          let targetRootAncestor = isElement(target) ? target : null;
2899          while (targetRootAncestor && !isLastTraversableNode(targetRootAncestor)) {
2900            const nextParent = getParentNode(targetRootAncestor);
2901            if (isLastTraversableNode(nextParent) || !isElement(nextParent)) {
2902              break;
2903            }
2904            targetRootAncestor = nextParent;
2905          }
2906          if (markers.length && isElement(target) && !isRootElement(target) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
2907          !contains(target, store2.select("floatingElement")) && // If the target root element contains none of the markers, then the
2908          // element was injected after the floating element rendered.
2909          markers.every((marker) => !contains(targetRootAncestor, marker))) {
2910            return;
2911          }
2912          if (isHTMLElement(target) && !("touches" in event)) {
2913            const lastTraversableNode = isLastTraversableNode(target);
2914            const style = getComputedStyle2(target);
2915            const scrollRe = /auto|scroll/;
2916            const isScrollableX = lastTraversableNode || scrollRe.test(style.overflowX);
2917            const isScrollableY = lastTraversableNode || scrollRe.test(style.overflowY);
2918            const canScrollX = isScrollableX && target.clientWidth > 0 && target.scrollWidth > target.clientWidth;
2919            const canScrollY = isScrollableY && target.clientHeight > 0 && target.scrollHeight > target.clientHeight;
2920            const isRTL4 = style.direction === "rtl";
2921            const pressedVerticalScrollbar = canScrollY && (isRTL4 ? event.offsetX <= target.offsetWidth - target.clientWidth : event.offsetX > target.clientWidth);
2922            const pressedHorizontalScrollbar = canScrollX && event.offsetY > target.clientHeight;
2923            if (pressedVerticalScrollbar || pressedHorizontalScrollbar) {
2924              return;
2925            }
2926          }
2927          if (isEventWithinFloatingTree(event)) {
2928            return;
2929          }
2930          if (getOutsidePressEvent() === "intentional" && suppressNextOutsideClickRef.current) {
2931            preventedPressSuppressionTimeout.clear();
2932            suppressNextOutsideClickRef.current = false;
2933            return;
2934          }
2935          if (typeof outsidePress2 === "function" && !outsidePress2(event)) {
2936            return;
2937          }
2938          if (hasBlockingChild("__outsidePressBubbles")) {
2939            return;
2940          }
2941          store2.setOpen(false, createChangeEventDetails(reason_parts_exports.outsidePress, event));
2942          clearInsideReactTree();
2943        }
2944        function handlePointerDown(event) {
2945          if (getOutsidePressEvent() !== "sloppy" || event.pointerType === "touch" || !store2.select("open") || !enabled || isEventWithinOwnElements(event)) {
2946            return;
2947          }
2948          closeOnPressOutside(event);
2949        }
2950        function handleTouchStart(event) {
2951          if (getOutsidePressEvent() !== "sloppy" || !store2.select("open") || !enabled || isEventWithinOwnElements(event)) {
2952            return;
2953          }
2954          const touch = event.touches[0];
2955          if (touch) {
2956            touchStateRef.current = {
2957              startTime: Date.now(),
2958              startX: touch.clientX,
2959              startY: touch.clientY,
2960              dismissOnTouchEnd: false,
2961              dismissOnMouseDown: true
2962            };
2963            cancelDismissOnEndTimeout.start(1e3, () => {
2964              if (touchStateRef.current) {
2965                touchStateRef.current.dismissOnTouchEnd = false;
2966                touchStateRef.current.dismissOnMouseDown = false;
2967              }
2968            });
2969          }
2970        }
2971        function addTargetEventListenerOnce(event, listener) {
2972          const target = getTarget(event);
2973          if (!target) {
2974            return;
2975          }
2976          const unsubscribe2 = addEventListener(target, event.type, () => {
2977            listener(event);
2978            unsubscribe2();
2979          });
2980        }
2981        function handleTouchStartCapture(event) {
2982          currentPointerTypeRef.current = "touch";
2983          addTargetEventListenerOnce(event, handleTouchStart);
2984        }
2985        function closeOnPressOutsideCapture(event) {
2986          cancelDismissOnEndTimeout.clear();
2987          if (event.type === "pointerdown") {
2988            currentPointerTypeRef.current = event.pointerType;
2989          }
2990          if (event.type === "mousedown" && touchStateRef.current && !touchStateRef.current.dismissOnMouseDown) {
2991            return;
2992          }
2993          addTargetEventListenerOnce(event, (targetEvent) => {
2994            if (targetEvent.type === "pointerdown") {
2995              handlePointerDown(targetEvent);
2996            } else {
2997              closeOnPressOutside(targetEvent);
2998            }
2999          });
3000        }
3001        function handlePressEndCapture(event) {
3002          if (!pressStartedInsideRef.current) {
3003            return;
3004          }
3005          const pressStartedInsideDefaultPrevented = pressStartPreventedRef.current;
3006          resetPressStartState();
3007          if (getOutsidePressEvent() !== "intentional") {
3008            return;
3009          }
3010          if (event.type === "pointercancel") {
3011            if (pressStartedInsideDefaultPrevented) {
3012              suppressImmediateOutsideClickAfterPreventedStart();
3013            }
3014            return;
3015          }
3016          if (isEventWithinFloatingTree(event)) {
3017            return;
3018          }
3019          if (pressStartedInsideDefaultPrevented) {
3020            suppressImmediateOutsideClickAfterPreventedStart();
3021            return;
3022          }
3023          if (typeof outsidePress2 === "function" && !outsidePress2(event)) {
3024            return;
3025          }
3026          preventedPressSuppressionTimeout.clear();
3027          suppressNextOutsideClickRef.current = true;
3028          clearInsideReactTree();
3029        }
3030        function handleTouchMove(event) {
3031          if (getOutsidePressEvent() !== "sloppy" || !touchStateRef.current || isEventWithinOwnElements(event)) {
3032            return;
3033          }
3034          const touch = event.touches[0];
3035          if (!touch) {
3036            return;
3037          }
3038          const deltaX = Math.abs(touch.clientX - touchStateRef.current.startX);
3039          const deltaY = Math.abs(touch.clientY - touchStateRef.current.startY);
3040          const distance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
3041          if (distance > 5) {
3042            touchStateRef.current.dismissOnTouchEnd = true;
3043          }
3044          if (distance > 10) {
3045            closeOnPressOutside(event);
3046            cancelDismissOnEndTimeout.clear();
3047            touchStateRef.current = null;
3048          }
3049        }
3050        function handleTouchMoveCapture(event) {
3051          addTargetEventListenerOnce(event, handleTouchMove);
3052        }
3053        function handleTouchEnd(event) {
3054          if (getOutsidePressEvent() !== "sloppy" || !touchStateRef.current || isEventWithinOwnElements(event)) {
3055            return;
3056          }
3057          if (touchStateRef.current.dismissOnTouchEnd) {
3058            closeOnPressOutside(event);
3059          }
3060          cancelDismissOnEndTimeout.clear();
3061          touchStateRef.current = null;
3062        }
3063        function handleTouchEndCapture(event) {
3064          addTargetEventListenerOnce(event, handleTouchEnd);
3065        }
3066        const doc = ownerDocument(floatingElement);
3067        const unsubscribe = mergeCleanups(escapeKey2 && mergeCleanups(addEventListener(doc, "keydown", closeOnEscapeKeyDown), addEventListener(doc, "compositionstart", handleCompositionStart), addEventListener(doc, "compositionend", handleCompositionEnd)), outsidePressEnabled && mergeCleanups(addEventListener(doc, "click", closeOnPressOutsideCapture, true), addEventListener(doc, "pointerdown", closeOnPressOutsideCapture, true), addEventListener(doc, "pointerup", handlePressEndCapture, true), addEventListener(doc, "pointercancel", handlePressEndCapture, true), addEventListener(doc, "mousedown", closeOnPressOutsideCapture, true), addEventListener(doc, "mouseup", handlePressEndCapture, true), addEventListener(doc, "touchstart", handleTouchStartCapture, true), addEventListener(doc, "touchmove", handleTouchMoveCapture, true), addEventListener(doc, "touchend", handleTouchEndCapture, true)));
3068        return () => {
3069          unsubscribe();
3070          compositionTimeout.clear();
3071          preventedPressSuppressionTimeout.clear();
3072          resetPressStartState();
3073          suppressNextOutsideClickRef.current = false;
3074          clearInsideReactTree();
3075        };
3076      }, [dataRef, floatingElement, escapeKey2, outsidePressEnabled, outsidePress2, open, enabled, escapeKeyBubbles, outsidePressBubbles, closeOnEscapeKeyDown, clearInsideReactTree, getOutsidePressEventProp, hasBlockingChild, isEventWithinOwnElements, tree, store2, cancelDismissOnEndTimeout]);
3077      const reference = React16.useMemo(() => ({
3078        onKeyDown: closeOnEscapeKeyDown,
3079        onPointerDown: closeOnReferencePress,
3080        onClick: closeOnReferencePress
3081      }), [closeOnEscapeKeyDown, closeOnReferencePress]);
3082      const floating = React16.useMemo(() => ({
3083        onKeyDown: closeOnEscapeKeyDown,
3084        // `onMouseDown` may be blocked if `event.preventDefault()` is called in
3085        // `onPointerDown`, such as with <NumberField.ScrubArea>.
3086        // See https://github.com/mui/base-ui/pull/3379
3087        onPointerDown: markInsidePressStartPrevented,
3088        onMouseDown: markInsidePressStartPrevented,
3089        onClickCapture: markInsideReactTree,
3090        onMouseDownCapture(event) {
3091          markInsideReactTree();
3092          markPressStartedInsideReactTree(event);
3093        },
3094        onPointerDownCapture(event) {
3095          markInsideReactTree();
3096          markPressStartedInsideReactTree(event);
3097        },
3098        onMouseUpCapture: markInsideReactTree,
3099        onTouchEndCapture: markInsideReactTree,
3100        onTouchMoveCapture: markInsideReactTree
3101      }), [closeOnEscapeKeyDown, markInsideReactTree, markPressStartedInsideReactTree, markInsidePressStartPrevented]);
3102      return React16.useMemo(() => enabled ? {
3103        reference,
3104        floating,
3105        trigger: reference
3106      } : {}, [enabled, reference, floating]);
3107    }
3108  
3109    // node_modules/@base-ui/react/floating-ui-react/hooks/useFloating.mjs
3110    var React24 = __toESM(require_react(), 1);
3111  
3112    // node_modules/@floating-ui/core/dist/floating-ui.core.mjs
3113    function computeCoordsFromPlacement(_ref, placement, rtl) {
3114      let {
3115        reference,
3116        floating
3117      } = _ref;
3118      const sideAxis = getSideAxis(placement);
3119      const alignmentAxis = getAlignmentAxis(placement);
3120      const alignLength = getAxisLength(alignmentAxis);
3121      const side = getSide(placement);
3122      const isVertical = sideAxis === "y";
3123      const commonX = reference.x + reference.width / 2 - floating.width / 2;
3124      const commonY = reference.y + reference.height / 2 - floating.height / 2;
3125      const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
3126      let coords;
3127      switch (side) {
3128        case "top":
3129          coords = {
3130            x: commonX,
3131            y: reference.y - floating.height
3132          };
3133          break;
3134        case "bottom":
3135          coords = {
3136            x: commonX,
3137            y: reference.y + reference.height
3138          };
3139          break;
3140        case "right":
3141          coords = {
3142            x: reference.x + reference.width,
3143            y: commonY
3144          };
3145          break;
3146        case "left":
3147          coords = {
3148            x: reference.x - floating.width,
3149            y: commonY
3150          };
3151          break;
3152        default:
3153          coords = {
3154            x: reference.x,
3155            y: reference.y
3156          };
3157      }
3158      const alignment = getAlignment(placement);
3159      if (alignment) {
3160        coords[alignmentAxis] += commonAlign * (alignment === "end" ? 1 : -1) * (rtl && isVertical ? -1 : 1);
3161      }
3162      return coords;
3163    }
3164    async function detectOverflow(state, options) {
3165      var _await$platform$isEle;
3166      if (options === void 0) {
3167        options = {};
3168      }
3169      const {
3170        x,
3171        y,
3172        platform: platform3,
3173        rects,
3174        elements,
3175        strategy
3176      } = state;
3177      const {
3178        boundary = "clippingAncestors",
3179        rootBoundary = "viewport",
3180        elementContext = "floating",
3181        altBoundary = false,
3182        padding = 0
3183      } = evaluate(options, state);
3184      const paddingObject = getPaddingObject(padding);
3185      const altContext = elementContext === "floating" ? "reference" : "floating";
3186      const element = elements[altBoundary ? altContext : elementContext];
3187      const clippingClientRect = rectToClientRect(await platform3.getClippingRect({
3188        element: ((_await$platform$isEle = await (platform3.isElement == null ? void 0 : platform3.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform3.getDocumentElement == null ? void 0 : platform3.getDocumentElement(elements.floating)),
3189        boundary,
3190        rootBoundary,
3191        strategy
3192      }));
3193      const rect = elementContext === "floating" ? {
3194        x,
3195        y,
3196        width: rects.floating.width,
3197        height: rects.floating.height
3198      } : rects.reference;
3199      const offsetParent = await (platform3.getOffsetParent == null ? void 0 : platform3.getOffsetParent(elements.floating));
3200      const offsetScale = await (platform3.isElement == null ? void 0 : platform3.isElement(offsetParent)) && await (platform3.getScale == null ? void 0 : platform3.getScale(offsetParent)) || {
3201        x: 1,
3202        y: 1
3203      };
3204      const elementClientRect = rectToClientRect(platform3.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform3.convertOffsetParentRelativeRectToViewportRelativeRect({
3205        elements,
3206        rect,
3207        offsetParent,
3208        strategy
3209      }) : rect);
3210      return {
3211        top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
3212        bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
3213        left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
3214        right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
3215      };
3216    }
3217    var MAX_RESET_COUNT = 50;
3218    var computePosition = async (reference, floating, config) => {
3219      const {
3220        placement = "bottom",
3221        strategy = "absolute",
3222        middleware = [],
3223        platform: platform3
3224      } = config;
3225      const platformWithDetectOverflow = platform3.detectOverflow ? platform3 : {
3226        ...platform3,
3227        detectOverflow
3228      };
3229      const rtl = await (platform3.isRTL == null ? void 0 : platform3.isRTL(floating));
3230      let rects = await platform3.getElementRects({
3231        reference,
3232        floating,
3233        strategy
3234      });
3235      let {
3236        x,
3237        y
3238      } = computeCoordsFromPlacement(rects, placement, rtl);
3239      let statefulPlacement = placement;
3240      let resetCount = 0;
3241      const middlewareData = {};
3242      for (let i = 0; i < middleware.length; i++) {
3243        const currentMiddleware = middleware[i];
3244        if (!currentMiddleware) {
3245          continue;
3246        }
3247        const {
3248          name,
3249          fn
3250        } = currentMiddleware;
3251        const {
3252          x: nextX,
3253          y: nextY,
3254          data,
3255          reset
3256        } = await fn({
3257          x,
3258          y,
3259          initialPlacement: placement,
3260          placement: statefulPlacement,
3261          strategy,
3262          middlewareData,
3263          rects,
3264          platform: platformWithDetectOverflow,
3265          elements: {
3266            reference,
3267            floating
3268          }
3269        });
3270        x = nextX != null ? nextX : x;
3271        y = nextY != null ? nextY : y;
3272        middlewareData[name] = {
3273          ...middlewareData[name],
3274          ...data
3275        };
3276        if (reset && resetCount < MAX_RESET_COUNT) {
3277          resetCount++;
3278          if (typeof reset === "object") {
3279            if (reset.placement) {
3280              statefulPlacement = reset.placement;
3281            }
3282            if (reset.rects) {
3283              rects = reset.rects === true ? await platform3.getElementRects({
3284                reference,
3285                floating,
3286                strategy
3287              }) : reset.rects;
3288            }
3289            ({
3290              x,
3291              y
3292            } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
3293          }
3294          i = -1;
3295        }
3296      }
3297      return {
3298        x,
3299        y,
3300        placement: statefulPlacement,
3301        strategy,
3302        middlewareData
3303      };
3304    };
3305    var flip = function(options) {
3306      if (options === void 0) {
3307        options = {};
3308      }
3309      return {
3310        name: "flip",
3311        options,
3312        async fn(state) {
3313          var _middlewareData$arrow, _middlewareData$flip;
3314          const {
3315            placement,
3316            middlewareData,
3317            rects,
3318            initialPlacement,
3319            platform: platform3,
3320            elements
3321          } = state;
3322          const {
3323            mainAxis: checkMainAxis = true,
3324            crossAxis: checkCrossAxis = true,
3325            fallbackPlacements: specifiedFallbackPlacements,
3326            fallbackStrategy = "bestFit",
3327            fallbackAxisSideDirection = "none",
3328            flipAlignment = true,
3329            ...detectOverflowOptions
3330          } = evaluate(options, state);
3331          if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
3332            return {};
3333          }
3334          const side = getSide(placement);
3335          const initialSideAxis = getSideAxis(initialPlacement);
3336          const isBasePlacement = getSide(initialPlacement) === initialPlacement;
3337          const rtl = await (platform3.isRTL == null ? void 0 : platform3.isRTL(elements.floating));
3338          const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
3339          const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
3340          if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
3341            fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
3342          }
3343          const placements2 = [initialPlacement, ...fallbackPlacements];
3344          const overflow = await platform3.detectOverflow(state, detectOverflowOptions);
3345          const overflows = [];
3346          let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
3347          if (checkMainAxis) {
3348            overflows.push(overflow[side]);
3349          }
3350          if (checkCrossAxis) {
3351            const sides2 = getAlignmentSides(placement, rects, rtl);
3352            overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
3353          }
3354          overflowsData = [...overflowsData, {
3355            placement,
3356            overflows
3357          }];
3358          if (!overflows.every((side2) => side2 <= 0)) {
3359            var _middlewareData$flip2, _overflowsData$filter;
3360            const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
3361            const nextPlacement = placements2[nextIndex];
3362            if (nextPlacement) {
3363              const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
3364              if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
3365              // overflows the main axis.
3366              overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
3367                return {
3368                  data: {
3369                    index: nextIndex,
3370                    overflows: overflowsData
3371                  },
3372                  reset: {
3373                    placement: nextPlacement
3374                  }
3375                };
3376              }
3377            }
3378            let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
3379            if (!resetPlacement) {
3380              switch (fallbackStrategy) {
3381                case "bestFit": {
3382                  var _overflowsData$filter2;
3383                  const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => {
3384                    if (hasFallbackAxisSideDirection) {
3385                      const currentSideAxis = getSideAxis(d.placement);
3386                      return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
3387                      // reading directions favoring greater width.
3388                      currentSideAxis === "y";
3389                    }
3390                    return true;
3391                  }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
3392                  if (placement2) {
3393                    resetPlacement = placement2;
3394                  }
3395                  break;
3396                }
3397                case "initialPlacement":
3398                  resetPlacement = initialPlacement;
3399                  break;
3400              }
3401            }
3402            if (placement !== resetPlacement) {
3403              return {
3404                reset: {
3405                  placement: resetPlacement
3406                }
3407              };
3408            }
3409          }
3410          return {};
3411        }
3412      };
3413    };
3414    var originSides = /* @__PURE__ */ new Set(["left", "top"]);
3415    async function convertValueToCoords(state, options) {
3416      const {
3417        placement,
3418        platform: platform3,
3419        elements
3420      } = state;
3421      const rtl = await (platform3.isRTL == null ? void 0 : platform3.isRTL(elements.floating));
3422      const side = getSide(placement);
3423      const alignment = getAlignment(placement);
3424      const isVertical = getSideAxis(placement) === "y";
3425      const mainAxisMulti = originSides.has(side) ? -1 : 1;
3426      const crossAxisMulti = rtl && isVertical ? -1 : 1;
3427      const rawValue = evaluate(options, state);
3428      let {
3429        mainAxis,
3430        crossAxis,
3431        alignmentAxis
3432      } = typeof rawValue === "number" ? {
3433        mainAxis: rawValue,
3434        crossAxis: 0,
3435        alignmentAxis: null
3436      } : {
3437        mainAxis: rawValue.mainAxis || 0,
3438        crossAxis: rawValue.crossAxis || 0,
3439        alignmentAxis: rawValue.alignmentAxis
3440      };
3441      if (alignment && typeof alignmentAxis === "number") {
3442        crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
3443      }
3444      return isVertical ? {
3445        x: crossAxis * crossAxisMulti,
3446        y: mainAxis * mainAxisMulti
3447      } : {
3448        x: mainAxis * mainAxisMulti,
3449        y: crossAxis * crossAxisMulti
3450      };
3451    }
3452    var offset = function(options) {
3453      if (options === void 0) {
3454        options = 0;
3455      }
3456      return {
3457        name: "offset",
3458        options,
3459        async fn(state) {
3460          var _middlewareData$offse, _middlewareData$arrow;
3461          const {
3462            x,
3463            y,
3464            placement,
3465            middlewareData
3466          } = state;
3467          const diffCoords = await convertValueToCoords(state, options);
3468          if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
3469            return {};
3470          }
3471          return {
3472            x: x + diffCoords.x,
3473            y: y + diffCoords.y,
3474            data: {
3475              ...diffCoords,
3476              placement
3477            }
3478          };
3479        }
3480      };
3481    };
3482    var shift = function(options) {
3483      if (options === void 0) {
3484        options = {};
3485      }
3486      return {
3487        name: "shift",
3488        options,
3489        async fn(state) {
3490          const {
3491            x,
3492            y,
3493            placement,
3494            platform: platform3
3495          } = state;
3496          const {
3497            mainAxis: checkMainAxis = true,
3498            crossAxis: checkCrossAxis = false,
3499            limiter = {
3500              fn: (_ref) => {
3501                let {
3502                  x: x2,
3503                  y: y2
3504                } = _ref;
3505                return {
3506                  x: x2,
3507                  y: y2
3508                };
3509              }
3510            },
3511            ...detectOverflowOptions
3512          } = evaluate(options, state);
3513          const coords = {
3514            x,
3515            y
3516          };
3517          const overflow = await platform3.detectOverflow(state, detectOverflowOptions);
3518          const crossAxis = getSideAxis(placement);
3519          const mainAxis = getOppositeAxis(crossAxis);
3520          let mainAxisCoord = coords[mainAxis];
3521          let crossAxisCoord = coords[crossAxis];
3522          const clampCoord = (axis, coord) => clamp(coord + overflow[axis === "y" ? "top" : "left"], coord, coord - overflow[axis === "y" ? "bottom" : "right"]);
3523          if (checkMainAxis) {
3524            mainAxisCoord = clampCoord(mainAxis, mainAxisCoord);
3525          }
3526          if (checkCrossAxis) {
3527            crossAxisCoord = clampCoord(crossAxis, crossAxisCoord);
3528          }
3529          const limitedCoords = limiter.fn({
3530            ...state,
3531            [mainAxis]: mainAxisCoord,
3532            [crossAxis]: crossAxisCoord
3533          });
3534          return {
3535            ...limitedCoords,
3536            data: {
3537              x: limitedCoords.x - x,
3538              y: limitedCoords.y - y,
3539              enabled: {
3540                [mainAxis]: checkMainAxis,
3541                [crossAxis]: checkCrossAxis
3542              }
3543            }
3544          };
3545        }
3546      };
3547    };
3548    var limitShift = function(options) {
3549      if (options === void 0) {
3550        options = {};
3551      }
3552      return {
3553        options,
3554        fn(state) {
3555          var _rawOffset$mainAxis, _rawOffset$crossAxis;
3556          const {
3557            x,
3558            y,
3559            placement,
3560            rects,
3561            middlewareData
3562          } = state;
3563          const {
3564            offset: offset4 = 0,
3565            mainAxis: checkMainAxis = true,
3566            crossAxis: checkCrossAxis = true
3567          } = evaluate(options, state);
3568          const coords = {
3569            x,
3570            y
3571          };
3572          const crossAxis = getSideAxis(placement);
3573          const mainAxis = getOppositeAxis(crossAxis);
3574          let mainAxisCoord = coords[mainAxis];
3575          let crossAxisCoord = coords[crossAxis];
3576          const rawOffset = evaluate(offset4, state);
3577          const computedOffset = typeof rawOffset === "number" ? {
3578            mainAxis: rawOffset,
3579            crossAxis: 0
3580          } : {
3581            mainAxis: (_rawOffset$mainAxis = rawOffset.mainAxis) != null ? _rawOffset$mainAxis : 0,
3582            crossAxis: (_rawOffset$crossAxis = rawOffset.crossAxis) != null ? _rawOffset$crossAxis : 0
3583          };
3584          if (checkMainAxis) {
3585            const len = mainAxis === "y" ? "height" : "width";
3586            const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
3587            const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
3588            if (mainAxisCoord < limitMin) {
3589              mainAxisCoord = limitMin;
3590            } else if (mainAxisCoord > limitMax) {
3591              mainAxisCoord = limitMax;
3592            }
3593          }
3594          if (checkCrossAxis) {
3595            var _middlewareData$offse, _middlewareData$offse2;
3596            const len = mainAxis === "y" ? "width" : "height";
3597            const isOriginSide = originSides.has(getSide(placement));
3598            const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
3599            const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
3600            if (crossAxisCoord < limitMin) {
3601              crossAxisCoord = limitMin;
3602            } else if (crossAxisCoord > limitMax) {
3603              crossAxisCoord = limitMax;
3604            }
3605          }
3606          return {
3607            [mainAxis]: mainAxisCoord,
3608            [crossAxis]: crossAxisCoord
3609          };
3610        }
3611      };
3612    };
3613    var size = function(options) {
3614      if (options === void 0) {
3615        options = {};
3616      }
3617      return {
3618        name: "size",
3619        options,
3620        async fn(state) {
3621          const {
3622            placement,
3623            rects,
3624            platform: platform3,
3625            elements
3626          } = state;
3627          const {
3628            apply = () => {
3629            },
3630            ...detectOverflowOptions
3631          } = evaluate(options, state);
3632          const overflow = await platform3.detectOverflow(state, detectOverflowOptions);
3633          const side = getSide(placement);
3634          const alignment = getAlignment(placement);
3635          const isYAxis = getSideAxis(placement) === "y";
3636          const {
3637            width,
3638            height
3639          } = rects.floating;
3640          let heightSide;
3641          let widthSide;
3642          if (side === "top" || side === "bottom") {
3643            heightSide = side;
3644            widthSide = alignment === (await (platform3.isRTL == null ? void 0 : platform3.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
3645          } else {
3646            widthSide = side;
3647            heightSide = alignment === "end" ? "top" : "bottom";
3648          }
3649          const maximumClippingHeight = height - overflow.top - overflow.bottom;
3650          const maximumClippingWidth = width - overflow.left - overflow.right;
3651          const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
3652          const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
3653          const shiftData = state.middlewareData.shift;
3654          const noShift = !shiftData;
3655          let availableHeight = overflowAvailableHeight;
3656          let availableWidth = overflowAvailableWidth;
3657          if (shiftData != null && shiftData.enabled.x) {
3658            availableWidth = maximumClippingWidth;
3659          }
3660          if (shiftData != null && shiftData.enabled.y) {
3661            availableHeight = maximumClippingHeight;
3662          }
3663          if (noShift && !alignment) {
3664            if (isYAxis) {
3665              availableWidth = width - 2 * max(overflow.left, overflow.right);
3666            } else {
3667              availableHeight = height - 2 * max(overflow.top, overflow.bottom);
3668            }
3669          }
3670          await apply({
3671            ...state,
3672            availableWidth,
3673            availableHeight
3674          });
3675          const nextDimensions = await platform3.getDimensions(elements.floating);
3676          if (width !== nextDimensions.width || height !== nextDimensions.height) {
3677            return {
3678              reset: {
3679                rects: true
3680              }
3681            };
3682          }
3683          return {};
3684        }
3685      };
3686    };
3687  
3688    // node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
3689    function getCssDimensions(element) {
3690      const css = getComputedStyle2(element);
3691      let width = parseFloat(css.width) || 0;
3692      let height = parseFloat(css.height) || 0;
3693      const hasOffset = isHTMLElement(element);
3694      const offsetWidth = hasOffset ? element.offsetWidth : width;
3695      const offsetHeight = hasOffset ? element.offsetHeight : height;
3696      const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
3697      if (shouldFallback) {
3698        width = offsetWidth;
3699        height = offsetHeight;
3700      }
3701      return {
3702        width,
3703        height,
3704        $: shouldFallback
3705      };
3706    }
3707    function unwrapElement(element) {
3708      return !isElement(element) ? element.contextElement : element;
3709    }
3710    function getScale(element) {
3711      const domElement = unwrapElement(element);
3712      if (!isHTMLElement(domElement)) {
3713        return createCoords(1);
3714      }
3715      const rect = domElement.getBoundingClientRect();
3716      const {
3717        width,
3718        height,
3719        $
3720      } = getCssDimensions(domElement);
3721      let x = ($ ? round(rect.width) : rect.width) / width;
3722      let y = ($ ? round(rect.height) : rect.height) / height;
3723      if (!x || !Number.isFinite(x)) {
3724        x = 1;
3725      }
3726      if (!y || !Number.isFinite(y)) {
3727        y = 1;
3728      }
3729      return {
3730        x,
3731        y
3732      };
3733    }
3734    var noOffsets = /* @__PURE__ */ createCoords(0);
3735    function getVisualOffsets(element) {
3736      const win = getWindow(element);
3737      if (!isWebKit() || !win.visualViewport) {
3738        return noOffsets;
3739      }
3740      return {
3741        x: win.visualViewport.offsetLeft,
3742        y: win.visualViewport.offsetTop
3743      };
3744    }
3745    function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
3746      if (isFixed === void 0) {
3747        isFixed = false;
3748      }
3749      return !!floatingOffsetParent && isFixed && floatingOffsetParent === getWindow(element);
3750    }
3751    function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
3752      if (includeScale === void 0) {
3753        includeScale = false;
3754      }
3755      if (isFixedStrategy === void 0) {
3756        isFixedStrategy = false;
3757      }
3758      const clientRect = element.getBoundingClientRect();
3759      const domElement = unwrapElement(element);
3760      let scale = createCoords(1);
3761      if (includeScale) {
3762        if (offsetParent) {
3763          if (isElement(offsetParent)) {
3764            scale = getScale(offsetParent);
3765          }
3766        } else {
3767          scale = getScale(element);
3768        }
3769      }
3770      const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
3771      let x = (clientRect.left + visualOffsets.x) / scale.x;
3772      let y = (clientRect.top + visualOffsets.y) / scale.y;
3773      let width = clientRect.width / scale.x;
3774      let height = clientRect.height / scale.y;
3775      if (domElement && offsetParent) {
3776        const win = getWindow(domElement);
3777        const offsetWin = isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
3778        let currentWin = win;
3779        let currentIFrame = getFrameElement(currentWin);
3780        while (currentIFrame && offsetWin !== currentWin) {
3781          const iframeScale = getScale(currentIFrame);
3782          const iframeRect = currentIFrame.getBoundingClientRect();
3783          const css = getComputedStyle2(currentIFrame);
3784          const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
3785          const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
3786          x *= iframeScale.x;
3787          y *= iframeScale.y;
3788          width *= iframeScale.x;
3789          height *= iframeScale.y;
3790          x += left;
3791          y += top;
3792          currentWin = getWindow(currentIFrame);
3793          currentIFrame = getFrameElement(currentWin);
3794        }
3795      }
3796      return rectToClientRect({
3797        width,
3798        height,
3799        x,
3800        y
3801      });
3802    }
3803    function getWindowScrollBarX(element, rect) {
3804      const leftScroll = getNodeScroll(element).scrollLeft;
3805      if (!rect) {
3806        return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
3807      }
3808      return rect.left + leftScroll;
3809    }
3810    function getHTMLOffset(documentElement, scroll) {
3811      const htmlRect = documentElement.getBoundingClientRect();
3812      const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
3813      const y = htmlRect.top + scroll.scrollTop;
3814      return {
3815        x,
3816        y
3817      };
3818    }
3819    function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
3820      let {
3821        elements,
3822        rect,
3823        offsetParent,
3824        strategy
3825      } = _ref;
3826      const isFixed = strategy === "fixed";
3827      const documentElement = getDocumentElement(offsetParent);
3828      const topLayer = elements ? isTopLayer(elements.floating) : false;
3829      if (offsetParent === documentElement || topLayer && isFixed) {
3830        return rect;
3831      }
3832      let scroll = {
3833        scrollLeft: 0,
3834        scrollTop: 0
3835      };
3836      let scale = createCoords(1);
3837      const offsets = createCoords(0);
3838      const isOffsetParentAnElement = isHTMLElement(offsetParent);
3839      if (isOffsetParentAnElement || !isFixed) {
3840        if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
3841          scroll = getNodeScroll(offsetParent);
3842        }
3843        if (isOffsetParentAnElement) {
3844          const offsetRect = getBoundingClientRect(offsetParent);
3845          scale = getScale(offsetParent);
3846          offsets.x = offsetRect.x + offsetParent.clientLeft;
3847          offsets.y = offsetRect.y + offsetParent.clientTop;
3848        }
3849      }
3850      const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
3851      return {
3852        width: rect.width * scale.x,
3853        height: rect.height * scale.y,
3854        x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x,
3855        y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y
3856      };
3857    }
3858    function getClientRects(element) {
3859      return element.getClientRects ? Array.from(element.getClientRects()) : [];
3860    }
3861    function getDocumentRect(html) {
3862      const scroll = getNodeScroll(html);
3863      const body = html.ownerDocument.body;
3864      const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
3865      const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
3866      let x = -scroll.scrollLeft + getWindowScrollBarX(html);
3867      const y = -scroll.scrollTop;
3868      if (getComputedStyle2(body).direction === "rtl") {
3869        x += max(html.clientWidth, body.clientWidth) - width;
3870      }
3871      return {
3872        width,
3873        height,
3874        x,
3875        y
3876      };
3877    }
3878    var SCROLLBAR_MAX = 25;
3879    function getViewportRect(element, strategy, rootBoundary) {
3880      if (rootBoundary === void 0) {
3881        rootBoundary = "viewport";
3882      }
3883      const isLayoutViewport = rootBoundary === "layoutViewport";
3884      const win = getWindow(element);
3885      const html = getDocumentElement(element);
3886      const visualViewport = win.visualViewport;
3887      let width = html.clientWidth;
3888      let height = html.clientHeight;
3889      let x = 0;
3890      let y = 0;
3891      if (visualViewport) {
3892        const layoutRelativeClientCoords = !isWebKit() || strategy === "fixed";
3893        if (isLayoutViewport) {
3894          if (!layoutRelativeClientCoords) {
3895            x = -visualViewport.offsetLeft;
3896            y = -visualViewport.offsetTop;
3897          }
3898        } else {
3899          width = visualViewport.width;
3900          height = visualViewport.height;
3901          if (layoutRelativeClientCoords) {
3902            x = visualViewport.offsetLeft;
3903            y = visualViewport.offsetTop;
3904          }
3905        }
3906      }
3907      const windowScrollbarX = getWindowScrollBarX(html);
3908      if (windowScrollbarX <= 0) {
3909        const doc = html.ownerDocument;
3910        const body = doc.body;
3911        const bodyStyles = getComputedStyle(body);
3912        const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
3913        const reservedWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
3914        const gutter = getComputedStyle(html).scrollbarGutter === "stable both-edges" ? reservedWidth / 2 : reservedWidth;
3915        if (gutter <= SCROLLBAR_MAX) {
3916          width -= gutter;
3917        }
3918      }
3919      return {
3920        width,
3921        height,
3922        x,
3923        y
3924      };
3925    }
3926    function getInnerBoundingClientRect(element, strategy) {
3927      const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
3928      const top = clientRect.top + element.clientTop;
3929      const left = clientRect.left + element.clientLeft;
3930      const scale = getScale(element);
3931      const width = element.clientWidth * scale.x;
3932      const height = element.clientHeight * scale.y;
3933      const x = left * scale.x;
3934      const y = top * scale.y;
3935      return {
3936        width,
3937        height,
3938        x,
3939        y
3940      };
3941    }
3942    function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
3943      let rect;
3944      if (clippingAncestor === "viewport" || clippingAncestor === "layoutViewport") {
3945        rect = getViewportRect(element, strategy, clippingAncestor);
3946      } else if (clippingAncestor === "document") {
3947        rect = getDocumentRect(getDocumentElement(element));
3948      } else if (isElement(clippingAncestor)) {
3949        rect = getInnerBoundingClientRect(clippingAncestor, strategy);
3950      } else {
3951        const visualOffsets = getVisualOffsets(element);
3952        rect = {
3953          x: clippingAncestor.x - visualOffsets.x,
3954          y: clippingAncestor.y - visualOffsets.y,
3955          width: clippingAncestor.width,
3956          height: clippingAncestor.height
3957        };
3958      }
3959      return rectToClientRect(rect);
3960    }
3961    function getClippingElementAncestors(element, cache) {
3962      const cachedResult = cache.get(element);
3963      if (cachedResult) {
3964        return cachedResult;
3965      }
3966      let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
3967      let lastKeptComputedStyle = null;
3968      const elementIsFixed = getComputedStyle2(element).position === "fixed";
3969      let currentNode = elementIsFixed ? getParentNode(element) : element;
3970      while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
3971        const computedStyle = getComputedStyle2(currentNode);
3972        const currentNodeIsContaining = isContainingBlock(currentNode);
3973        const lastPosition = lastKeptComputedStyle ? lastKeptComputedStyle.position : elementIsFixed ? "fixed" : "";
3974        const shouldDropCurrentNode = !currentNodeIsContaining && (lastPosition === "fixed" || lastPosition === "absolute" && computedStyle.position === "static");
3975        if (shouldDropCurrentNode) {
3976          result = result.filter((ancestor) => ancestor !== currentNode);
3977        } else {
3978          lastKeptComputedStyle = computedStyle;
3979        }
3980        currentNode = getParentNode(currentNode);
3981      }
3982      cache.set(element, result);
3983      return result;
3984    }
3985    function getClippingRect(_ref) {
3986      let {
3987        element,
3988        boundary,
3989        rootBoundary,
3990        strategy
3991      } = _ref;
3992      const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
3993      const clippingAncestors = [...elementClippingAncestors, rootBoundary];
3994      const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy);
3995      let top = firstRect.top;
3996      let right = firstRect.right;
3997      let bottom = firstRect.bottom;
3998      let left = firstRect.left;
3999      for (let i = 1; i < clippingAncestors.length; i++) {
4000        const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy);
4001        top = max(rect.top, top);
4002        right = min(rect.right, right);
4003        bottom = min(rect.bottom, bottom);
4004        left = max(rect.left, left);
4005      }
4006      return {
4007        width: right - left,
4008        height: bottom - top,
4009        x: left,
4010        y: top
4011      };
4012    }
4013    function getDimensions(element) {
4014      const {
4015        width,
4016        height
4017      } = getCssDimensions(element);
4018      return {
4019        width,
4020        height
4021      };
4022    }
4023    function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
4024      const isOffsetParentAnElement = isHTMLElement(offsetParent);
4025      const documentElement = getDocumentElement(offsetParent);
4026      const isFixed = strategy === "fixed";
4027      const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
4028      let scroll = {
4029        scrollLeft: 0,
4030        scrollTop: 0
4031      };
4032      const offsets = createCoords(0);
4033      if (isOffsetParentAnElement || !isFixed) {
4034        if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
4035          scroll = getNodeScroll(offsetParent);
4036        }
4037        if (isOffsetParentAnElement) {
4038          const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
4039          offsets.x = offsetRect.x + offsetParent.clientLeft;
4040          offsets.y = offsetRect.y + offsetParent.clientTop;
4041        }
4042      }
4043      if (!isOffsetParentAnElement && documentElement) {
4044        offsets.x = getWindowScrollBarX(documentElement);
4045      }
4046      const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
4047      const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
4048      const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
4049      return {
4050        x,
4051        y,
4052        width: rect.width,
4053        height: rect.height
4054      };
4055    }
4056    function isStaticPositioned(element) {
4057      return getComputedStyle2(element).position === "static";
4058    }
4059    function getTrueOffsetParent(element, polyfill) {
4060      if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") {
4061        return null;
4062      }
4063      if (polyfill) {
4064        return polyfill(element);
4065      }
4066      let rawOffsetParent = element.offsetParent;
4067      if (getDocumentElement(element) === rawOffsetParent) {
4068        rawOffsetParent = rawOffsetParent.ownerDocument.body;
4069      }
4070      return rawOffsetParent;
4071    }
4072    function getOffsetParent(element, polyfill) {
4073      const win = getWindow(element);
4074      if (isTopLayer(element)) {
4075        return win;
4076      }
4077      if (!isHTMLElement(element)) {
4078        let svgOffsetParent = getParentNode(element);
4079        while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
4080          if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
4081            return svgOffsetParent;
4082          }
4083          svgOffsetParent = getParentNode(svgOffsetParent);
4084        }
4085        return win;
4086      }
4087      let offsetParent = getTrueOffsetParent(element, polyfill);
4088      while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
4089        offsetParent = getTrueOffsetParent(offsetParent, polyfill);
4090      }
4091      if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
4092        return win;
4093      }
4094      return offsetParent || getContainingBlock(element) || win;
4095    }
4096    var getElementRects = async function(data) {
4097      const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
4098      const getDimensionsFn = this.getDimensions;
4099      const floatingDimensions = await getDimensionsFn(data.floating);
4100      return {
4101        reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
4102        floating: {
4103          x: 0,
4104          y: 0,
4105          width: floatingDimensions.width,
4106          height: floatingDimensions.height
4107        }
4108      };
4109    };
4110    function isRTL(element) {
4111      return getComputedStyle2(element).direction === "rtl";
4112    }
4113    var platform2 = {
4114      convertOffsetParentRelativeRectToViewportRelativeRect,
4115      getDocumentElement,
4116      getClippingRect,
4117      getOffsetParent,
4118      getElementRects,
4119      getClientRects,
4120      getDimensions,
4121      getScale,
4122      isElement,
4123      isRTL
4124    };
4125    function rectsAreEqual(a, b) {
4126      return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
4127    }
4128    function observeMove(element, onMove, ancestorResize) {
4129      let io = null;
4130      let timeoutId;
4131      const root = getDocumentElement(element);
4132      function cleanup() {
4133        var _io;
4134        clearTimeout(timeoutId);
4135        (_io = io) == null || _io.disconnect();
4136        io = null;
4137      }
4138      function refresh(skip, threshold) {
4139        if (skip === void 0) {
4140          skip = false;
4141        }
4142        if (threshold === void 0) {
4143          threshold = 1;
4144        }
4145        cleanup();
4146        const elementRectForRootMargin = element.getBoundingClientRect();
4147        const {
4148          left,
4149          top,
4150          width,
4151          height
4152        } = elementRectForRootMargin;
4153        if (!skip) {
4154          onMove();
4155        }
4156        if (!width || !height) {
4157          return;
4158        }
4159        const insetTop = floor(top);
4160        const insetRight = floor(root.clientWidth - (left + width));
4161        const insetBottom = floor(root.clientHeight - (top + height));
4162        const insetLeft = floor(left);
4163        const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
4164        const options = {
4165          rootMargin,
4166          threshold: max(0, min(1, threshold)) || 1
4167        };
4168        let isFirstUpdate = true;
4169        function handleObserve(entries) {
4170          const ratio = entries[0].intersectionRatio;
4171          if (!rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
4172            return refresh();
4173          }
4174          if (ratio !== threshold) {
4175            if (!isFirstUpdate) {
4176              return refresh();
4177            }
4178            if (!ratio) {
4179              timeoutId = setTimeout(() => {
4180                refresh(false, 1e-7);
4181              }, 1e3);
4182            } else {
4183              refresh(false, ratio);
4184            }
4185          }
4186          isFirstUpdate = false;
4187        }
4188        try {
4189          io = new IntersectionObserver(handleObserve, {
4190            ...options,
4191            // Handle <iframe>s
4192            root: root.ownerDocument
4193          });
4194        } catch (_e) {
4195          io = new IntersectionObserver(handleObserve, options);
4196        }
4197        io.observe(element);
4198      }
4199      const win = getWindow(element);
4200      const handleResize = () => refresh(ancestorResize);
4201      win.addEventListener("resize", handleResize);
4202      refresh(true);
4203      return () => {
4204        win.removeEventListener("resize", handleResize);
4205        cleanup();
4206      };
4207    }
4208    function autoUpdate(reference, floating, update2, options) {
4209      if (options === void 0) {
4210        options = {};
4211      }
4212      const {
4213        ancestorScroll = true,
4214        ancestorResize = true,
4215        elementResize = typeof ResizeObserver === "function",
4216        layoutShift = typeof IntersectionObserver === "function",
4217        animationFrame = false
4218      } = options;
4219      const referenceEl = unwrapElement(reference);
4220      const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...floating ? getOverflowAncestors(floating) : []] : [];
4221      ancestors.forEach((ancestor) => {
4222        ancestorScroll && ancestor.addEventListener("scroll", update2);
4223        ancestorResize && ancestor.addEventListener("resize", update2);
4224      });
4225      const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update2, ancestorResize) : null;
4226      let reobserveFrame = -1;
4227      let resizeObserver = null;
4228      if (elementResize) {
4229        resizeObserver = new ResizeObserver((_ref) => {
4230          let [firstEntry] = _ref;
4231          if (firstEntry && firstEntry.target === referenceEl && resizeObserver && floating) {
4232            resizeObserver.unobserve(floating);
4233            cancelAnimationFrame(reobserveFrame);
4234            reobserveFrame = requestAnimationFrame(() => {
4235              var _resizeObserver;
4236              (_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
4237            });
4238          }
4239          update2();
4240        });
4241        if (referenceEl && !animationFrame) {
4242          resizeObserver.observe(referenceEl);
4243        }
4244        if (floating) {
4245          resizeObserver.observe(floating);
4246        }
4247      }
4248      let frameId;
4249      let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
4250      if (animationFrame) {
4251        frameLoop();
4252      }
4253      function frameLoop() {
4254        const nextRefRect = getBoundingClientRect(reference);
4255        if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
4256          update2();
4257        }
4258        prevRefRect = nextRefRect;
4259        frameId = requestAnimationFrame(frameLoop);
4260      }
4261      update2();
4262      return () => {
4263        var _resizeObserver2;
4264        ancestors.forEach((ancestor) => {
4265          ancestorScroll && ancestor.removeEventListener("scroll", update2);
4266          ancestorResize && ancestor.removeEventListener("resize", update2);
4267        });
4268        cleanupIo == null || cleanupIo();
4269        (_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
4270        resizeObserver = null;
4271        if (animationFrame) {
4272          cancelAnimationFrame(frameId);
4273        }
4274      };
4275    }
4276    var offset2 = offset;
4277    var shift2 = shift;
4278    var flip2 = flip;
4279    var size2 = size;
4280    var limitShift2 = limitShift;
4281    var computePosition2 = (reference, floating, options) => {
4282      const cache = /* @__PURE__ */ new Map();
4283      const mergedOptions = options != null ? options : {};
4284      const platformWithCache = {
4285        ...platform2,
4286        ...mergedOptions.platform,
4287        _c: cache
4288      };
4289      return computePosition(reference, floating, {
4290        ...mergedOptions,
4291        platform: platformWithCache
4292      });
4293    };
4294  
4295    // node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
4296    var React17 = __toESM(require_react(), 1);
4297    var import_react2 = __toESM(require_react(), 1);
4298    var ReactDOM3 = __toESM(require_react_dom(), 1);
4299    var isClient = typeof document !== "undefined";
4300    var noop2 = function noop3() {
4301    };
4302    var index = isClient ? import_react2.useLayoutEffect : noop2;
4303    function deepEqual(a, b) {
4304      if (a === b) {
4305        return true;
4306      }
4307      if (typeof a !== typeof b) {
4308        return false;
4309      }
4310      if (typeof a === "function" && a.toString() === b.toString()) {
4311        return true;
4312      }
4313      let length;
4314      let i;
4315      let keys;
4316      if (a && b && typeof a === "object") {
4317        if (Array.isArray(a)) {
4318          length = a.length;
4319          if (length !== b.length) return false;
4320          for (i = length; i-- !== 0; ) {
4321            if (!deepEqual(a[i], b[i])) {
4322              return false;
4323            }
4324          }
4325          return true;
4326        }
4327        keys = Object.keys(a);
4328        length = keys.length;
4329        if (length !== Object.keys(b).length) {
4330          return false;
4331        }
4332        for (i = length; i-- !== 0; ) {
4333          if (!{}.hasOwnProperty.call(b, keys[i])) {
4334            return false;
4335          }
4336        }
4337        for (i = length; i-- !== 0; ) {
4338          const key = keys[i];
4339          if (key === "_owner" && a.$$typeof) {
4340            continue;
4341          }
4342          if (!deepEqual(a[key], b[key])) {
4343            return false;
4344          }
4345        }
4346        return true;
4347      }
4348      return a !== a && b !== b;
4349    }
4350    function getDPR(element) {
4351      if (typeof window === "undefined") {
4352        return 1;
4353      }
4354      const win = element.ownerDocument.defaultView || window;
4355      return win.devicePixelRatio || 1;
4356    }
4357    function roundByDPR(element, value) {
4358      const dpr = getDPR(element);
4359      return Math.round(value * dpr) / dpr;
4360    }
4361    function useLatestRef(value) {
4362      const ref = React17.useRef(value);
4363      index(() => {
4364        ref.current = value;
4365      });
4366      return ref;
4367    }
4368    function useFloating(options) {
4369      if (options === void 0) {
4370        options = {};
4371      }
4372      const {
4373        placement = "bottom",
4374        strategy = "absolute",
4375        middleware = [],
4376        platform: platform3,
4377        elements: {
4378          reference: externalReference,
4379          floating: externalFloating
4380        } = {},
4381        transform = true,
4382        whileElementsMounted,
4383        open
4384      } = options;
4385      const [data, setData] = React17.useState({
4386        x: 0,
4387        y: 0,
4388        strategy,
4389        placement,
4390        middlewareData: {},
4391        isPositioned: false
4392      });
4393      const [latestMiddleware, setLatestMiddleware] = React17.useState(middleware);
4394      if (!deepEqual(latestMiddleware, middleware)) {
4395        setLatestMiddleware(middleware);
4396      }
4397      const [_reference, _setReference] = React17.useState(null);
4398      const [_floating, _setFloating] = React17.useState(null);
4399      const setReference = React17.useCallback((node) => {
4400        if (node !== referenceRef.current) {
4401          referenceRef.current = node;
4402          _setReference(node);
4403        }
4404      }, []);
4405      const setFloating = React17.useCallback((node) => {
4406        if (node !== floatingRef.current) {
4407          floatingRef.current = node;
4408          _setFloating(node);
4409        }
4410      }, []);
4411      const referenceEl = externalReference || _reference;
4412      const floatingEl = externalFloating || _floating;
4413      const referenceRef = React17.useRef(null);
4414      const floatingRef = React17.useRef(null);
4415      const dataRef = React17.useRef(data);
4416      const hasWhileElementsMounted = whileElementsMounted != null;
4417      const whileElementsMountedRef = useLatestRef(whileElementsMounted);
4418      const platformRef = useLatestRef(platform3);
4419      const openRef = useLatestRef(open);
4420      const update2 = React17.useCallback(() => {
4421        if (!referenceRef.current || !floatingRef.current) {
4422          return;
4423        }
4424        const config = {
4425          placement,
4426          strategy,
4427          middleware: latestMiddleware
4428        };
4429        if (platformRef.current) {
4430          config.platform = platformRef.current;
4431        }
4432        computePosition2(referenceRef.current, floatingRef.current, config).then((data2) => {
4433          const fullData = {
4434            ...data2,
4435            // The floating element's position may be recomputed while it's closed
4436            // but still mounted (such as when transitioning out). To ensure
4437            // `isPositioned` will be `false` initially on the next open, avoid
4438            // setting it to `true` when `open === false` (must be specified).
4439            isPositioned: openRef.current !== false
4440          };
4441          if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
4442            dataRef.current = fullData;
4443            ReactDOM3.flushSync(() => {
4444              setData(fullData);
4445            });
4446          }
4447        });
4448      }, [latestMiddleware, placement, strategy, platformRef, openRef]);
4449      index(() => {
4450        if (open === false && dataRef.current.isPositioned) {
4451          dataRef.current.isPositioned = false;
4452          setData((data2) => ({
4453            ...data2,
4454            isPositioned: false
4455          }));
4456        }
4457      }, [open]);
4458      const isMountedRef = React17.useRef(false);
4459      index(() => {
4460        isMountedRef.current = true;
4461        return () => {
4462          isMountedRef.current = false;
4463        };
4464      }, []);
4465      index(() => {
4466        if (referenceEl) referenceRef.current = referenceEl;
4467        if (floatingEl) floatingRef.current = floatingEl;
4468        if (referenceEl && floatingEl) {
4469          if (whileElementsMountedRef.current) {
4470            return whileElementsMountedRef.current(referenceEl, floatingEl, update2);
4471          }
4472          update2();
4473        }
4474      }, [referenceEl, floatingEl, update2, whileElementsMountedRef, hasWhileElementsMounted]);
4475      const refs = React17.useMemo(() => ({
4476        reference: referenceRef,
4477        floating: floatingRef,
4478        setReference,
4479        setFloating
4480      }), [setReference, setFloating]);
4481      const elements = React17.useMemo(() => ({
4482        reference: referenceEl,
4483        floating: floatingEl
4484      }), [referenceEl, floatingEl]);
4485      const floatingStyles = React17.useMemo(() => {
4486        const initialStyles = {
4487          position: strategy,
4488          left: 0,
4489          top: 0
4490        };
4491        if (!elements.floating) {
4492          return initialStyles;
4493        }
4494        const x = roundByDPR(elements.floating, data.x);
4495        const y = roundByDPR(elements.floating, data.y);
4496        if (transform) {
4497          return {
4498            ...initialStyles,
4499            transform: "translate(" + x + "px, " + y + "px)",
4500            ...getDPR(elements.floating) >= 1.5 && {
4501              willChange: "transform"
4502            }
4503          };
4504        }
4505        return {
4506          position: strategy,
4507          left: x,
4508          top: y
4509        };
4510      }, [strategy, transform, elements.floating, data.x, data.y]);
4511      return React17.useMemo(() => ({
4512        ...data,
4513        update: update2,
4514        refs,
4515        elements,
4516        floatingStyles
4517      }), [data, update2, refs, elements, floatingStyles]);
4518    }
4519    var offset3 = (options, deps) => {
4520      const result = offset2(options);
4521      return {
4522        name: result.name,
4523        fn: result.fn,
4524        options: [options, deps]
4525      };
4526    };
4527    var shift3 = (options, deps) => {
4528      const result = shift2(options);
4529      return {
4530        name: result.name,
4531        fn: result.fn,
4532        options: [options, deps]
4533      };
4534    };
4535    var limitShift3 = (options, deps) => {
4536      const result = limitShift2(options);
4537      return {
4538        fn: result.fn,
4539        options: [options, deps]
4540      };
4541    };
4542    var flip3 = (options, deps) => {
4543      const result = flip2(options);
4544      return {
4545        name: result.name,
4546        fn: result.fn,
4547        options: [options, deps]
4548      };
4549    };
4550    var size3 = (options, deps) => {
4551      const result = size2(options);
4552      return {
4553        name: result.name,
4554        fn: result.fn,
4555        options: [options, deps]
4556      };
4557    };
4558  
4559    // node_modules/@base-ui/react/utils/popups/popupHandle.mjs
4560    var BasePopupHandle = class {
4561      /**
4562       * Stores of every root currently using this handle, in attach order. A handle is meant to be used
4563       * by a single mounted root, but roots can transiently overlap (e.g. during an animated route
4564       * transition), so this stack lets `attachStore`'s cleanup restore the previous root instead of
4565       * leaving a still-mounted root uncontrollable when a newer overlapping root detaches first.
4566       */
4567      attachedStores = [];
4568      /**
4569       * Store of the root that currently controls the handle: the most recently attached one still
4570       * mounted, or `null` when no root is attached. Imperative methods are no-ops while this is `null`.
4571       */
4572      attachedStoreValue = null;
4573      /**
4574       * Listeners notified when `attachedStore` changes, so detached triggers can follow the store pointer.
4575       */
4576      storeListeners = /* @__PURE__ */ new Set();
4577      /**
4578       * Creates a handle backed by the store used while no root is attached.
4579       *
4580       * @param fallbackStore Inert, closed store handed to detached triggers while no root is attached,
4581       * so they can render and register without a mounted root. Triggers register into whichever store
4582       * `store` currently resolves to, so while detached they live in this store's trigger map and
4583       * migrate themselves to the root's store (and back) as it attaches/detaches.
4584       * @param componentName Component name used to prefix dev warnings, e.g. `'Menu'` produces
4585       * `MenuHandle.open()` in warning text.
4586       * @param throwOnMissingTrigger Whether `open(triggerId)` throws when no trigger with that id is
4587       * registered. Anchored popups (Menu, Popover, Tooltip, PreviewCard) need a trigger to anchor to,
4588       * so they throw; Dialog is not anchored and instead opens unassociated with a dev warning.
4589       */
4590      constructor(fallbackStore, componentName, throwOnMissingTrigger = true) {
4591        this.fallbackStore = fallbackStore;
4592        this.componentName = componentName;
4593        this.throwOnMissingTrigger = throwOnMissingTrigger;
4594      }
4595      get attachedStore() {
4596        return this.attachedStoreValue;
4597      }
4598      /**
4599       * Store that detached triggers read from: the attached root's store, or an inert fallback store
4600       * used while no root is attached.
4601       * @internal
4602       */
4603      get store() {
4604        return this.attachedStoreValue ?? this.fallbackStore;
4605      }
4606      /**
4607       * Stable fallback store used for server rendering and hydration. Root stores cannot be recorded on
4608       * the handle during render because a handle can be shared by concurrent server-rendered requests.
4609       * @internal
4610       */
4611      get serverStore() {
4612        return this.fallbackStore;
4613      }
4614      /**
4615       * Subscribes to changes of the attached store pointer so detached triggers re-render and re-bind
4616       * when a root attaches or detaches. Returns a function that removes the listener.
4617       * @internal
4618       */
4619      subscribeStore(listener) {
4620        this.storeListeners.add(listener);
4621        return () => {
4622          this.storeListeners.delete(listener);
4623        };
4624      }
4625      /**
4626       * Points the handle at a root's store and notifies subscribers so detached triggers re-render and
4627       * re-register into it (their registration ref re-fires on the store-pointer change). Returns a
4628       * cleanup function that detaches the store again.
4629       * @internal
4630       */
4631      attachStore(newStore) {
4632        this.attachedStores.push(newStore);
4633        this.setActiveStore(newStore);
4634        if (true) {
4635          if (this.attachedStores.length > 1) {
4636            const dev = this;
4637            (dev.overlapWarningFrame ??= AnimationFrame.create()).request(() => {
4638              if (this.attachedStores.length > 1) {
4639                console.warn("Base UI: A handle is attached to more than one mounted root at the same time. The most recently mounted root takes over and the previous one stops being controlled by the handle. A handle should be used by a single root that stays mounted for the lifetime of the handle.");
4640              }
4641            });
4642          }
4643        }
4644        return () => {
4645          const index2 = this.attachedStores.lastIndexOf(newStore);
4646          if (index2 !== -1) {
4647            this.attachedStores.splice(index2, 1);
4648          }
4649          this.setActiveStore(this.attachedStores[this.attachedStores.length - 1] ?? null);
4650        };
4651      }
4652      /**
4653       * Sets the store that currently controls the handle and notifies subscribers when it changes, so
4654       * detached triggers re-render and migrate their registration to the new store.
4655       */
4656      setActiveStore(store2) {
4657        if (this.attachedStoreValue !== store2) {
4658          this.attachedStoreValue = store2;
4659          this.storeListeners.forEach((listener) => {
4660            listener();
4661          });
4662        }
4663      }
4664      /**
4665       * Opens the attached root's store and associates it with the trigger with the given id, or a
4666       * no-op (with a dev warning) while no root is attached. Shared by every concrete handle's public
4667       * `open()` method, which only narrows the parameter type.
4668       *
4669       * When a trigger id is given but no matching trigger is registered, anchored popups throw (see
4670       * `throwOnMissingTrigger`); Dialog opens unassociated with a dev warning instead.
4671       *
4672       * This method should only be called in an event handler or an effect (not during rendering).
4673       *
4674       * @param triggerId ID of the trigger to associate with the popup, or `null`/`undefined` to open
4675       * without associating any trigger.
4676       */
4677      openByTrigger(triggerId) {
4678        const attachedStore = this.attachedStore;
4679        if (attachedStore === null) {
4680          if (true) {
4681            console.warn(`Base UI: $this.componentName}Handle.open() was called while no root using this handle is mounted. The call was ignored; mount a root with this handle before opening it imperatively.`);
4682          }
4683          return;
4684        }
4685        let triggerElement;
4686        if (triggerId) {
4687          for (let i = this.attachedStores.length - 1; i >= 0 && !triggerElement; i -= 1) {
4688            triggerElement = this.attachedStores[i].context.triggerElements.getById(triggerId);
4689          }
4690          triggerElement ??= this.fallbackStore.context.triggerElements.getById(triggerId);
4691        }
4692        if (triggerId && !triggerElement) {
4693          if (this.throwOnMissingTrigger) {
4694            throw new Error(true ? `Base UI: $this.componentName}Handle.open() was called with the trigger id "$triggerId}", but no matching trigger is registered with this handle. An anchored popup cannot open without a trigger to anchor to. Pass the id of a mounted $this.componentName}.Trigger that has this handle set on its "handle" prop.` : formatErrorMessage_default(99, this.componentName, triggerId, this.componentName));
4695          }
4696          if (true) {
4697            console.warn(`Base UI: $this.componentName}Handle.open: No trigger found with id "$triggerId}". The popup will open, but the trigger will not be associated with it.`);
4698          }
4699        }
4700        attachedStore.setOpen(true, createChangeEventDetails(reason_parts_exports.imperativeAction, void 0, triggerElement));
4701      }
4702      /**
4703       * Closes the popup by setting the attached root's store to closed, or a no-op (with a dev warning)
4704       * while no root is attached. Shared by every concrete handle's public `close()` method.
4705       *
4706       * This method should only be called in an event handler or an effect (not during rendering).
4707       */
4708      closePopup() {
4709        const attachedStore = this.attachedStore;
4710        if (attachedStore === null) {
4711          if (true) {
4712            console.warn(`Base UI: $this.componentName}Handle.close() was called while no root using this handle is mounted. The call was ignored.`);
4713          }
4714          return;
4715        }
4716        attachedStore.setOpen(false, createChangeEventDetails(reason_parts_exports.imperativeAction));
4717      }
4718    };
4719  
4720    // node_modules/@base-ui/react/utils/popups/popupStoreUtils.mjs
4721    var React22 = __toESM(require_react(), 1);
4722    var ReactDOM4 = __toESM(require_react_dom(), 1);
4723  
4724    // node_modules/@base-ui/react/floating-ui-react/hooks/useSyncedFloatingRootContext.mjs
4725    var React21 = __toESM(require_react(), 1);
4726  
4727    // node_modules/@base-ui/utils/store/useStore.mjs
4728    var React19 = __toESM(require_react(), 1);
4729    var import_shim = __toESM(require_shim(), 1);
4730    var import_with_selector = __toESM(require_with_selector(), 1);
4731  
4732    // node_modules/@base-ui/utils/fastHooks.mjs
4733    var React18 = __toESM(require_react(), 1);
4734    var hooks = [];
4735    var currentInstance = void 0;
4736    function getInstance() {
4737      return currentInstance;
4738    }
4739    function register(hook) {
4740      hooks.push(hook);
4741    }
4742    function fastComponent(fn) {
4743      const FastComponent = (props, forwardedRef) => {
4744        const instance = useRefWithInit(createInstance).current;
4745        let result;
4746        try {
4747          currentInstance = instance;
4748          for (const hook of hooks) {
4749            hook.before(instance);
4750          }
4751          result = fn(props, forwardedRef);
4752          for (const hook of hooks) {
4753            hook.after(instance);
4754          }
4755          instance.didInitialize = true;
4756        } finally {
4757          currentInstance = void 0;
4758        }
4759        return result;
4760      };
4761      FastComponent.displayName = fn.displayName || fn.name;
4762      return FastComponent;
4763    }
4764    function fastComponentRef(fn) {
4765      return /* @__PURE__ */ React18.forwardRef(fastComponent(fn));
4766    }
4767    function createInstance() {
4768      return {
4769        didInitialize: false
4770      };
4771    }
4772  
4773    // node_modules/@base-ui/utils/store/useStore.mjs
4774    var canUseRawUseSyncExternalStore = isReactVersionAtLeast(19);
4775    var useStoreImplementation = canUseRawUseSyncExternalStore ? useStoreFast : useStoreLegacy;
4776    function useStore(store2, selector, a1, a2, a3) {
4777      return useStoreImplementation(store2, selector, a1, a2, a3);
4778    }
4779    function useStoreR19(store2, selector, a1, a2, a3) {
4780      const getSelection = React19.useCallback(() => selector(store2.getSnapshot(), a1, a2, a3), [store2, selector, a1, a2, a3]);
4781      return (0, import_shim.useSyncExternalStore)(store2.subscribe, getSelection, getSelection);
4782    }
4783    register({
4784      before(instance) {
4785        instance.syncIndex = 0;
4786        if (!instance.didInitialize) {
4787          instance.syncTick = 1;
4788          instance.syncHooks = [];
4789          instance.didChangeStore = true;
4790          instance.getSnapshot = () => {
4791            let didChange2 = false;
4792            for (let i = 0; i < instance.syncHooks.length; i += 1) {
4793              const hook = instance.syncHooks[i];
4794              const value = hook.selector(hook.store.state, hook.a1, hook.a2, hook.a3);
4795              if (!Object.is(hook.value, value)) {
4796                didChange2 = true;
4797                hook.value = value;
4798              }
4799            }
4800            if (didChange2) {
4801              instance.syncTick += 1;
4802            }
4803            return instance.syncTick;
4804          };
4805        }
4806      },
4807      after(instance) {
4808        if (instance.syncHooks.length > 0) {
4809          if (instance.didChangeStore) {
4810            instance.didChangeStore = false;
4811            instance.subscribe = (onStoreChange) => {
4812              const stores = /* @__PURE__ */ new Set();
4813              for (const hook of instance.syncHooks) {
4814                stores.add(hook.store);
4815              }
4816              const unsubscribes = [];
4817              for (const store2 of stores) {
4818                unsubscribes.push(store2.subscribe(onStoreChange));
4819              }
4820              return () => {
4821                for (const unsubscribe of unsubscribes) {
4822                  unsubscribe();
4823                }
4824              };
4825            };
4826          }
4827          (0, import_shim.useSyncExternalStore)(instance.subscribe, instance.getSnapshot, instance.getSnapshot);
4828        }
4829      }
4830    });
4831    function useStoreFast(store2, selector, a1, a2, a3) {
4832      const instance = getInstance();
4833      if (!instance) {
4834        return useStoreR19(store2, selector, a1, a2, a3);
4835      }
4836      const index2 = instance.syncIndex;
4837      instance.syncIndex += 1;
4838      let hook;
4839      if (!instance.didInitialize) {
4840        hook = {
4841          store: store2,
4842          selector,
4843          a1,
4844          a2,
4845          a3,
4846          value: selector(store2.getSnapshot(), a1, a2, a3)
4847        };
4848        instance.syncHooks.push(hook);
4849      } else {
4850        hook = instance.syncHooks[index2];
4851        if (hook.store !== store2 || hook.selector !== selector || !Object.is(hook.a1, a1) || !Object.is(hook.a2, a2) || !Object.is(hook.a3, a3)) {
4852          if (hook.store !== store2) {
4853            instance.didChangeStore = true;
4854          }
4855          hook.store = store2;
4856          hook.selector = selector;
4857          hook.a1 = a1;
4858          hook.a2 = a2;
4859          hook.a3 = a3;
4860          hook.value = selector(store2.getSnapshot(), a1, a2, a3);
4861        }
4862      }
4863      return hook.value;
4864    }
4865    function useStoreLegacy(store2, selector, a1, a2, a3) {
4866      return (0, import_with_selector.useSyncExternalStoreWithSelector)(store2.subscribe, store2.getSnapshot, store2.getSnapshot, (state) => selector(state, a1, a2, a3));
4867    }
4868  
4869    // node_modules/@base-ui/utils/store/Store.mjs
4870    var Store = class {
4871      /**
4872       * The current state of the store.
4873       * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
4874       * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
4875       * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
4876       *
4877       * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
4878       */
4879      // Internal state to handle recursive `setState()` calls
4880      constructor(state) {
4881        this.state = state;
4882        this.listeners = /* @__PURE__ */ new Set();
4883        this.updateTick = 0;
4884      }
4885      /**
4886       * Registers a listener that will be called whenever the store's state changes.
4887       *
4888       * @param fn The listener function to be called on state changes.
4889       * @returns A function to unsubscribe the listener.
4890       */
4891      subscribe = (fn) => {
4892        this.listeners.add(fn);
4893        return () => {
4894          this.listeners.delete(fn);
4895        };
4896      };
4897      /**
4898       * Returns the current state of the store.
4899       */
4900      getSnapshot = () => {
4901        return this.state;
4902      };
4903      /**
4904       * Updates the entire store's state and notifies all registered listeners.
4905       *
4906       * @param newState The new state to set for the store.
4907       */
4908      setState(newState) {
4909        if (this.state === newState) {
4910          return;
4911        }
4912        this.state = newState;
4913        this.updateTick += 1;
4914        const currentTick = this.updateTick;
4915        for (const listener of this.listeners) {
4916          if (currentTick !== this.updateTick) {
4917            return;
4918          }
4919          listener(newState);
4920        }
4921      }
4922      /**
4923       * Merges the provided changes into the current state and notifies listeners if there are changes.
4924       *
4925       * @param changes An object containing the changes to apply to the current state.
4926       */
4927      update(changes) {
4928        for (const key in changes) {
4929          if (!Object.is(this.state[key], changes[key])) {
4930            this.setState({
4931              ...this.state,
4932              ...changes
4933            });
4934            return;
4935          }
4936        }
4937      }
4938      /**
4939       * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
4940       *
4941       * @param key The key in the store's state to update.
4942       * @param value The new value to set for the specified key.
4943       */
4944      set(key, value) {
4945        if (!Object.is(this.state[key], value)) {
4946          this.setState({
4947            ...this.state,
4948            [key]: value
4949          });
4950        }
4951      }
4952      /**
4953       * Gives the state a new reference and updates all registered listeners.
4954       */
4955      notifyAll() {
4956        const newState = {
4957          ...this.state
4958        };
4959        this.setState(newState);
4960      }
4961      use(selector, a1, a2, a3) {
4962        return useStore(this, selector, a1, a2, a3);
4963      }
4964    };
4965  
4966    // node_modules/@base-ui/utils/store/ReactStore.mjs
4967    var React20 = __toESM(require_react(), 1);
4968    var ReactStore = class extends Store {
4969      /**
4970       * Creates a new ReactStore instance.
4971       *
4972       * @param state Initial state of the store.
4973       * @param context Non-reactive context values.
4974       * @param selectors Optional selectors for use with `useState`.
4975       */
4976      constructor(state, context = {}, selectors3) {
4977        super(state);
4978        this.context = context;
4979        this.selectors = selectors3;
4980      }
4981      /**
4982       * Non-reactive values such as refs, callbacks, etc.
4983       */
4984      /**
4985       * Synchronizes a single external value into the store.
4986       *
4987       * Note that the while the value in `state` is updated immediately, the value returned
4988       * by `useState` is updated before the next render (similarly to React's `useState`).
4989       */
4990      useSyncedValue(key, value) {
4991        React20.useDebugValue(key);
4992        const store2 = this;
4993        useIsoLayoutEffect(() => {
4994          if (store2.state[key] !== value) {
4995            store2.set(key, value);
4996          }
4997        }, [store2, key, value]);
4998      }
4999      /**
5000       * Synchronizes a single external value into the store and
5001       * cleans it up (sets to `undefined`) on unmount.
5002       *
5003       * Note that the while the value in `state` is updated immediately, the value returned
5004       * by `useState` is updated before the next render (similarly to React's `useState`).
5005       */
5006      useSyncedValueWithCleanup(key, value) {
5007        const store2 = this;
5008        useIsoLayoutEffect(() => {
5009          if (store2.state[key] !== value) {
5010            store2.set(key, value);
5011          }
5012          return () => {
5013            store2.set(key, void 0);
5014          };
5015        }, [store2, key, value]);
5016      }
5017      /**
5018       * Synchronizes multiple external values into the store.
5019       *
5020       * Note that the while the values in `state` are updated immediately, the values returned
5021       * by `useState` are updated before the next render (similarly to React's `useState`).
5022       */
5023      useSyncedValues(statePart) {
5024        const store2 = this;
5025        if (true) {
5026          React20.useDebugValue(statePart, (p) => Object.keys(p));
5027          const keys = React20.useRef(Object.keys(statePart)).current;
5028          const nextKeys = Object.keys(statePart);
5029          if (keys.length !== nextKeys.length || keys.some((key, index2) => key !== nextKeys[index2])) {
5030            console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
5031          }
5032        }
5033        const dependencies = Object.values(statePart);
5034        useIsoLayoutEffect(() => {
5035          store2.update(statePart);
5036        }, [store2, ...dependencies]);
5037      }
5038      /**
5039       * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
5040       * is non-undefined, the store's state at `key` is updated to match `controlled`.
5041       */
5042      useControlledProp(key, controlled) {
5043        React20.useDebugValue(key);
5044        const store2 = this;
5045        const isControlled = controlled !== void 0;
5046        useIsoLayoutEffect(() => {
5047          if (isControlled && !Object.is(store2.state[key], controlled)) {
5048            store2.setState({
5049              ...store2.state,
5050              [key]: controlled
5051            });
5052          }
5053        }, [store2, key, controlled, isControlled]);
5054        if (true) {
5055          const cache = this.controlledValues ??= /* @__PURE__ */ new Map();
5056          if (!cache.has(key)) {
5057            cache.set(key, isControlled);
5058          }
5059          const previouslyControlled = cache.get(key);
5060          if (previouslyControlled !== void 0 && previouslyControlled !== isControlled) {
5061            console.error(`A component is changing the $isControlled ? "" : "un"}controlled state of $key.toString()} to be $isControlled ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
5062          }
5063        }
5064      }
5065      /** Gets the current value from the store using a selector with the provided key.
5066       *
5067       * @param key Key of the selector to use.
5068       */
5069      select(key, a1, a2, a3) {
5070        const selector = this.selectors[key];
5071        return selector(this.state, a1, a2, a3);
5072      }
5073      /**
5074       * Returns a value from the store's state using a selector function.
5075       * Used to subscribe to specific parts of the state.
5076       * This methods causes a rerender whenever the selected state changes.
5077       *
5078       * @param key Key of the selector to use.
5079       */
5080      useState(key, a1, a2, a3) {
5081        React20.useDebugValue(key);
5082        return useStore(this, this.selectors[key], a1, a2, a3);
5083      }
5084      /**
5085       * Wraps a function with `useStableCallback` to ensure it has a stable reference
5086       * and assigns it to the context.
5087       *
5088       * @param key Key of the event callback. Must be a function in the context.
5089       * @param fn Function to assign.
5090       */
5091      useContextCallback(key, fn) {
5092        React20.useDebugValue(key);
5093        const stableFunction = useStableCallback(fn ?? NOOP);
5094        this.context[key] = stableFunction;
5095      }
5096      /**
5097       * Returns a stable setter function for a specific key in the store's state.
5098       * It's commonly used to pass as a ref callback to React elements.
5099       *
5100       * @param key Key of the state to set.
5101       */
5102      useStateSetter(key) {
5103        const ref = React20.useRef(void 0);
5104        if (ref.current === void 0) {
5105          ref.current = (value) => {
5106            this.set(key, value);
5107          };
5108        }
5109        return ref.current;
5110      }
5111      /**
5112       * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
5113       *
5114       * @param key Key of the selector to observe.
5115       * @param listener Listener function called when the selector result changes.
5116       */
5117      observe(selector, listener) {
5118        let selectFn;
5119        if (typeof selector === "function") {
5120          selectFn = selector;
5121        } else {
5122          selectFn = this.selectors[selector];
5123        }
5124        let prevValue = selectFn(this.state);
5125        listener(prevValue, prevValue, this);
5126        return this.subscribe((nextState) => {
5127          const nextValue = selectFn(nextState);
5128          if (!Object.is(prevValue, nextValue)) {
5129            const oldValue = prevValue;
5130            prevValue = nextValue;
5131            listener(nextValue, oldValue, this);
5132          }
5133        });
5134      }
5135    };
5136  
5137    // node_modules/@base-ui/react/floating-ui-react/components/FloatingRootStore.mjs
5138    var selectors = {
5139      open: (state) => state.open,
5140      transitionStatus: (state) => state.transitionStatus,
5141      domReferenceElement: (state) => state.domReferenceElement,
5142      referenceElement: (state) => state.positionReference ?? state.referenceElement,
5143      floatingElement: (state) => state.floatingElement,
5144      floatingId: (state) => state.floatingId
5145    };
5146    var FloatingRootStore = class extends ReactStore {
5147      constructor(options) {
5148        const {
5149          syncOnly,
5150          nested,
5151          onOpenChange,
5152          triggerElements,
5153          ...initialState
5154        } = options;
5155        super({
5156          ...initialState,
5157          positionReference: initialState.referenceElement,
5158          domReferenceElement: initialState.referenceElement
5159        }, {
5160          onOpenChange,
5161          dataRef: {
5162            current: {}
5163          },
5164          events: createEventEmitter(),
5165          nested,
5166          triggerElements
5167        }, selectors);
5168        this.syncOnly = syncOnly;
5169      }
5170      /**
5171       * Syncs the event used by hover logic to distinguish hover-open from click-like interaction.
5172       */
5173      syncOpenEvent = (newOpen, event) => {
5174        if (!newOpen || !this.state.open || // Prevent a pending hover-open from overwriting a click-open event, while allowing
5175        // click events to upgrade a hover-open.
5176        event != null && isClickLikeEvent(event)) {
5177          this.context.dataRef.current.openEvent = newOpen ? event : void 0;
5178        }
5179      };
5180      /**
5181       * Runs the root-owned side effects for an open state change.
5182       */
5183      dispatchOpenChange = (newOpen, eventDetails) => {
5184        this.syncOpenEvent(newOpen, eventDetails.event);
5185        const details = {
5186          open: newOpen,
5187          reason: eventDetails.reason,
5188          nativeEvent: eventDetails.event,
5189          nested: this.context.nested,
5190          triggerElement: eventDetails.trigger
5191        };
5192        this.context.events.emit("openchange", details);
5193      };
5194      /**
5195       * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
5196       *
5197       * @param newOpen The new open state.
5198       * @param eventDetails Details about the event that triggered the open state change.
5199       */
5200      setOpen = (newOpen, eventDetails) => {
5201        if (this.syncOnly) {
5202          this.context.onOpenChange?.(newOpen, eventDetails);
5203          return;
5204        }
5205        this.dispatchOpenChange(newOpen, eventDetails);
5206        this.context.onOpenChange?.(newOpen, eventDetails);
5207      };
5208    };
5209  
5210    // node_modules/@base-ui/react/floating-ui-react/hooks/useSyncedFloatingRootContext.mjs
5211    function useSyncedFloatingRootContext(options) {
5212      const {
5213        popupStore,
5214        treatPopupAsFloatingElement = false,
5215        floatingRootContext: floatingRootContextProp,
5216        floatingId,
5217        nested,
5218        onOpenChange
5219      } = options;
5220      const open = popupStore.useState("open");
5221      const referenceElement = popupStore.useState("activeTriggerElement");
5222      const floatingElement = popupStore.useState(treatPopupAsFloatingElement ? "popupElement" : "positionerElement");
5223      const triggerElements = popupStore.context.triggerElements;
5224      const handleOpenChange = onOpenChange;
5225      const internalStoreRef = React21.useRef(null);
5226      if (floatingRootContextProp === void 0 && internalStoreRef.current === null) {
5227        internalStoreRef.current = new FloatingRootStore({
5228          open,
5229          transitionStatus: void 0,
5230          referenceElement,
5231          floatingElement,
5232          triggerElements,
5233          onOpenChange: handleOpenChange,
5234          floatingId,
5235          syncOnly: true,
5236          nested
5237        });
5238      }
5239      const store2 = floatingRootContextProp ?? internalStoreRef.current;
5240      popupStore.useSyncedValue("floatingId", floatingId);
5241      useIsoLayoutEffect(() => {
5242        const valuesToSync = {
5243          open,
5244          floatingId,
5245          referenceElement,
5246          floatingElement
5247        };
5248        if (isElement(referenceElement)) {
5249          valuesToSync.domReferenceElement = referenceElement;
5250        }
5251        if (store2.state.positionReference === store2.state.referenceElement) {
5252          valuesToSync.positionReference = referenceElement;
5253        }
5254        store2.update(valuesToSync);
5255      }, [open, floatingId, referenceElement, floatingElement, store2]);
5256      store2.context.onOpenChange = handleOpenChange;
5257      store2.context.nested = nested;
5258      return store2;
5259    }
5260  
5261    // node_modules/@base-ui/react/utils/popups/popupStoreUtils.mjs
5262    var FOCUSABLE_POPUP_PROPS = {
5263      tabIndex: -1,
5264      [FOCUSABLE_ATTRIBUTE]: ""
5265    };
5266    function usePopupRootStore(createStore, treatPopupAsFloatingElement = false) {
5267      const floatingId = useId();
5268      const nested = useFloatingParentNodeId() != null;
5269      const store2 = useRefWithInit(() => createStore(floatingId, nested)).current;
5270      useSyncedFloatingRootContext({
5271        popupStore: store2,
5272        treatPopupAsFloatingElement,
5273        floatingRootContext: store2.state.floatingRootContext,
5274        floatingId,
5275        nested,
5276        onOpenChange: store2.setOpen
5277      });
5278      return store2;
5279    }
5280    function PopupHandleAttachment({
5281      handle,
5282      store: store2
5283    }) {
5284      useIsoLayoutEffect(() => {
5285        return handle.attachStore(store2);
5286      }, [handle, store2]);
5287      return null;
5288    }
5289    function useTriggerRegistration(id, store2) {
5290      const registeredElementIdRef = React22.useRef(null);
5291      const registeredElementRef = React22.useRef(null);
5292      return React22.useCallback((element) => {
5293        if (id === void 0) {
5294          return;
5295        }
5296        let shouldSyncTriggerCount = false;
5297        if (registeredElementIdRef.current !== null) {
5298          const registeredId = registeredElementIdRef.current;
5299          const registeredElement = registeredElementRef.current;
5300          const currentElement = store2.context.triggerElements.getById(registeredId);
5301          if (registeredElement && currentElement === registeredElement) {
5302            store2.context.triggerElements.delete(registeredId);
5303            shouldSyncTriggerCount = true;
5304          }
5305          registeredElementIdRef.current = null;
5306          registeredElementRef.current = null;
5307        }
5308        if (element !== null) {
5309          registeredElementIdRef.current = id;
5310          registeredElementRef.current = element;
5311          store2.context.triggerElements.add(id, element);
5312          shouldSyncTriggerCount = true;
5313        }
5314        if (shouldSyncTriggerCount) {
5315          const triggerCount = store2.context.triggerElements.size;
5316          if (store2.select("open") && store2.state.triggerCount !== triggerCount) {
5317            store2.set("triggerCount", triggerCount);
5318          }
5319        }
5320      }, [store2, id]);
5321    }
5322    function setPopupOpenState(state, open, trigger, preventUnmountOnClose = false) {
5323      if (open) {
5324        state.preventUnmountingOnClose = false;
5325      } else if (preventUnmountOnClose) {
5326        state.preventUnmountingOnClose = true;
5327      }
5328      const triggerId = trigger?.id ?? null;
5329      if (triggerId || open) {
5330        state.activeTriggerId = triggerId;
5331        state.activeTriggerElement = trigger ?? null;
5332      }
5333    }
5334    function attachPreventUnmountOnClose(eventDetails) {
5335      let preventUnmountOnClose = false;
5336      eventDetails.preventUnmountOnClose = () => {
5337        preventUnmountOnClose = true;
5338      };
5339      return () => preventUnmountOnClose;
5340    }
5341    function applyPopupOpenChange(store2, nextOpen, eventDetails, options = {}) {
5342      const reason = eventDetails.reason;
5343      const isHover = reason === reason_parts_exports.triggerHover;
5344      const isFocusOpen = nextOpen && reason === reason_parts_exports.triggerFocus;
5345      const isDismissClose = !nextOpen && (reason === reason_parts_exports.triggerPress || reason === reason_parts_exports.escapeKey);
5346      const shouldPreventUnmountOnClose = attachPreventUnmountOnClose(eventDetails);
5347      store2.context.onOpenChange?.(nextOpen, eventDetails);
5348      if (eventDetails.isCanceled) {
5349        return;
5350      }
5351      options.onBeforeDispatch?.();
5352      store2.state.floatingRootContext.dispatchOpenChange(nextOpen, eventDetails);
5353      const changeState = () => {
5354        const updatedState = {
5355          ...options.extraState,
5356          open: nextOpen
5357        };
5358        if (isFocusOpen) {
5359          updatedState.instantType = "focus";
5360        } else if (isDismissClose) {
5361          updatedState.instantType = "dismiss";
5362        } else if (isHover) {
5363          updatedState.instantType = void 0;
5364        }
5365        setPopupOpenState(updatedState, nextOpen, eventDetails.trigger, shouldPreventUnmountOnClose());
5366        store2.update(updatedState);
5367      };
5368      if (isHover) {
5369        ReactDOM4.flushSync(changeState);
5370      } else {
5371        changeState();
5372      }
5373    }
5374    function useTriggerDataForwarding(triggerId, triggerElementRef, store2, stateUpdates) {
5375      const isMountedByThisTrigger = store2.useState("isMountedByTrigger", triggerId);
5376      const baseRegisterTrigger = useTriggerRegistration(triggerId, store2);
5377      const applyTriggerData = useStableCallback((element) => {
5378        const open = store2.select("open");
5379        const activeTriggerId = store2.select("activeTriggerId");
5380        if (activeTriggerId === triggerId) {
5381          store2.update({
5382            activeTriggerElement: element,
5383            ...open ? stateUpdates : null
5384          });
5385          return;
5386        }
5387        if (activeTriggerId == null && open) {
5388          store2.update({
5389            activeTriggerId: triggerId,
5390            activeTriggerElement: element,
5391            ...stateUpdates
5392          });
5393        }
5394      });
5395      const registerTrigger = React22.useCallback((element) => {
5396        baseRegisterTrigger(element);
5397        if (element) {
5398          applyTriggerData(element);
5399        }
5400      }, [baseRegisterTrigger, applyTriggerData]);
5401      useIsoLayoutEffect(() => {
5402        if (isMountedByThisTrigger) {
5403          store2.update({
5404            activeTriggerElement: triggerElementRef.current,
5405            ...stateUpdates
5406          });
5407        }
5408      }, [isMountedByThisTrigger, store2, triggerElementRef, ...Object.values(stateUpdates)]);
5409      return {
5410        registerTrigger,
5411        isMountedByThisTrigger
5412      };
5413    }
5414    function useImplicitActiveTrigger(store2, options = {}) {
5415      const {
5416        closeOnActiveTriggerUnmount = false
5417      } = options;
5418      const resolvedActiveTriggerIdRef = React22.useRef(null);
5419      const open = store2.useState("open");
5420      const reactiveTriggerCount = store2.useState("triggerCount");
5421      const activeTriggerId = store2.useState("activeTriggerId");
5422      const reactiveActiveTriggerElement = store2.useState("activeTriggerElement");
5423      useIsoLayoutEffect(() => {
5424        if (!open) {
5425          resolvedActiveTriggerIdRef.current = null;
5426          if (store2.state.triggerCount !== 0) {
5427            store2.set("triggerCount", 0);
5428          }
5429          return;
5430        }
5431        const triggerCount = store2.context.triggerElements.size;
5432        const stateUpdates = {};
5433        if (store2.state.triggerCount !== triggerCount) {
5434          stateUpdates.triggerCount = triggerCount;
5435        }
5436        const currentActiveTriggerId = store2.select("activeTriggerId");
5437        let lostActiveTriggerId = null;
5438        if (currentActiveTriggerId) {
5439          const activeTriggerElement = store2.context.triggerElements.getById(currentActiveTriggerId);
5440          if (!activeTriggerElement) {
5441            for (const [triggerId, triggerElement] of store2.context.triggerElements.entries()) {
5442              if (triggerElement === store2.state.activeTriggerElement) {
5443                stateUpdates.activeTriggerId = triggerId;
5444                stateUpdates.activeTriggerElement = triggerElement;
5445                resolvedActiveTriggerIdRef.current = triggerId;
5446                break;
5447              }
5448            }
5449            if (stateUpdates.activeTriggerId === void 0) {
5450              if (resolvedActiveTriggerIdRef.current === currentActiveTriggerId) {
5451                lostActiveTriggerId = currentActiveTriggerId;
5452              } else {
5453                resolvedActiveTriggerIdRef.current = null;
5454              }
5455            }
5456          } else {
5457            resolvedActiveTriggerIdRef.current = currentActiveTriggerId;
5458            if (activeTriggerElement !== store2.state.activeTriggerElement) {
5459              stateUpdates.activeTriggerElement = activeTriggerElement;
5460            }
5461          }
5462        } else {
5463          resolvedActiveTriggerIdRef.current = null;
5464        }
5465        if (!lostActiveTriggerId && !currentActiveTriggerId && triggerCount === 1) {
5466          const iteratorResult = store2.context.triggerElements.entries().next();
5467          if (!iteratorResult.done) {
5468            const [implicitTriggerId, implicitTriggerElement] = iteratorResult.value;
5469            stateUpdates.activeTriggerId = implicitTriggerId;
5470            stateUpdates.activeTriggerElement = implicitTriggerElement;
5471            resolvedActiveTriggerIdRef.current = implicitTriggerId;
5472          }
5473        }
5474        if (stateUpdates.triggerCount !== void 0 || stateUpdates.activeTriggerId !== void 0 || stateUpdates.activeTriggerElement !== void 0) {
5475          store2.update(stateUpdates);
5476        }
5477        if (lostActiveTriggerId) {
5478          if (closeOnActiveTriggerUnmount) {
5479            queueMicrotask(() => {
5480              if (store2.select("open") && store2.select("activeTriggerId") === lostActiveTriggerId && !store2.context.triggerElements.getById(lostActiveTriggerId)) {
5481                const eventDetails = createChangeEventDetails(reason_parts_exports.none);
5482                store2.setOpen(false, eventDetails);
5483                if (!eventDetails.isCanceled) {
5484                  store2.update({
5485                    activeTriggerId: null,
5486                    activeTriggerElement: null
5487                  });
5488                }
5489              }
5490            });
5491          }
5492        }
5493      }, [open, store2, reactiveTriggerCount, activeTriggerId, reactiveActiveTriggerElement, closeOnActiveTriggerUnmount]);
5494    }
5495    function useOpenStateTransitions(open, store2, onUnmount) {
5496      const {
5497        mounted,
5498        setMounted,
5499        transitionStatus
5500      } = useTransitionStatus(open);
5501      const preventUnmountingOnClose = store2.useState("preventUnmountingOnClose");
5502      const syncedPreventUnmountingOnClose = open ? false : preventUnmountingOnClose;
5503      store2.useSyncedValues({
5504        mounted,
5505        transitionStatus,
5506        preventUnmountingOnClose: syncedPreventUnmountingOnClose
5507      });
5508      const forceUnmount = useStableCallback(() => {
5509        setMounted(false);
5510        store2.update({
5511          activeTriggerId: null,
5512          activeTriggerElement: null,
5513          mounted: false,
5514          preventUnmountingOnClose: false
5515        });
5516        onUnmount?.();
5517        store2.context.onOpenChangeComplete?.(false);
5518      });
5519      useOpenChangeComplete({
5520        enabled: mounted && !open && !syncedPreventUnmountingOnClose,
5521        open,
5522        ref: store2.context.popupRef,
5523        onComplete() {
5524          if (!open) {
5525            forceUnmount();
5526          }
5527        }
5528      });
5529      return {
5530        forceUnmount,
5531        transitionStatus
5532      };
5533    }
5534    function usePopupInteractionProps(store2, statePart) {
5535      store2.useSyncedValues(statePart);
5536      useIsoLayoutEffect(() => () => {
5537        store2.update({
5538          activeTriggerProps: EMPTY_OBJECT,
5539          inactiveTriggerProps: EMPTY_OBJECT,
5540          popupProps: EMPTY_OBJECT
5541        });
5542      }, [store2]);
5543    }
5544  
5545    // node_modules/@base-ui/react/utils/popups/popupTriggerMap.mjs
5546    var devElementIdsByMap;
5547    function getDevElementIds(map) {
5548      devElementIdsByMap ??= /* @__PURE__ */ new WeakMap();
5549      let elementIds = devElementIdsByMap.get(map);
5550      if (!elementIds) {
5551        elementIds = /* @__PURE__ */ new WeakMap();
5552        devElementIdsByMap.set(map, elementIds);
5553      }
5554      return elementIds;
5555    }
5556    var PopupTriggerMap = class {
5557      constructor() {
5558        this.idMap = /* @__PURE__ */ new Map();
5559      }
5560      /**
5561       * Adds a trigger element with the given ID.
5562       *
5563       * Note: The provided element is assumed to not be registered under multiple IDs.
5564       */
5565      add(id, element) {
5566        if (true) {
5567          const elementIds = getDevElementIds(this);
5568          const existingId = elementIds.get(element);
5569          if (existingId !== void 0 && existingId !== id) {
5570            throw new Error("Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap.");
5571          }
5572          const previousElement = this.idMap.get(id);
5573          if (previousElement !== void 0 && previousElement !== element) {
5574            elementIds.delete(previousElement);
5575          }
5576          elementIds.set(element, id);
5577        }
5578        this.idMap.set(id, element);
5579      }
5580      /**
5581       * Removes the trigger element with the given ID.
5582       */
5583      delete(id) {
5584        if (true) {
5585          const element = this.idMap.get(id);
5586          if (element !== void 0) {
5587            devElementIdsByMap?.get(this)?.delete(element);
5588          }
5589        }
5590        this.idMap.delete(id);
5591      }
5592      /**
5593       * Whether the given element is registered as a trigger.
5594       */
5595      hasElement(element) {
5596        for (const registered of this.idMap.values()) {
5597          if (registered === element) {
5598            return true;
5599          }
5600        }
5601        return false;
5602      }
5603      /**
5604       * Whether there is a registered trigger element matching the given predicate.
5605       */
5606      hasMatchingElement(predicate) {
5607        for (const element of this.idMap.values()) {
5608          if (predicate(element)) {
5609            return true;
5610          }
5611        }
5612        return false;
5613      }
5614      /**
5615       * Returns the trigger element associated with the given ID, or undefined if no such element exists.
5616       */
5617      getById(id) {
5618        return this.idMap.get(id);
5619      }
5620      /**
5621       * Returns an iterable of all registered trigger entries, where each entry is a tuple of [id, element].
5622       */
5623      entries() {
5624        return this.idMap.entries();
5625      }
5626      /**
5627       * Returns an iterable of all registered trigger elements.
5628       */
5629      elements() {
5630        return this.idMap.values();
5631      }
5632      /**
5633       * Returns the number of registered trigger elements.
5634       */
5635      get size() {
5636        return this.idMap.size;
5637      }
5638    };
5639  
5640    // node_modules/@base-ui/react/floating-ui-react/utils/getEmptyRootContext.mjs
5641    function getEmptyRootContext() {
5642      return new FloatingRootStore({
5643        open: false,
5644        transitionStatus: void 0,
5645        floatingElement: null,
5646        referenceElement: null,
5647        triggerElements: new PopupTriggerMap(),
5648        floatingId: void 0,
5649        syncOnly: false,
5650        nested: false,
5651        onOpenChange: void 0
5652      });
5653    }
5654  
5655    // node_modules/@base-ui/react/utils/popups/store.mjs
5656    function createInitialPopupStoreState() {
5657      return {
5658        open: false,
5659        openProp: void 0,
5660        mounted: false,
5661        transitionStatus: void 0,
5662        floatingRootContext: getEmptyRootContext(),
5663        floatingId: void 0,
5664        triggerCount: 0,
5665        preventUnmountingOnClose: false,
5666        payload: void 0,
5667        activeTriggerId: null,
5668        activeTriggerElement: null,
5669        triggerIdProp: void 0,
5670        popupElement: null,
5671        positionerElement: null,
5672        activeTriggerProps: EMPTY_OBJECT,
5673        inactiveTriggerProps: EMPTY_OBJECT,
5674        popupProps: EMPTY_OBJECT
5675      };
5676    }
5677    function createPopupFloatingRootContext(triggerElements, floatingId, nested = false) {
5678      return new FloatingRootStore({
5679        open: false,
5680        transitionStatus: void 0,
5681        floatingElement: null,
5682        referenceElement: null,
5683        triggerElements,
5684        floatingId,
5685        syncOnly: true,
5686        nested,
5687        onOpenChange: void 0
5688      });
5689    }
5690    var activeTriggerIdSelector = (state) => state.triggerIdProp ?? state.activeTriggerId;
5691    var openSelector = (state) => state.openProp ?? state.open;
5692    var popupIdSelector = (state) => {
5693      const popupId = state.popupElement?.id ?? state.floatingId;
5694      return popupId || void 0;
5695    };
5696    function triggerOwnsOpenPopup(state, triggerId) {
5697      return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) === triggerId;
5698    }
5699    function triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) {
5700      if (triggerOwnsOpenPopup(state, triggerId)) {
5701        return true;
5702      }
5703      return triggerId !== void 0 && openSelector(state) && activeTriggerIdSelector(state) == null && state.triggerCount === 1;
5704    }
5705    var popupStoreSelectors = {
5706      open: openSelector,
5707      mounted: (state) => state.mounted,
5708      transitionStatus: (state) => state.transitionStatus,
5709      floatingRootContext: (state) => state.floatingRootContext,
5710      triggerCount: (state) => state.triggerCount,
5711      preventUnmountingOnClose: (state) => state.preventUnmountingOnClose,
5712      payload: (state) => state.payload,
5713      activeTriggerId: activeTriggerIdSelector,
5714      activeTriggerElement: (state) => state.mounted ? state.activeTriggerElement : null,
5715      popupId: popupIdSelector,
5716      /**
5717       * Whether the trigger with the given ID was used to open the popup.
5718       */
5719      isTriggerActive: (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId,
5720      /**
5721       * Whether the popup is open and was activated by a trigger with the given ID.
5722       */
5723      isOpenedByTrigger: (state, triggerId) => triggerOwnsOpenPopup(state, triggerId),
5724      /**
5725       * Whether the popup is mounted and was activated by a trigger with the given ID.
5726       */
5727      isMountedByTrigger: (state, triggerId) => triggerId !== void 0 && activeTriggerIdSelector(state) === triggerId && state.mounted,
5728      triggerProps: (state, isActive) => isActive ? state.activeTriggerProps : state.inactiveTriggerProps,
5729      /**
5730       * Popup id for the trigger that currently owns the open popup.
5731       */
5732      triggerPopupId: (state, triggerId) => triggerOwnsOpenPopupOrIsOnlyTrigger(state, triggerId) ? popupIdSelector(state) : void 0,
5733      popupProps: (state) => state.popupProps,
5734      popupElement: (state) => state.popupElement,
5735      positionerElement: (state) => state.positionerElement
5736    };
5737  
5738    // node_modules/@base-ui/react/utils/popups/usePopupHandleStore.mjs
5739    var React23 = __toESM(require_react(), 1);
5740    var import_shim2 = __toESM(require_shim(), 1);
5741    function usePopupHandleStore(handle) {
5742      const subscribe = React23.useCallback((listener) => {
5743        if (handle === void 0) {
5744          return NOOP;
5745        }
5746        return handle.subscribeStore(listener);
5747      }, [handle]);
5748      const getSnapshot = React23.useCallback(() => {
5749        return handle === void 0 ? void 0 : handle.store;
5750      }, [handle]);
5751      return (0, import_shim2.useSyncExternalStore)(subscribe, getSnapshot, () => handle?.serverStore);
5752    }
5753  
5754    // node_modules/@base-ui/react/floating-ui-react/hooks/useFloating.mjs
5755    function useBaseUIFloating(options) {
5756      return useFloatingWithStore(options, options.rootContext);
5757    }
5758    function useFloatingWithStore(options, store2) {
5759      const {
5760        nodeId,
5761        externalTree
5762      } = options;
5763      const referenceElement = store2.useState("referenceElement");
5764      const floatingElement = store2.useState("floatingElement");
5765      const domReferenceElement = store2.useState("domReferenceElement");
5766      const open = store2.useState("open");
5767      const floatingId = store2.useState("floatingId");
5768      const [positionReference, setPositionReferenceRaw] = React24.useState(null);
5769      const [localDomReference, setLocalDomReference] = React24.useState(void 0);
5770      const [localFloatingElement, setLocalFloatingElement] = React24.useState(void 0);
5771      const domReferenceRef = React24.useRef(null);
5772      const tree = useFloatingTree(externalTree);
5773      const storeElements = React24.useMemo(() => ({
5774        reference: referenceElement,
5775        floating: floatingElement,
5776        domReference: domReferenceElement
5777      }), [referenceElement, floatingElement, domReferenceElement]);
5778      const position = useFloating({
5779        ...options,
5780        elements: {
5781          ...storeElements,
5782          ...positionReference && {
5783            reference: positionReference
5784          }
5785        }
5786      });
5787      const localDomReferenceElement = isElement(localDomReference) ? localDomReference : null;
5788      const syncedFloatingElement = localFloatingElement === void 0 ? store2.state.floatingElement : localFloatingElement;
5789      store2.useSyncedValue("referenceElement", localDomReference ?? null);
5790      store2.useSyncedValue("domReferenceElement", localDomReference === void 0 ? domReferenceElement : localDomReferenceElement);
5791      store2.useSyncedValue("floatingElement", syncedFloatingElement);
5792      const setPositionReference = React24.useCallback((node) => {
5793        const computedPositionReference = isElement(node) ? {
5794          getBoundingClientRect: () => node.getBoundingClientRect(),
5795          getClientRects: () => node.getClientRects(),
5796          contextElement: node
5797        } : node;
5798        setPositionReferenceRaw(computedPositionReference);
5799        position.refs.setReference(computedPositionReference);
5800      }, [position.refs]);
5801      const setReference = React24.useCallback((node) => {
5802        if (isElement(node) || node === null) {
5803          domReferenceRef.current = node;
5804          setLocalDomReference(node);
5805        }
5806        if (isElement(position.refs.reference.current) || position.refs.reference.current === null || // Don't allow setting virtual elements using the old technique back to
5807        // `null` to support `positionReference` + an unstable `reference`
5808        // callback ref.
5809        node !== null && !isElement(node)) {
5810          position.refs.setReference(node);
5811        }
5812      }, [position.refs, setLocalDomReference]);
5813      const setFloating = React24.useCallback((node) => {
5814        setLocalFloatingElement(node);
5815        position.refs.setFloating(node);
5816      }, [position.refs]);
5817      const refs = React24.useMemo(() => ({
5818        ...position.refs,
5819        setReference,
5820        setFloating,
5821        setPositionReference,
5822        domReference: domReferenceRef
5823      }), [position.refs, setReference, setFloating, setPositionReference]);
5824      const elements = React24.useMemo(() => ({
5825        ...position.elements,
5826        domReference: domReferenceElement
5827      }), [position.elements, domReferenceElement]);
5828      const context = React24.useMemo(() => ({
5829        ...position,
5830        dataRef: store2.context.dataRef,
5831        open,
5832        onOpenChange: store2.setOpen,
5833        events: store2.context.events,
5834        floatingId,
5835        refs,
5836        elements,
5837        nodeId,
5838        rootStore: store2
5839      }), [position, refs, elements, nodeId, store2, open, floatingId]);
5840      useIsoLayoutEffect(() => {
5841        if (domReferenceElement) {
5842          domReferenceRef.current = domReferenceElement;
5843        }
5844      }, [domReferenceElement]);
5845      useIsoLayoutEffect(() => {
5846        store2.context.dataRef.current.floatingContext = context;
5847        const node = tree?.nodesRef.current.find((n) => n.id === nodeId);
5848        if (node) {
5849          node.context = context;
5850        }
5851      });
5852      return React24.useMemo(() => ({
5853        ...position,
5854        context,
5855        refs,
5856        elements,
5857        rootStore: store2
5858      }), [position, refs, elements, context, store2]);
5859    }
5860  
5861    // node_modules/@base-ui/react/floating-ui-react/hooks/useFocus.mjs
5862    var React25 = __toESM(require_react(), 1);
5863    var isMacSafari = parts_exports.os.mac && parts_exports.engine.webkit;
5864    function useFocus(context, props = {}) {
5865      const {
5866        enabled = true,
5867        delay
5868      } = props;
5869      const store2 = "rootStore" in context ? context.rootStore : context;
5870      const {
5871        events,
5872        dataRef
5873      } = store2.context;
5874      const blockFocusRef = React25.useRef(false);
5875      const blockedReferenceRef = React25.useRef(null);
5876      const keyboardModalityRef = React25.useRef(true);
5877      const timeout = useTimeout();
5878      React25.useEffect(() => {
5879        const domReference = store2.select("domReferenceElement");
5880        if (!enabled) {
5881          return void 0;
5882        }
5883        const win = getWindow(domReference);
5884        function onBlur() {
5885          const currentDomReference = store2.select("domReferenceElement");
5886          if (!store2.select("open") && isHTMLElement(currentDomReference) && currentDomReference === activeElement(ownerDocument(currentDomReference))) {
5887            blockFocusRef.current = true;
5888          }
5889        }
5890        function onKeyDown() {
5891          keyboardModalityRef.current = true;
5892        }
5893        function onPointerDown() {
5894          keyboardModalityRef.current = false;
5895        }
5896        return mergeCleanups(addEventListener(win, "blur", onBlur), isMacSafari && addEventListener(win, "keydown", onKeyDown, true), isMacSafari && addEventListener(win, "pointerdown", onPointerDown, true));
5897      }, [store2, enabled]);
5898      React25.useEffect(() => {
5899        if (!enabled) {
5900          return void 0;
5901        }
5902        function onOpenChangeLocal(details) {
5903          if (details.reason === reason_parts_exports.triggerPress || details.reason === reason_parts_exports.escapeKey) {
5904            const referenceElement = store2.select("domReferenceElement");
5905            if (isElement(referenceElement)) {
5906              blockedReferenceRef.current = referenceElement;
5907              blockFocusRef.current = true;
5908            }
5909          }
5910        }
5911        events.on("openchange", onOpenChangeLocal);
5912        return () => {
5913          events.off("openchange", onOpenChangeLocal);
5914        };
5915      }, [events, enabled, store2]);
5916      const reference = React25.useMemo(() => {
5917        function resetBlockedFocus() {
5918          blockFocusRef.current = false;
5919          blockedReferenceRef.current = null;
5920        }
5921        return {
5922          onMouseLeave() {
5923            resetBlockedFocus();
5924          },
5925          onFocus(event) {
5926            const focusTarget = event.currentTarget;
5927            if (blockFocusRef.current) {
5928              if (blockedReferenceRef.current === focusTarget) {
5929                return;
5930              }
5931              resetBlockedFocus();
5932            }
5933            const target = getTarget(event.nativeEvent);
5934            if (isElement(target)) {
5935              if (isMacSafari && !event.relatedTarget) {
5936                if (!keyboardModalityRef.current && !isTypeableElement(target)) {
5937                  return;
5938                }
5939              } else if (!matchesFocusVisible(target)) {
5940                return;
5941              }
5942            }
5943            const movedFromOtherEnabledTrigger = isTargetInsideEnabledTrigger(event.relatedTarget, store2.context.triggerElements);
5944            const {
5945              nativeEvent,
5946              currentTarget
5947            } = event;
5948            const delayValue = typeof delay === "function" ? delay() : delay;
5949            if (store2.select("open") && movedFromOtherEnabledTrigger || delayValue === 0 || delayValue === void 0) {
5950              store2.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerFocus, nativeEvent, currentTarget));
5951              return;
5952            }
5953            timeout.start(delayValue, () => {
5954              if (blockFocusRef.current) {
5955                return;
5956              }
5957              store2.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerFocus, nativeEvent, currentTarget));
5958            });
5959          },
5960          onBlur(event) {
5961            resetBlockedFocus();
5962            const relatedTarget = event.relatedTarget;
5963            const nativeEvent = event.nativeEvent;
5964            const movedToFocusGuard = isElement(relatedTarget) && relatedTarget.hasAttribute(createAttribute("focus-guard")) && relatedTarget.getAttribute("data-type") === "outside";
5965            timeout.start(0, () => {
5966              const domReference = store2.select("domReferenceElement");
5967              const activeEl = activeElement(ownerDocument(domReference));
5968              if (!relatedTarget && activeEl === domReference) {
5969                return;
5970              }
5971              if (contains(dataRef.current.floatingContext?.refs.floating.current, activeEl) || contains(domReference, activeEl) || movedToFocusGuard) {
5972                return;
5973              }
5974              const nextFocusedElement = relatedTarget ?? activeEl;
5975              if (isTargetInsideEnabledTrigger(nextFocusedElement, store2.context.triggerElements)) {
5976                return;
5977              }
5978              store2.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerFocus, nativeEvent));
5979            });
5980          }
5981        };
5982      }, [dataRef, delay, store2, timeout]);
5983      return React25.useMemo(() => enabled ? {
5984        reference,
5985        trigger: reference
5986      } : {}, [enabled, reference]);
5987    }
5988  
5989    // node_modules/@base-ui/react/floating-ui-react/hooks/useHoverFloatingInteraction.mjs
5990    var React26 = __toESM(require_react(), 1);
5991  
5992    // node_modules/@base-ui/react/floating-ui-react/hooks/useHoverInteractionSharedState.mjs
5993    var HoverInteraction = class _HoverInteraction {
5994      constructor() {
5995        this.pointerType = void 0;
5996        this.interactedInside = false;
5997        this.handler = void 0;
5998        this.blockMouseMove = true;
5999        this.performedPointerEventsMutation = false;
6000        this.pointerEventsScopeElement = null;
6001        this.pointerEventsReferenceElement = null;
6002        this.pointerEventsFloatingElement = null;
6003        this.restTimeoutPending = false;
6004        this.openChangeTimeout = new Timeout();
6005        this.restTimeout = new Timeout();
6006        this.handleCloseOptions = void 0;
6007      }
6008      static create() {
6009        return new _HoverInteraction();
6010      }
6011      dispose = () => {
6012        this.openChangeTimeout.clear();
6013        this.restTimeout.clear();
6014      };
6015      disposeEffect = () => {
6016        return this.dispose;
6017      };
6018    };
6019    var pointerEventsMutationOwnerByScopeElement = /* @__PURE__ */ new WeakMap();
6020    function clearSafePolygonPointerEventsMutation(instance) {
6021      if (!instance.performedPointerEventsMutation) {
6022        return;
6023      }
6024      const scopeElement = instance.pointerEventsScopeElement;
6025      if (scopeElement && pointerEventsMutationOwnerByScopeElement.get(scopeElement) === instance) {
6026        instance.pointerEventsScopeElement?.style.removeProperty("pointer-events");
6027        instance.pointerEventsReferenceElement?.style.removeProperty("pointer-events");
6028        instance.pointerEventsFloatingElement?.style.removeProperty("pointer-events");
6029        pointerEventsMutationOwnerByScopeElement.delete(scopeElement);
6030      }
6031      instance.performedPointerEventsMutation = false;
6032      instance.pointerEventsScopeElement = null;
6033      instance.pointerEventsReferenceElement = null;
6034      instance.pointerEventsFloatingElement = null;
6035    }
6036    function applySafePolygonPointerEventsMutation(instance, options) {
6037      const {
6038        scopeElement,
6039        referenceElement,
6040        floatingElement
6041      } = options;
6042      const existingOwner = pointerEventsMutationOwnerByScopeElement.get(scopeElement);
6043      if (existingOwner && existingOwner !== instance) {
6044        clearSafePolygonPointerEventsMutation(existingOwner);
6045      }
6046      clearSafePolygonPointerEventsMutation(instance);
6047      instance.performedPointerEventsMutation = true;
6048      instance.pointerEventsScopeElement = scopeElement;
6049      instance.pointerEventsReferenceElement = referenceElement;
6050      instance.pointerEventsFloatingElement = floatingElement;
6051      pointerEventsMutationOwnerByScopeElement.set(scopeElement, instance);
6052      scopeElement.style.pointerEvents = "none";
6053      referenceElement.style.pointerEvents = "auto";
6054      floatingElement.style.pointerEvents = "auto";
6055    }
6056    function useHoverInteractionSharedState(store2) {
6057      const data = store2.context.dataRef.current;
6058      const instance = useRefWithInit(() => data.hoverInteractionState ?? HoverInteraction.create()).current;
6059      if (!data.hoverInteractionState) {
6060        data.hoverInteractionState = instance;
6061      }
6062      useOnMount(data.hoverInteractionState.disposeEffect);
6063      return data.hoverInteractionState;
6064    }
6065  
6066    // node_modules/@base-ui/react/floating-ui-react/hooks/useHoverFloatingInteraction.mjs
6067    function useHoverFloatingInteraction(context, parameters = {}) {
6068      const {
6069        enabled = true,
6070        closeDelay: closeDelayProp = 0,
6071        nodeId: nodeIdProp
6072      } = parameters;
6073      const store2 = "rootStore" in context ? context.rootStore : context;
6074      const open = store2.useState("open");
6075      const floatingElement = store2.useState("floatingElement");
6076      const domReferenceElement = store2.useState("domReferenceElement");
6077      const {
6078        dataRef
6079      } = store2.context;
6080      const tree = useFloatingTree();
6081      const parentId = useFloatingParentNodeId();
6082      const instance = useHoverInteractionSharedState(store2);
6083      const childClosedTimeout = useTimeout();
6084      const isClickLikeOpenEvent2 = useStableCallback(() => {
6085        return isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside);
6086      });
6087      const isHoverOpen = useStableCallback(() => {
6088        return isHoverOpenEvent(dataRef.current.openEvent?.type);
6089      });
6090      const clearPointerEvents = useStableCallback(() => {
6091        clearSafePolygonPointerEventsMutation(instance);
6092      });
6093      useIsoLayoutEffect(() => {
6094        if (!open) {
6095          instance.pointerType = void 0;
6096          instance.restTimeoutPending = false;
6097          instance.interactedInside = false;
6098          clearPointerEvents();
6099        }
6100      }, [open, instance, clearPointerEvents]);
6101      React26.useEffect(() => {
6102        return clearPointerEvents;
6103      }, [clearPointerEvents]);
6104      useIsoLayoutEffect(() => {
6105        if (!enabled) {
6106          return void 0;
6107        }
6108        if (open && instance.handleCloseOptions?.blockPointerEvents && isHoverOpen() && isElement(domReferenceElement) && floatingElement) {
6109          const ref = domReferenceElement;
6110          const floatingEl = floatingElement;
6111          const doc = ownerDocument(floatingElement);
6112          const parentFloating = tree?.nodesRef.current.find((node) => node.id === parentId)?.context?.elements.floating;
6113          if (parentFloating) {
6114            parentFloating.style.pointerEvents = "";
6115          }
6116          const cachedScopeElement = instance.pointerEventsScopeElement !== floatingEl ? instance.pointerEventsScopeElement : null;
6117          const parentScopeElement = parentFloating !== floatingEl ? parentFloating : null;
6118          const scopeElement = instance.handleCloseOptions?.getScope?.() ?? cachedScopeElement ?? parentScopeElement ?? ref.closest("[data-rootownerid]") ?? doc.body;
6119          applySafePolygonPointerEventsMutation(instance, {
6120            scopeElement,
6121            referenceElement: ref,
6122            floatingElement: floatingEl
6123          });
6124          return () => {
6125            clearPointerEvents();
6126          };
6127        }
6128        return void 0;
6129      }, [enabled, open, domReferenceElement, floatingElement, instance, isHoverOpen, tree, parentId, clearPointerEvents]);
6130      React26.useEffect(() => {
6131        if (!enabled) {
6132          return void 0;
6133        }
6134        function hasParentChildren() {
6135          return !!(tree && parentId && getNodeChildren(tree.nodesRef.current, parentId).length > 0);
6136        }
6137        function closeWithDelay(event) {
6138          const closeDelay = getDelay(closeDelayProp, "close", instance.pointerType);
6139          const close = () => {
6140            store2.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
6141            tree?.events.emit("floating.closed", event);
6142          };
6143          if (closeDelay) {
6144            instance.openChangeTimeout.start(closeDelay, close);
6145          } else {
6146            instance.openChangeTimeout.clear();
6147            close();
6148          }
6149        }
6150        function handleInteractInside(event) {
6151          const target = getTarget(event);
6152          if (!isInteractiveElement(target)) {
6153            instance.interactedInside = false;
6154            return;
6155          }
6156          instance.interactedInside = target?.closest("[aria-haspopup]") != null;
6157        }
6158        function onFloatingMouseEnter() {
6159          instance.openChangeTimeout.clear();
6160          childClosedTimeout.clear();
6161          tree?.events.off("floating.closed", onNodeClosed);
6162          clearPointerEvents();
6163        }
6164        function onFloatingMouseLeave(event) {
6165          if (hasParentChildren() && tree) {
6166            tree.events.on("floating.closed", onNodeClosed);
6167            return;
6168          }
6169          if (isTargetInsideEnabledTrigger(event.relatedTarget, store2.context.triggerElements)) {
6170            return;
6171          }
6172          const currentNodeId = dataRef.current.floatingContext?.nodeId ?? nodeIdProp;
6173          const relatedTarget = event.relatedTarget;
6174          const isMovingIntoDescendantFloating = tree && currentNodeId && isElement(relatedTarget) && getNodeChildren(tree.nodesRef.current, currentNodeId, false).some((node) => contains(node.context?.elements.floating, relatedTarget));
6175          if (isMovingIntoDescendantFloating) {
6176            return;
6177          }
6178          if (instance.handler) {
6179            instance.handler(event);
6180            return;
6181          }
6182          clearPointerEvents();
6183          if (isHoverOpen() && !isClickLikeOpenEvent2()) {
6184            closeWithDelay(event);
6185          }
6186        }
6187        function onNodeClosed(event) {
6188          if (!tree || !parentId || hasParentChildren()) {
6189            return;
6190          }
6191          childClosedTimeout.start(0, () => {
6192            tree.events.off("floating.closed", onNodeClosed);
6193            store2.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
6194            tree.events.emit("floating.closed", event);
6195          });
6196        }
6197        const floating = floatingElement;
6198        return mergeCleanups(floating && addEventListener(floating, "mouseenter", onFloatingMouseEnter), floating && addEventListener(floating, "mouseleave", onFloatingMouseLeave), floating && addEventListener(floating, "pointerdown", handleInteractInside, true), () => {
6199          tree?.events.off("floating.closed", onNodeClosed);
6200        });
6201      }, [enabled, floatingElement, store2, dataRef, closeDelayProp, nodeIdProp, isHoverOpen, isClickLikeOpenEvent2, clearPointerEvents, instance, tree, parentId, childClosedTimeout]);
6202    }
6203  
6204    // node_modules/@base-ui/react/floating-ui-react/hooks/useHoverReferenceInteraction.mjs
6205    var React27 = __toESM(require_react(), 1);
6206    var ReactDOM5 = __toESM(require_react_dom(), 1);
6207    var EMPTY_REF = {
6208      current: null
6209    };
6210    function useHoverReferenceInteraction(context, props = {}) {
6211      const {
6212        enabled = true,
6213        delay = 0,
6214        handleClose = null,
6215        mouseOnly = false,
6216        restMs = 0,
6217        move: move2 = true,
6218        triggerElementRef = EMPTY_REF,
6219        externalTree,
6220        isActiveTrigger = true,
6221        getHandleCloseContext,
6222        isClosing,
6223        shouldOpen: shouldOpenProp,
6224        guardStaleOpen = false
6225      } = props;
6226      const store2 = "rootStore" in context ? context.rootStore : context;
6227      const {
6228        dataRef,
6229        events
6230      } = store2.context;
6231      const tree = useFloatingTree(externalTree);
6232      const instance = useHoverInteractionSharedState(store2);
6233      const isHoverCloseActiveRef = React27.useRef(false);
6234      const handleCloseRef = useValueAsRef(handleClose);
6235      const delayRef = useValueAsRef(delay);
6236      const restMsRef = useValueAsRef(restMs);
6237      const enabledRef = useValueAsRef(enabled);
6238      const shouldOpenRef = useValueAsRef(shouldOpenProp);
6239      const isClosingRef = useValueAsRef(isClosing);
6240      const isClickLikeOpenEvent2 = useStableCallback(() => {
6241        return isClickLikeOpenEvent(dataRef.current.openEvent?.type, instance.interactedInside);
6242      });
6243      const checkShouldOpen = useStableCallback(() => {
6244        return shouldOpenRef.current?.() !== false;
6245      });
6246      const isOverInactiveTrigger = useStableCallback((currentDomReference, currentTarget, target) => {
6247        const allTriggers = store2.context.triggerElements;
6248        if (allTriggers.hasElement(currentTarget)) {
6249          return !currentDomReference || !contains(currentDomReference, currentTarget);
6250        }
6251        if (!isElement(target)) {
6252          return false;
6253        }
6254        const targetElement = target;
6255        return allTriggers.hasMatchingElement((trigger) => contains(trigger, targetElement)) && (!currentDomReference || !contains(currentDomReference, targetElement));
6256      });
6257      const cleanupMouseMoveHandler = useStableCallback(() => {
6258        if (!instance.handler) {
6259          return;
6260        }
6261        const doc = ownerDocument(store2.select("domReferenceElement"));
6262        doc.removeEventListener("mousemove", instance.handler);
6263        instance.handler = void 0;
6264      });
6265      const clearPointerEvents = useStableCallback(() => {
6266        clearSafePolygonPointerEventsMutation(instance);
6267      });
6268      if (isActiveTrigger) {
6269        instance.handleCloseOptions = handleCloseRef.current?.__options;
6270      }
6271      React27.useEffect(() => cleanupMouseMoveHandler, [cleanupMouseMoveHandler]);
6272      React27.useEffect(() => {
6273        if (!enabled) {
6274          return void 0;
6275        }
6276        function onOpenChangeLocal(details) {
6277          if (!details.open) {
6278            isHoverCloseActiveRef.current = details.reason === reason_parts_exports.triggerHover;
6279            cleanupMouseMoveHandler();
6280            instance.openChangeTimeout.clear();
6281            instance.restTimeout.clear();
6282            instance.blockMouseMove = true;
6283            instance.restTimeoutPending = false;
6284          } else {
6285            isHoverCloseActiveRef.current = false;
6286          }
6287        }
6288        events.on("openchange", onOpenChangeLocal);
6289        return () => {
6290          events.off("openchange", onOpenChangeLocal);
6291        };
6292      }, [enabled, events, instance, cleanupMouseMoveHandler]);
6293      React27.useEffect(() => {
6294        if (!enabled) {
6295          return void 0;
6296        }
6297        function closeWithDelay(event, runElseBranch = true) {
6298          const closeDelay = getDelay(delayRef.current, "close", instance.pointerType);
6299          if (closeDelay) {
6300            instance.openChangeTimeout.start(closeDelay, () => {
6301              store2.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
6302              tree?.events.emit("floating.closed", event);
6303            });
6304          } else if (runElseBranch) {
6305            instance.openChangeTimeout.clear();
6306            store2.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
6307            tree?.events.emit("floating.closed", event);
6308          }
6309        }
6310        const trigger = triggerElementRef.current ?? (isActiveTrigger ? store2.select("domReferenceElement") : null);
6311        if (!isElement(trigger)) {
6312          return void 0;
6313        }
6314        function onMouseEnter(event) {
6315          instance.openChangeTimeout.clear();
6316          instance.blockMouseMove = false;
6317          if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
6318            return;
6319          }
6320          const restMsValue = getRestMs(restMsRef.current);
6321          const openDelay = getDelay(delayRef.current, "open", instance.pointerType);
6322          const eventTarget = getTarget(event);
6323          const currentTarget = event.currentTarget ?? null;
6324          const currentDomReference = store2.select("domReferenceElement");
6325          let triggerNode = currentTarget;
6326          if (isElement(eventTarget) && !store2.context.triggerElements.hasElement(eventTarget)) {
6327            for (const triggerElement of store2.context.triggerElements.elements()) {
6328              if (contains(triggerElement, eventTarget)) {
6329                triggerNode = triggerElement;
6330                break;
6331              }
6332            }
6333          }
6334          if (isElement(currentTarget) && isElement(currentDomReference) && !store2.context.triggerElements.hasElement(currentTarget) && contains(currentTarget, currentDomReference)) {
6335            triggerNode = currentDomReference;
6336          }
6337          const isOverInactive = triggerNode == null ? false : isOverInactiveTrigger(currentDomReference, triggerNode, eventTarget);
6338          const isOpen = store2.select("open");
6339          const isInClosingTransition = isClosingRef.current?.() ?? store2.select("transitionStatus") === "ending";
6340          const isHoverCloseTransition = !isOpen && isInClosingTransition && isHoverCloseActiveRef.current;
6341          const isReenteringSameTriggerDuringCloseTransition = !isOverInactive && isElement(triggerNode) && isElement(currentDomReference) && contains(currentDomReference, triggerNode) && isHoverCloseTransition;
6342          const isRestOnlyDelay = restMsValue > 0 && !openDelay;
6343          const shouldOpenImmediately = isOverInactive && (isOpen || isHoverCloseTransition) || isReenteringSameTriggerDuringCloseTransition;
6344          const shouldOpen = !isOpen || isOverInactive;
6345          if (shouldOpenImmediately) {
6346            if (checkShouldOpen()) {
6347              store2.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerNode));
6348            }
6349            return;
6350          }
6351          if (isRestOnlyDelay) {
6352            return;
6353          }
6354          if (openDelay) {
6355            instance.openChangeTimeout.start(openDelay, () => {
6356              if (shouldOpen && checkShouldOpen()) {
6357                store2.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerNode));
6358              }
6359            });
6360          } else if (shouldOpen) {
6361            if (checkShouldOpen()) {
6362              store2.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerNode));
6363            }
6364          }
6365        }
6366        function onMouseLeave(event) {
6367          if (isClickLikeOpenEvent2()) {
6368            clearPointerEvents();
6369            return;
6370          }
6371          cleanupMouseMoveHandler();
6372          const domReferenceElement = store2.select("domReferenceElement");
6373          const doc = ownerDocument(domReferenceElement);
6374          instance.restTimeout.clear();
6375          instance.restTimeoutPending = false;
6376          const handleCloseContextBase = dataRef.current.floatingContext ?? getHandleCloseContext?.();
6377          if (isTargetInsideEnabledTrigger(event.relatedTarget, store2.context.triggerElements)) {
6378            return;
6379          }
6380          if (handleCloseRef.current && handleCloseContextBase) {
6381            if (!store2.select("open")) {
6382              instance.openChangeTimeout.clear();
6383            }
6384            const currentTrigger = triggerElementRef.current;
6385            instance.handler = handleCloseRef.current({
6386              ...handleCloseContextBase,
6387              tree,
6388              x: event.clientX,
6389              y: event.clientY,
6390              onClose() {
6391                clearPointerEvents();
6392                cleanupMouseMoveHandler();
6393                if (enabledRef.current && !isClickLikeOpenEvent2() && currentTrigger === store2.select("domReferenceElement")) {
6394                  closeWithDelay(event, true);
6395                }
6396              }
6397            });
6398            doc.addEventListener("mousemove", instance.handler);
6399            instance.handler(event);
6400            return;
6401          }
6402          const shouldClose = instance.pointerType === "touch" ? !contains(store2.select("floatingElement"), event.relatedTarget) : true;
6403          if (shouldClose) {
6404            closeWithDelay(event);
6405          }
6406        }
6407        function onMouseOut(event) {
6408          if (contains(trigger, event.relatedTarget)) {
6409            return;
6410          }
6411          instance.openChangeTimeout.clear();
6412          instance.restTimeout.clear();
6413          instance.restTimeoutPending = false;
6414        }
6415        const staleOpenGuard = guardStaleOpen ? addEventListener(trigger, "mouseout", onMouseOut) : void 0;
6416        if (move2) {
6417          return mergeCleanups(addEventListener(trigger, "mousemove", onMouseEnter, {
6418            once: true
6419          }), addEventListener(trigger, "mouseenter", onMouseEnter), addEventListener(trigger, "mouseleave", onMouseLeave), staleOpenGuard);
6420        }
6421        return mergeCleanups(addEventListener(trigger, "mouseenter", onMouseEnter), addEventListener(trigger, "mouseleave", onMouseLeave), staleOpenGuard);
6422      }, [cleanupMouseMoveHandler, clearPointerEvents, dataRef, delayRef, store2, enabled, handleCloseRef, instance, isActiveTrigger, isOverInactiveTrigger, isClickLikeOpenEvent2, mouseOnly, move2, restMsRef, triggerElementRef, tree, enabledRef, getHandleCloseContext, isClosingRef, checkShouldOpen, guardStaleOpen]);
6423      return React27.useMemo(() => {
6424        if (!enabled) {
6425          return void 0;
6426        }
6427        function setPointerRef(event) {
6428          instance.pointerType = event.pointerType;
6429        }
6430        return {
6431          onPointerDown: setPointerRef,
6432          onPointerEnter: setPointerRef,
6433          onMouseMove(event) {
6434            const {
6435              nativeEvent
6436            } = event;
6437            const trigger = event.currentTarget;
6438            const currentDomReference = store2.select("domReferenceElement");
6439            const currentOpen = store2.select("open");
6440            const isOverInactive = isOverInactiveTrigger(currentDomReference, trigger, event.target);
6441            if (mouseOnly && !isMouseLikePointerType(instance.pointerType)) {
6442              return;
6443            }
6444            if (currentOpen && isOverInactive && instance.handleCloseOptions?.blockPointerEvents) {
6445              const floatingElement = store2.select("floatingElement");
6446              if (floatingElement) {
6447                const scopeElement = instance.handleCloseOptions?.getScope?.() ?? trigger.ownerDocument.body;
6448                applySafePolygonPointerEventsMutation(instance, {
6449                  scopeElement,
6450                  referenceElement: trigger,
6451                  floatingElement
6452                });
6453              }
6454            }
6455            const restMsValue = getRestMs(restMsRef.current);
6456            if (currentOpen && !isOverInactive || restMsValue === 0) {
6457              return;
6458            }
6459            if (!isOverInactive && instance.restTimeoutPending && event.movementX ** 2 + event.movementY ** 2 < 2) {
6460              return;
6461            }
6462            instance.restTimeout.clear();
6463            function handleMouseMove() {
6464              instance.restTimeoutPending = false;
6465              if (isClickLikeOpenEvent2()) {
6466                return;
6467              }
6468              const latestOpen = store2.select("open");
6469              if (!instance.blockMouseMove && (!latestOpen || isOverInactive) && checkShouldOpen()) {
6470                store2.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, nativeEvent, trigger));
6471              }
6472            }
6473            if (instance.pointerType === "touch") {
6474              ReactDOM5.flushSync(() => {
6475                handleMouseMove();
6476              });
6477            } else if (isOverInactive && currentOpen) {
6478              handleMouseMove();
6479            } else {
6480              instance.restTimeoutPending = true;
6481              instance.restTimeout.start(restMsValue, handleMouseMove);
6482            }
6483          }
6484        };
6485      }, [enabled, instance, isClickLikeOpenEvent2, isOverInactiveTrigger, mouseOnly, store2, restMsRef, checkShouldOpen]);
6486    }
6487  
6488    // node_modules/@base-ui/react/floating-ui-react/safePolygon.mjs
6489    var CURSOR_SPEED_THRESHOLD = 0.1;
6490    var CURSOR_SPEED_THRESHOLD_SQUARED = CURSOR_SPEED_THRESHOLD * CURSOR_SPEED_THRESHOLD;
6491    var POLYGON_BUFFER = 0.5;
6492    function hasIntersectingEdge(pointX, pointY, xi, yi, xj, yj) {
6493      return yi >= pointY !== yj >= pointY && pointX <= (xj - xi) * (pointY - yi) / (yj - yi) + xi;
6494    }
6495    function isPointInQuadrilateral(pointX, pointY, x1, y1, x2, y2, x3, y3, x4, y4) {
6496      let isInsideValue = false;
6497      if (hasIntersectingEdge(pointX, pointY, x1, y1, x2, y2)) {
6498        isInsideValue = !isInsideValue;
6499      }
6500      if (hasIntersectingEdge(pointX, pointY, x2, y2, x3, y3)) {
6501        isInsideValue = !isInsideValue;
6502      }
6503      if (hasIntersectingEdge(pointX, pointY, x3, y3, x4, y4)) {
6504        isInsideValue = !isInsideValue;
6505      }
6506      if (hasIntersectingEdge(pointX, pointY, x4, y4, x1, y1)) {
6507        isInsideValue = !isInsideValue;
6508      }
6509      return isInsideValue;
6510    }
6511    function isInsideRect(pointX, pointY, rect) {
6512      return pointX >= rect.x && pointX <= rect.x + rect.width && pointY >= rect.y && pointY <= rect.y + rect.height;
6513    }
6514    function isInsideAxisAlignedRect(pointX, pointY, x1, y1, x2, y2) {
6515      const minX = Math.min(x1, x2);
6516      const maxX = Math.max(x1, x2);
6517      const minY = Math.min(y1, y2);
6518      const maxY = Math.max(y1, y2);
6519      return pointX >= minX && pointX <= maxX && pointY >= minY && pointY <= maxY;
6520    }
6521    function safePolygon(options = {}) {
6522      const {
6523        blockPointerEvents = false
6524      } = options;
6525      const timeout = new Timeout();
6526      const fn = ({
6527        x,
6528        y,
6529        placement,
6530        elements,
6531        onClose,
6532        nodeId,
6533        tree
6534      }) => {
6535        const side = placement?.split("-")[0];
6536        let hasLanded = false;
6537        let lastX = null;
6538        let lastY = null;
6539        let lastCursorTime = typeof performance !== "undefined" ? performance.now() : 0;
6540        function isCursorMovingSlowly(nextX, nextY) {
6541          const currentTime = performance.now();
6542          const elapsedTime = currentTime - lastCursorTime;
6543          if (lastX === null || lastY === null || elapsedTime === 0) {
6544            lastX = nextX;
6545            lastY = nextY;
6546            lastCursorTime = currentTime;
6547            return false;
6548          }
6549          const deltaX = nextX - lastX;
6550          const deltaY = nextY - lastY;
6551          const distanceSquared = deltaX * deltaX + deltaY * deltaY;
6552          const thresholdSquared = elapsedTime * elapsedTime * CURSOR_SPEED_THRESHOLD_SQUARED;
6553          lastX = nextX;
6554          lastY = nextY;
6555          lastCursorTime = currentTime;
6556          return distanceSquared < thresholdSquared;
6557        }
6558        function close() {
6559          timeout.clear();
6560          onClose();
6561        }
6562        return function onMouseMove(event) {
6563          timeout.clear();
6564          const domReference = elements.domReference;
6565          const floating = elements.floating;
6566          if (!domReference || !floating || side == null || x == null || y == null) {
6567            return void 0;
6568          }
6569          const {
6570            clientX,
6571            clientY
6572          } = event;
6573          const target = getTarget(event);
6574          const isLeave = event.type === "mouseleave";
6575          const isOverFloatingEl = contains(floating, target);
6576          const isOverReferenceEl = contains(domReference, target);
6577          if (isOverFloatingEl) {
6578            hasLanded = true;
6579            if (!isLeave) {
6580              return void 0;
6581            }
6582          }
6583          if (isOverReferenceEl) {
6584            hasLanded = false;
6585            if (!isLeave) {
6586              hasLanded = true;
6587              return void 0;
6588            }
6589          }
6590          if (isLeave && isElement(event.relatedTarget) && contains(floating, event.relatedTarget)) {
6591            return void 0;
6592          }
6593          function hasOpenChildNode() {
6594            return Boolean(tree && getNodeChildren(tree.nodesRef.current, nodeId).length > 0);
6595          }
6596          function closeIfNoOpenChild() {
6597            if (!hasOpenChildNode()) {
6598              close();
6599            }
6600          }
6601          if (hasOpenChildNode()) {
6602            return void 0;
6603          }
6604          const refRect = domReference.getBoundingClientRect();
6605          const rect = floating.getBoundingClientRect();
6606          const cursorLeaveFromRight = x > rect.right - rect.width / 2;
6607          const cursorLeaveFromBottom = y > rect.bottom - rect.height / 2;
6608          const isFloatingWider = rect.width > refRect.width;
6609          const isFloatingTaller = rect.height > refRect.height;
6610          const left = (isFloatingWider ? refRect : rect).left;
6611          const right = (isFloatingWider ? refRect : rect).right;
6612          const top = (isFloatingTaller ? refRect : rect).top;
6613          const bottom = (isFloatingTaller ? refRect : rect).bottom;
6614          if (side === "top" && y >= refRect.bottom - 1 || side === "bottom" && y <= refRect.top + 1 || side === "left" && x >= refRect.right - 1 || side === "right" && x <= refRect.left + 1) {
6615            closeIfNoOpenChild();
6616            return void 0;
6617          }
6618          let isInsideTroughRect = false;
6619          switch (side) {
6620            case "top":
6621              isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, left, refRect.top + 1, right, rect.bottom - 1);
6622              break;
6623            case "bottom":
6624              isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, left, rect.top + 1, right, refRect.bottom - 1);
6625              break;
6626            case "left":
6627              isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, rect.right - 1, bottom, refRect.left + 1, top);
6628              break;
6629            case "right":
6630              isInsideTroughRect = isInsideAxisAlignedRect(clientX, clientY, refRect.right - 1, bottom, rect.left + 1, top);
6631              break;
6632            default:
6633          }
6634          if (isInsideTroughRect) {
6635            return void 0;
6636          }
6637          if (hasLanded && !isInsideRect(clientX, clientY, refRect)) {
6638            closeIfNoOpenChild();
6639            return void 0;
6640          }
6641          if (!isLeave && isCursorMovingSlowly(clientX, clientY)) {
6642            closeIfNoOpenChild();
6643            return void 0;
6644          }
6645          let isInsidePolygon = false;
6646          switch (side) {
6647            case "top": {
6648              const cursorXOffset = isFloatingWider ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
6649              const cursorPointOneX = isFloatingWider ? x + cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
6650              const cursorPointTwoX = isFloatingWider ? x - cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
6651              const cursorPointY = y + POLYGON_BUFFER + 1;
6652              const commonYLeft = cursorLeaveFromRight ? rect.bottom - POLYGON_BUFFER : isFloatingWider ? rect.bottom - POLYGON_BUFFER : rect.top;
6653              const commonYRight = cursorLeaveFromRight ? isFloatingWider ? rect.bottom - POLYGON_BUFFER : rect.top : rect.bottom - POLYGON_BUFFER;
6654              isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointOneX, cursorPointY, cursorPointTwoX, cursorPointY, rect.left, commonYLeft, rect.right, commonYRight);
6655              break;
6656            }
6657            case "bottom": {
6658              const cursorXOffset = isFloatingWider ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
6659              const cursorPointOneX = isFloatingWider ? x + cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
6660              const cursorPointTwoX = isFloatingWider ? x - cursorXOffset : cursorLeaveFromRight ? x + cursorXOffset : x - cursorXOffset;
6661              const cursorPointY = y - POLYGON_BUFFER;
6662              const commonYLeft = cursorLeaveFromRight ? rect.top + POLYGON_BUFFER : isFloatingWider ? rect.top + POLYGON_BUFFER : rect.bottom;
6663              const commonYRight = cursorLeaveFromRight ? isFloatingWider ? rect.top + POLYGON_BUFFER : rect.bottom : rect.top + POLYGON_BUFFER;
6664              isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointOneX, cursorPointY, cursorPointTwoX, cursorPointY, rect.left, commonYLeft, rect.right, commonYRight);
6665              break;
6666            }
6667            case "left": {
6668              const cursorYOffset = isFloatingTaller ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
6669              const cursorPointOneY = isFloatingTaller ? y + cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
6670              const cursorPointTwoY = isFloatingTaller ? y - cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
6671              const cursorPointX = x + POLYGON_BUFFER + 1;
6672              const commonXTop = cursorLeaveFromBottom ? rect.right - POLYGON_BUFFER : isFloatingTaller ? rect.right - POLYGON_BUFFER : rect.left;
6673              const commonXBottom = cursorLeaveFromBottom ? isFloatingTaller ? rect.right - POLYGON_BUFFER : rect.left : rect.right - POLYGON_BUFFER;
6674              isInsidePolygon = isPointInQuadrilateral(clientX, clientY, commonXTop, rect.top, commonXBottom, rect.bottom, cursorPointX, cursorPointOneY, cursorPointX, cursorPointTwoY);
6675              break;
6676            }
6677            case "right": {
6678              const cursorYOffset = isFloatingTaller ? POLYGON_BUFFER / 2 : POLYGON_BUFFER * 4;
6679              const cursorPointOneY = isFloatingTaller ? y + cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
6680              const cursorPointTwoY = isFloatingTaller ? y - cursorYOffset : cursorLeaveFromBottom ? y + cursorYOffset : y - cursorYOffset;
6681              const cursorPointX = x - POLYGON_BUFFER;
6682              const commonXTop = cursorLeaveFromBottom ? rect.left + POLYGON_BUFFER : isFloatingTaller ? rect.left + POLYGON_BUFFER : rect.right;
6683              const commonXBottom = cursorLeaveFromBottom ? isFloatingTaller ? rect.left + POLYGON_BUFFER : rect.right : rect.left + POLYGON_BUFFER;
6684              isInsidePolygon = isPointInQuadrilateral(clientX, clientY, cursorPointX, cursorPointOneY, cursorPointX, cursorPointTwoY, commonXTop, rect.top, commonXBottom, rect.bottom);
6685              break;
6686            }
6687            default:
6688          }
6689          if (!isInsidePolygon) {
6690            closeIfNoOpenChild();
6691          } else if (!hasLanded) {
6692            timeout.start(40, closeIfNoOpenChild);
6693          }
6694          return void 0;
6695        };
6696      };
6697      fn.__options = {
6698        ...options,
6699        blockPointerEvents
6700      };
6701      return fn;
6702    }
6703  
6704    // node_modules/@base-ui/react/utils/NullStore.mjs
6705    var NullStore = class extends ReactStore {
6706      // `update`/`set`/`notifyAll` funnel through `setState` in the base `Store`, so overriding
6707      // `setState` alone would neutralize them today. They are overridden explicitly so the store stays
6708      // inert even if a future base-class change stops routing a mutator through `setState`.
6709      setState(_newState) {
6710      }
6711      update(_changes) {
6712      }
6713      set(_key, _value) {
6714      }
6715      notifyAll() {
6716      }
6717    };
6718  
6719    // node_modules/@base-ui/react/utils/popupStateMapping.mjs
6720    var CommonPopupDataAttributes = (function(CommonPopupDataAttributes2) {
6721      CommonPopupDataAttributes2["open"] = "data-open";
6722      CommonPopupDataAttributes2["closed"] = "data-closed";
6723      CommonPopupDataAttributes2[CommonPopupDataAttributes2["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
6724      CommonPopupDataAttributes2[CommonPopupDataAttributes2["endingStyle"] = TransitionStatusDataAttributes.endingStyle] = "endingStyle";
6725      CommonPopupDataAttributes2["anchorHidden"] = "data-anchor-hidden";
6726      CommonPopupDataAttributes2["side"] = "data-side";
6727      CommonPopupDataAttributes2["align"] = "data-align";
6728      return CommonPopupDataAttributes2;
6729    })({});
6730    var TRIGGER_HOOK = {
6731      "data-popup-open": ""
6732    };
6733    var POPUP_OPEN_HOOK = {
6734      "data-open": ""
6735    };
6736    var POPUP_CLOSED_HOOK = {
6737      "data-closed": ""
6738    };
6739    var ANCHOR_HIDDEN_HOOK = {
6740      "data-anchor-hidden": ""
6741    };
6742    var triggerOpenStateMapping = {
6743      open(value) {
6744        if (value) {
6745          return TRIGGER_HOOK;
6746        }
6747        return null;
6748      }
6749    };
6750    var popupStateMapping = {
6751      open(value) {
6752        if (value) {
6753          return POPUP_OPEN_HOOK;
6754        }
6755        return POPUP_CLOSED_HOOK;
6756      },
6757      anchorHidden(value) {
6758        if (value) {
6759          return ANCHOR_HIDDEN_HOOK;
6760        }
6761        return null;
6762      }
6763    };
6764    var popupTransitionStateMapping = {
6765      ...popupStateMapping,
6766      ...transitionStatusMapping
6767    };
6768  
6769    // node_modules/@base-ui/utils/inertValue.mjs
6770    function inertValue(value) {
6771      if (isReactVersionAtLeast(19)) {
6772        return value;
6773      }
6774      return value ? "true" : void 0;
6775    }
6776  
6777    // node_modules/@base-ui/react/internals/direction-context/DirectionContext.mjs
6778    var React28 = __toESM(require_react(), 1);
6779    var DirectionContext = /* @__PURE__ */ React28.createContext(void 0);
6780    if (true) DirectionContext.displayName = "DirectionContext";
6781    function useDirection() {
6782      const context = React28.useContext(DirectionContext);
6783      return context?.direction ?? "ltr";
6784    }
6785  
6786    // node_modules/@base-ui/react/internals/useAnchorPositioning.mjs
6787    var React29 = __toESM(require_react(), 1);
6788  
6789    // node_modules/@base-ui/react/floating-ui-react/middleware/arrow.mjs
6790    var baseArrow = (options) => ({
6791      name: "arrow",
6792      options,
6793      async fn(state) {
6794        const {
6795          x,
6796          y,
6797          placement,
6798          rects,
6799          platform: platform3,
6800          elements,
6801          middlewareData
6802        } = state;
6803        const {
6804          element,
6805          padding = 0,
6806          offsetParent = "real"
6807        } = evaluate(options, state) || {};
6808        if (element == null) {
6809          return {};
6810        }
6811        const paddingObject = getPaddingObject(padding);
6812        const coords = {
6813          x,
6814          y
6815        };
6816        const axis = getAlignmentAxis(placement);
6817        const length = getAxisLength(axis);
6818        const arrowDimensions = await platform3.getDimensions(element);
6819        const isYAxis = axis === "y";
6820        const minProp = isYAxis ? "top" : "left";
6821        const maxProp = isYAxis ? "bottom" : "right";
6822        const clientProp = isYAxis ? "clientHeight" : "clientWidth";
6823        const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
6824        const startDiff = coords[axis] - rects.reference[axis];
6825        const arrowOffsetParent = offsetParent === "real" ? await platform3.getOffsetParent?.(element) : elements.floating;
6826        let clientSize = elements.floating[clientProp] || rects.floating[length];
6827        if (!clientSize || !await platform3.isElement?.(arrowOffsetParent)) {
6828          clientSize = elements.floating[clientProp] || rects.floating[length];
6829        }
6830        const centerToReference = endDiff / 2 - startDiff / 2;
6831        const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
6832        const minPadding = Math.min(paddingObject[minProp], largestPossiblePadding);
6833        const maxPadding = Math.min(paddingObject[maxProp], largestPossiblePadding);
6834        const min2 = minPadding;
6835        const max2 = clientSize - arrowDimensions[length] - maxPadding;
6836        const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
6837        const offset4 = clamp(min2, center, max2);
6838        const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length] / 2 - (center < min2 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
6839        const alignmentOffset = shouldAddOffset ? center < min2 ? center - min2 : center - max2 : 0;
6840        return {
6841          [axis]: coords[axis] + alignmentOffset,
6842          data: {
6843            [axis]: offset4,
6844            centerOffset: center - offset4 - alignmentOffset,
6845            ...shouldAddOffset && {
6846              alignmentOffset
6847            }
6848          },
6849          reset: shouldAddOffset
6850        };
6851      }
6852    });
6853    var arrow4 = (options, deps) => ({
6854      ...baseArrow(options),
6855      options: [options, deps]
6856    });
6857  
6858    // node_modules/@base-ui/react/utils/hideMiddleware.mjs
6859    var hide4 = {
6860      name: "hide",
6861      async fn(state) {
6862        const {
6863          width,
6864          height,
6865          x,
6866          y
6867        } = state.rects.reference;
6868        const anchorHidden = width === 0 && height === 0 && x === 0 && y === 0;
6869        const overflow = await state.platform.detectOverflow(state, {
6870          elementContext: "reference"
6871        });
6872        const referenceHidden = overflow.top - height >= 0 || overflow.right - width >= 0 || overflow.bottom - height >= 0 || overflow.left - width >= 0;
6873        return {
6874          data: {
6875            referenceHidden: referenceHidden || anchorHidden
6876          }
6877        };
6878      }
6879    };
6880  
6881    // node_modules/@base-ui/react/utils/adaptiveOriginConstants.mjs
6882    var DEFAULT_SIDES = {
6883      sideX: "left",
6884      sideY: "top"
6885    };
6886  
6887    // node_modules/@base-ui/react/internals/useAnchorPositioning.mjs
6888    var AVAILABLE_WIDTH_VAR = "--available-width";
6889    var AVAILABLE_HEIGHT_VAR = "--available-height";
6890    function getLogicalSide(sideParam, renderedSide, isRtl) {
6891      const isLogicalSideParam = sideParam === "inline-start" || sideParam === "inline-end";
6892      const logicalRight = isRtl ? "inline-start" : "inline-end";
6893      const logicalLeft = isRtl ? "inline-end" : "inline-start";
6894      return {
6895        top: "top",
6896        right: isLogicalSideParam ? logicalRight : "right",
6897        bottom: "bottom",
6898        left: isLogicalSideParam ? logicalLeft : "left"
6899      }[renderedSide];
6900    }
6901    function getOffsetData(state, sideParam, isRtl) {
6902      const {
6903        rects,
6904        placement
6905      } = state;
6906      const data = {
6907        side: getLogicalSide(sideParam, getSide(placement), isRtl),
6908        align: getAlignment(placement) || "center",
6909        anchor: {
6910          width: rects.reference.width,
6911          height: rects.reference.height
6912        },
6913        positioner: {
6914          width: rects.floating.width,
6915          height: rects.floating.height
6916        }
6917      };
6918      return data;
6919    }
6920    function useAnchorPositioning(params) {
6921      return useAnchorPositioningWithHook(params, useBaseUIFloating);
6922    }
6923    function useAnchorPositioningWithHook(params, useFloatingHook) {
6924      const {
6925        // Public parameters
6926        anchor,
6927        positionMethod = "absolute",
6928        side: sideParam = "bottom",
6929        sideOffset = 0,
6930        align = "center",
6931        alignOffset = 0,
6932        collisionBoundary,
6933        collisionPadding: collisionPaddingParam = 5,
6934        sticky = false,
6935        arrowPadding = 5,
6936        disableAnchorTracking = false,
6937        inline: inlineMiddleware,
6938        // Private parameters
6939        keepMounted = false,
6940        floatingRootContext,
6941        mounted,
6942        collisionAvoidance,
6943        shift: shift4,
6944        nodeId,
6945        adaptiveOrigin: adaptiveOrigin2,
6946        lazyFlip = false,
6947        externalTree
6948      } = params;
6949      const [mountSide, setMountSide] = React29.useState(null);
6950      if (!mounted && mountSide !== null) {
6951        setMountSide(null);
6952      }
6953      const collisionAvoidanceSide = collisionAvoidance.side || "flip";
6954      const collisionAvoidanceAlign = collisionAvoidance.align || "flip";
6955      const collisionAvoidanceFallbackAxisSide = collisionAvoidance.fallbackAxisSide || "end";
6956      const shiftCrossAxis = shift4?.crossAxis ?? false;
6957      const shiftRootBoundary = shift4?.rootBoundary;
6958      const anchorFn = typeof anchor === "function" ? anchor : void 0;
6959      const anchorFnCallback = useStableCallback(anchorFn);
6960      const anchorDep = anchorFn ? anchorFnCallback : anchor;
6961      const anchorValueRef = useValueAsRef(anchor);
6962      const mountedRef = useValueAsRef(mounted);
6963      const direction = useDirection();
6964      const isRtl = direction === "rtl";
6965      const side = mountSide || {
6966        top: "top",
6967        right: "right",
6968        bottom: "bottom",
6969        left: "left",
6970        "inline-end": isRtl ? "left" : "right",
6971        "inline-start": isRtl ? "right" : "left"
6972      }[sideParam];
6973      const placement = align === "center" ? side : `$side}-$align}`;
6974      let collisionPadding = collisionPaddingParam;
6975      if (typeof collisionPadding === "number") {
6976        collisionPadding = {
6977          top: collisionPadding,
6978          right: collisionPadding,
6979          bottom: collisionPadding,
6980          left: collisionPadding
6981        };
6982      } else if (collisionPadding) {
6983        collisionPadding = {
6984          top: collisionPadding.top || 0,
6985          right: collisionPadding.right || 0,
6986          bottom: collisionPadding.bottom || 0,
6987          left: collisionPadding.left || 0
6988        };
6989      }
6990      const bias = 1;
6991      const biasTop = sideParam === "bottom" ? bias : 0;
6992      const biasBottom = sideParam === "top" ? bias : 0;
6993      const biasLeft = sideParam === "right" ? bias : 0;
6994      const biasRight = sideParam === "left" ? bias : 0;
6995      const commonCollisionProps = {
6996        boundary: collisionBoundary === "clipping-ancestors" ? "clippingAncestors" : collisionBoundary,
6997        padding: collisionPadding
6998      };
6999      const arrowRef = React29.useRef(null);
7000      const sideOffsetRef = useValueAsRef(sideOffset);
7001      const alignOffsetRef = useValueAsRef(alignOffset);
7002      const sideOffsetDep = typeof sideOffset !== "function" ? sideOffset : 0;
7003      const alignOffsetDep = typeof alignOffset !== "function" ? alignOffset : 0;
7004      const middleware = [];
7005      if (inlineMiddleware) {
7006        middleware.push(inlineMiddleware);
7007      }
7008      middleware.push(offset3((state) => {
7009        const data = getOffsetData(state, sideParam, isRtl);
7010        const sideAxis = typeof sideOffsetRef.current === "function" ? sideOffsetRef.current(data) : sideOffsetRef.current;
7011        const alignAxis = typeof alignOffsetRef.current === "function" ? alignOffsetRef.current(data) : alignOffsetRef.current;
7012        return {
7013          mainAxis: sideAxis,
7014          crossAxis: alignAxis,
7015          alignmentAxis: alignAxis
7016        };
7017      }, [sideOffsetDep, alignOffsetDep, isRtl, sideParam]));
7018      const shiftDisabled = collisionAvoidanceAlign === "none" && collisionAvoidanceSide !== "shift";
7019      const crossAxisShiftEnabled = !shiftDisabled && (sticky || shiftCrossAxis || collisionAvoidanceSide === "shift");
7020      const flipMiddleware = collisionAvoidanceSide === "none" ? null : flip3({
7021        ...commonCollisionProps,
7022        // Ensure the popup flips if it's been limited by its --available-height and it resizes.
7023        // Since the size() padding is smaller than the flip() padding, flip() will take precedence.
7024        padding: {
7025          top: collisionPadding.top + bias + biasTop,
7026          right: collisionPadding.right + bias + biasRight,
7027          bottom: collisionPadding.bottom + bias + biasBottom,
7028          left: collisionPadding.left + bias + biasLeft
7029        },
7030        mainAxis: !shiftCrossAxis && collisionAvoidanceSide === "flip",
7031        crossAxis: collisionAvoidanceAlign === "flip" ? "alignment" : false,
7032        fallbackAxisSideDirection: collisionAvoidanceFallbackAxisSide
7033      });
7034      const shiftMiddleware = shiftDisabled ? null : shift3({
7035        ...commonCollisionProps,
7036        // Use the Layout Viewport to avoid shifting around when pinch-zooming.
7037        rootBoundary: shiftRootBoundary,
7038        mainAxis: collisionAvoidanceAlign !== "none",
7039        crossAxis: crossAxisShiftEnabled,
7040        limiter: sticky || shiftCrossAxis ? void 0 : limitShift3((limitData) => {
7041          if (!arrowRef.current) {
7042            return {};
7043          }
7044          const {
7045            width,
7046            height
7047          } = arrowRef.current.getBoundingClientRect();
7048          const sideAxis = getSideAxis(getSide(limitData.placement));
7049          const arrowSize = sideAxis === "y" ? width : height;
7050          const offsetAmount = sideAxis === "y" ? collisionPadding.left + collisionPadding.right : collisionPadding.top + collisionPadding.bottom;
7051          return {
7052            offset: arrowSize / 2 + offsetAmount / 2
7053          };
7054        })
7055      }, [commonCollisionProps, sticky, shiftCrossAxis, shiftRootBoundary, collisionPadding, collisionAvoidanceAlign]);
7056      if (collisionAvoidanceSide === "shift" || collisionAvoidanceAlign === "shift" || align === "center") {
7057        middleware.push(shiftMiddleware, flipMiddleware);
7058      } else {
7059        middleware.push(flipMiddleware, shiftMiddleware);
7060      }
7061      middleware.push(size3({
7062        ...commonCollisionProps,
7063        apply({
7064          elements: {
7065            floating
7066          },
7067          availableWidth,
7068          availableHeight,
7069          rects
7070        }) {
7071          if (!mountedRef.current) {
7072            return;
7073          }
7074          const floatingStyle = floating.style;
7075          floatingStyle.setProperty(AVAILABLE_WIDTH_VAR, `$availableWidth}px`);
7076          floatingStyle.setProperty(AVAILABLE_HEIGHT_VAR, `$availableHeight}px`);
7077          const dpr = getWindow(floating).devicePixelRatio || 1;
7078          const {
7079            x: x2,
7080            y: y2,
7081            width,
7082            height
7083          } = rects.reference;
7084          const anchorWidth = (Math.round((x2 + width) * dpr) - Math.round(x2 * dpr)) / dpr;
7085          const anchorHeight = (Math.round((y2 + height) * dpr) - Math.round(y2 * dpr)) / dpr;
7086          floatingStyle.setProperty("--anchor-width", `$anchorWidth}px`);
7087          floatingStyle.setProperty("--anchor-height", `$anchorHeight}px`);
7088        }
7089      }), arrow4((state) => ({
7090        // `transform-origin` calculations rely on an element existing. If the arrow hasn't been set,
7091        // we'll create a fake element.
7092        element: arrowRef.current || ownerDocument(state.elements.floating).createElement("div"),
7093        padding: arrowPadding,
7094        offsetParent: "floating"
7095      }), [arrowPadding]), {
7096        name: "transformOrigin",
7097        fn(state) {
7098          const {
7099            elements: elements2,
7100            middlewareData: middlewareData2,
7101            placement: renderedPlacement2,
7102            rects,
7103            y: y2
7104          } = state;
7105          const currentRenderedSide = getSide(renderedPlacement2);
7106          const currentRenderedAxis = getSideAxis(currentRenderedSide);
7107          const arrowEl = arrowRef.current;
7108          const arrowX = middlewareData2.arrow?.x || 0;
7109          const arrowY = middlewareData2.arrow?.y || 0;
7110          const arrowWidth = arrowEl?.clientWidth || 0;
7111          const arrowHeight = arrowEl?.clientHeight || 0;
7112          const transformX = arrowX + arrowWidth / 2;
7113          const transformY = arrowY + arrowHeight / 2;
7114          const shiftY = Math.abs(middlewareData2.shift?.y || 0);
7115          const halfAnchorHeight = rects.reference.height / 2;
7116          const sideOffsetValue = typeof sideOffset === "function" ? sideOffset(getOffsetData(state, sideParam, isRtl)) : sideOffset;
7117          const isOverlappingAnchor = shiftY > sideOffsetValue;
7118          const adjacentTransformOrigin = {
7119            top: `$transformX}px calc(100% + $sideOffsetValue}px)`,
7120            bottom: `$transformX}px ${-sideOffsetValue}px`,
7121            left: `calc(100% + $sideOffsetValue}px) $transformY}px`,
7122            right: `${-sideOffsetValue}px $transformY}px`
7123          }[currentRenderedSide];
7124          const overlapTransformOrigin = `$transformX}px $rects.reference.y + halfAnchorHeight - y2}px`;
7125          elements2.floating.style.setProperty("--transform-origin", crossAxisShiftEnabled && currentRenderedAxis === "y" && isOverlappingAnchor ? overlapTransformOrigin : adjacentTransformOrigin);
7126          return {};
7127        }
7128      }, hide4, adaptiveOrigin2);
7129      useIsoLayoutEffect(() => {
7130        if (!mounted && floatingRootContext) {
7131          floatingRootContext.update({
7132            referenceElement: null,
7133            floatingElement: null,
7134            domReferenceElement: null,
7135            positionReference: null
7136          });
7137        }
7138      }, [mounted, floatingRootContext]);
7139      const autoUpdateOptions = React29.useMemo(() => ({
7140        elementResize: !disableAnchorTracking && typeof ResizeObserver !== "undefined",
7141        layoutShift: !disableAnchorTracking && typeof IntersectionObserver !== "undefined"
7142      }), [disableAnchorTracking]);
7143      const {
7144        refs,
7145        elements,
7146        x,
7147        y,
7148        middlewareData,
7149        update: update2,
7150        placement: renderedPlacement,
7151        context,
7152        isPositioned,
7153        floatingStyles: originalFloatingStyles
7154      } = useFloatingHook({
7155        rootContext: floatingRootContext,
7156        open: keepMounted ? mounted : void 0,
7157        placement,
7158        middleware,
7159        strategy: positionMethod,
7160        whileElementsMounted: keepMounted ? void 0 : (...args) => autoUpdate(...args, autoUpdateOptions),
7161        nodeId,
7162        externalTree
7163      });
7164      const {
7165        sideX,
7166        sideY
7167      } = middlewareData.adaptiveOrigin || DEFAULT_SIDES;
7168      const resolvedPosition = isPositioned ? positionMethod : "fixed";
7169      const floatingStyles = React29.useMemo(() => {
7170        let base;
7171        if (!isPositioned) {
7172          base = {
7173            position: resolvedPosition,
7174            top: 0,
7175            left: 0
7176          };
7177        } else if (adaptiveOrigin2) {
7178          base = {
7179            position: resolvedPosition,
7180            [sideX]: x,
7181            [sideY]: y
7182          };
7183        } else {
7184          base = {
7185            ...originalFloatingStyles,
7186            position: resolvedPosition
7187          };
7188        }
7189        base[AVAILABLE_WIDTH_VAR] = "100vw";
7190        base[AVAILABLE_HEIGHT_VAR] = "100vh";
7191        if (!isPositioned) {
7192          base.opacity = 0;
7193        }
7194        return base;
7195      }, [adaptiveOrigin2, resolvedPosition, sideX, x, sideY, y, originalFloatingStyles, isPositioned]);
7196      const registeredPositionReferenceRef = React29.useRef(null);
7197      useIsoLayoutEffect(() => {
7198        if (!mounted) {
7199          return;
7200        }
7201        const anchorValue = anchorValueRef.current;
7202        const resolvedAnchor = typeof anchorValue === "function" ? anchorValue() : anchorValue;
7203        const unwrappedElement = (isRef(resolvedAnchor) ? resolvedAnchor.current : resolvedAnchor) || null;
7204        const finalAnchor = unwrappedElement || null;
7205        if (finalAnchor !== registeredPositionReferenceRef.current) {
7206          refs.setPositionReference(finalAnchor);
7207          registeredPositionReferenceRef.current = finalAnchor;
7208        }
7209      }, [mounted, refs, anchorDep, anchorValueRef]);
7210      React29.useEffect(() => {
7211        if (!mounted) {
7212          return;
7213        }
7214        const anchorValue = anchorValueRef.current;
7215        if (typeof anchorValue === "function") {
7216          return;
7217        }
7218        if (isRef(anchorValue) && anchorValue.current !== registeredPositionReferenceRef.current) {
7219          refs.setPositionReference(anchorValue.current);
7220          registeredPositionReferenceRef.current = anchorValue.current;
7221        }
7222      }, [mounted, refs, anchorDep, anchorValueRef]);
7223      React29.useEffect(() => {
7224        if (keepMounted && mounted && elements.reference && elements.floating) {
7225          return autoUpdate(elements.reference, elements.floating, update2, autoUpdateOptions);
7226        }
7227        return void 0;
7228      }, [keepMounted, mounted, elements, update2, autoUpdateOptions]);
7229      const renderedSide = getSide(renderedPlacement);
7230      const logicalRenderedSide = getLogicalSide(sideParam, renderedSide, isRtl);
7231      const renderedAlign = getAlignment(renderedPlacement) || "center";
7232      const anchorHidden = Boolean(middlewareData.hide?.referenceHidden);
7233      useIsoLayoutEffect(() => {
7234        if (lazyFlip && mounted && isPositioned && renderedSide !== side) {
7235          setMountSide(renderedSide);
7236        }
7237      }, [lazyFlip, mounted, isPositioned, renderedSide, side]);
7238      const arrowStyles = React29.useMemo(() => ({
7239        position: "absolute",
7240        top: middlewareData.arrow?.y,
7241        left: middlewareData.arrow?.x
7242      }), [middlewareData.arrow]);
7243      const arrowUncentered = middlewareData.arrow?.centerOffset !== 0;
7244      return React29.useMemo(() => ({
7245        positionerStyles: floatingStyles,
7246        arrowStyles,
7247        arrowRef,
7248        arrowUncentered,
7249        side: logicalRenderedSide,
7250        align: renderedAlign,
7251        physicalSide: renderedSide,
7252        anchorHidden,
7253        refs,
7254        context,
7255        isPositioned,
7256        update: update2
7257      }), [floatingStyles, arrowStyles, arrowRef, arrowUncentered, logicalRenderedSide, renderedAlign, renderedSide, anchorHidden, refs, context, isPositioned, update2]);
7258    }
7259    function isRef(param) {
7260      return param != null && "current" in param;
7261    }
7262  
7263    // node_modules/@base-ui/react/internals/getDisabledMountTransitionStyles.mjs
7264    function getDisabledMountTransitionStyles(transitionStatus) {
7265      return transitionStatus === "starting" ? DISABLED_TRANSITIONS_STYLE : EMPTY_OBJECT;
7266    }
7267  
7268    // node_modules/@base-ui/react/utils/usePositioner.mjs
7269    function usePositioner(componentProps, state, {
7270      styles,
7271      transitionStatus,
7272      props,
7273      refs,
7274      hidden,
7275      inert = false
7276    }) {
7277      const style = {
7278        ...styles
7279      };
7280      if (inert) {
7281        style.pointerEvents = "none";
7282      }
7283      return useRenderElement("div", componentProps, {
7284        state,
7285        ref: refs,
7286        props: [{
7287          role: "presentation",
7288          hidden,
7289          style
7290        }, getDisabledMountTransitionStyles(transitionStatus), props],
7291        stateAttributesMapping: popupStateMapping
7292      });
7293    }
7294  
7295    // node_modules/@base-ui/react/utils/usePopupViewport.mjs
7296    var React33 = __toESM(require_react(), 1);
7297    var ReactDOM6 = __toESM(require_react_dom(), 1);
7298  
7299    // node_modules/@base-ui/utils/usePreviousValue.mjs
7300    var React30 = __toESM(require_react(), 1);
7301    function usePreviousValue(value) {
7302      const [state, setState] = React30.useState({
7303        current: value,
7304        previous: null
7305      });
7306      if (!Object.is(value, state.current)) {
7307        setState({
7308          current: value,
7309          previous: state.current
7310        });
7311      }
7312      return state.previous;
7313    }
7314  
7315    // node_modules/@base-ui/react/utils/usePopupAutoResize.mjs
7316    var React31 = __toESM(require_react(), 1);
7317  
7318    // node_modules/@base-ui/react/utils/getCssDimensions.mjs
7319    function getCssDimensions2(element) {
7320      const css = getComputedStyle2(element);
7321      let width = parseFloat(css.width) || 0;
7322      let height = parseFloat(css.height) || 0;
7323      const hasOffset = isHTMLElement(element);
7324      const offsetWidth = hasOffset ? element.offsetWidth : width;
7325      const offsetHeight = hasOffset ? element.offsetHeight : height;
7326      const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
7327      if (shouldFallback) {
7328        width = offsetWidth;
7329        height = offsetHeight;
7330      }
7331      return {
7332        width,
7333        height
7334      };
7335    }
7336  
7337    // node_modules/@base-ui/react/utils/usePopupAutoResize.mjs
7338    function usePopupAutoResize(parameters) {
7339      const {
7340        popupElement,
7341        positionerElement,
7342        content,
7343        mounted,
7344        onMeasureLayout: onMeasureLayoutParam,
7345        onMeasureLayoutComplete: onMeasureLayoutCompleteParam,
7346        side,
7347        direction
7348      } = parameters;
7349      const runOnceAnimationsFinish = useAnimationsFinished(popupElement, true);
7350      const animationFrame = useAnimationFrame();
7351      const committedDimensionsRef = React31.useRef(null);
7352      const isInitialRenderRef = React31.useRef(true);
7353      const restoreAnchoringStylesRef = React31.useRef(NOOP);
7354      const onMeasureLayout = useStableCallback(onMeasureLayoutParam);
7355      const onMeasureLayoutComplete = useStableCallback(onMeasureLayoutCompleteParam);
7356      const anchoringStyles = React31.useMemo(() => getPopupAnchoringStyles(side, direction), [side, direction]);
7357      useIsoLayoutEffect(() => {
7358        if (!mounted) {
7359          restoreAnchoringStylesRef.current = NOOP;
7360          isInitialRenderRef.current = true;
7361          committedDimensionsRef.current = null;
7362          return void 0;
7363        }
7364        if (!popupElement || !positionerElement) {
7365          return void 0;
7366        }
7367        restoreAnchoringStylesRef.current = applyElementStyles(popupElement, anchoringStyles);
7368        setPopupCssSize(popupElement, "auto");
7369        const restorePopupPosition = overrideElementStyle(popupElement, "position", "static");
7370        const restorePopupTransform = overrideElementStyle(popupElement, "transform", "none");
7371        const restorePopupScale = overrideElementStyle(popupElement, "scale", "1");
7372        const restorePositionerAvailableSize = applyElementStyles(positionerElement, {
7373          "--available-width": "max-content",
7374          "--available-height": "max-content"
7375        });
7376        function restoreMeasurementOverrides() {
7377          restorePopupPosition();
7378          restorePopupTransform();
7379          restorePositionerAvailableSize();
7380        }
7381        function restoreMeasurementOverridesIncludingScale() {
7382          restoreMeasurementOverrides();
7383          restorePopupScale();
7384        }
7385        onMeasureLayout?.();
7386        if (isInitialRenderRef.current || committedDimensionsRef.current === null) {
7387          setPositionerCssSize(positionerElement, "max-content");
7388          const dimensions = getCssDimensions2(popupElement);
7389          committedDimensionsRef.current = dimensions;
7390          setPositionerCssSize(positionerElement, dimensions);
7391          restoreMeasurementOverridesIncludingScale();
7392          onMeasureLayoutComplete?.(null, dimensions);
7393          isInitialRenderRef.current = false;
7394          return () => {
7395            restoreAnchoringStylesRef.current();
7396            restoreAnchoringStylesRef.current = NOOP;
7397          };
7398        }
7399        setPositionerCssSize(positionerElement, "max-content");
7400        const previousDimensions = committedDimensionsRef.current;
7401        const newDimensions = getCssDimensions2(popupElement);
7402        committedDimensionsRef.current = newDimensions;
7403        setPopupCssSize(popupElement, previousDimensions);
7404        restoreMeasurementOverridesIncludingScale();
7405        onMeasureLayoutComplete?.(previousDimensions, newDimensions);
7406        setPositionerCssSize(positionerElement, newDimensions);
7407        const abortController = new AbortController();
7408        animationFrame.request(() => {
7409          setPopupCssSize(popupElement, newDimensions);
7410          runOnceAnimationsFinish(() => {
7411            popupElement.style.setProperty("--popup-width", "auto");
7412            popupElement.style.setProperty("--popup-height", "auto");
7413          }, abortController.signal);
7414        });
7415        return () => {
7416          abortController.abort();
7417          animationFrame.cancel();
7418          restoreAnchoringStylesRef.current();
7419          restoreAnchoringStylesRef.current = NOOP;
7420        };
7421      }, [content, popupElement, positionerElement, runOnceAnimationsFinish, animationFrame, mounted, onMeasureLayout, onMeasureLayoutComplete, anchoringStyles]);
7422    }
7423    function getPopupAnchoringStyles(side, direction) {
7424      const isPhysicalTop = side === "top";
7425      const isPhysicalLeft = side === "left" || side === (direction === "rtl" ? "inline-end" : "inline-start");
7426      if (!isPhysicalTop && !isPhysicalLeft) {
7427        return EMPTY_OBJECT;
7428      }
7429      return {
7430        position: "absolute",
7431        [isPhysicalTop ? "bottom" : "top"]: "0",
7432        [isPhysicalLeft ? "right" : "left"]: "0"
7433      };
7434    }
7435    function overrideElementStyle(element, property, value) {
7436      const originalValue = element.style.getPropertyValue(property);
7437      element.style.setProperty(property, value);
7438      return () => {
7439        element.style.setProperty(property, originalValue);
7440      };
7441    }
7442    function applyElementStyles(element, styles) {
7443      const restorers = [];
7444      for (const [key, value] of Object.entries(styles)) {
7445        restorers.push(overrideElementStyle(element, key, value));
7446      }
7447      return restorers.length ? () => {
7448        restorers.forEach((restore) => restore());
7449      } : NOOP;
7450    }
7451    function setPopupCssSize(popupElement, size4) {
7452      const width = size4 === "auto" ? "auto" : `$size4.width}px`;
7453      const height = size4 === "auto" ? "auto" : `$size4.height}px`;
7454      popupElement.style.setProperty("--popup-width", width);
7455      popupElement.style.setProperty("--popup-height", height);
7456    }
7457    function setPositionerCssSize(positionerElement, size4) {
7458      const width = size4 === "max-content" ? "max-content" : `$size4.width}px`;
7459      const height = size4 === "max-content" ? "max-content" : `$size4.height}px`;
7460      positionerElement.style.setProperty("--positioner-width", width);
7461      positionerElement.style.setProperty("--positioner-height", height);
7462    }
7463  
7464    // node_modules/@base-ui/react/direction-provider/DirectionProvider.mjs
7465    var React32 = __toESM(require_react(), 1);
7466    var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
7467    var DirectionProvider = function DirectionProvider2(props) {
7468      const {
7469        direction = "ltr"
7470      } = props;
7471      const contextValue = React32.useMemo(() => ({
7472        direction
7473      }), [direction]);
7474      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(DirectionContext.Provider, {
7475        value: contextValue,
7476        children: props.children
7477      });
7478    };
7479    if (true) DirectionProvider.displayName = "DirectionProvider";
7480  
7481    // node_modules/@base-ui/react/utils/adaptiveOriginMiddleware.mjs
7482    var adaptiveOrigin = {
7483      name: "adaptiveOrigin",
7484      async fn(state) {
7485        const {
7486          x: rawX,
7487          y: rawY,
7488          rects: {
7489            floating: floatRect
7490          },
7491          elements: {
7492            floating
7493          },
7494          platform: platform3,
7495          strategy,
7496          placement
7497        } = state;
7498        const win = getWindow(floating);
7499        const styles = win.getComputedStyle(floating);
7500        const hasTransition = styles.transitionDuration !== "0s" && styles.transitionDuration !== "";
7501        if (!hasTransition) {
7502          return {
7503            x: rawX,
7504            y: rawY,
7505            data: DEFAULT_SIDES
7506          };
7507        }
7508        const offsetParent = await platform3.getOffsetParent?.(floating);
7509        let offsetDimensions = {
7510          width: 0,
7511          height: 0
7512        };
7513        if (strategy === "fixed" && win?.visualViewport) {
7514          offsetDimensions = {
7515            width: win.visualViewport.width,
7516            height: win.visualViewport.height
7517          };
7518        } else if (offsetParent === win) {
7519          const doc = ownerDocument(floating);
7520          offsetDimensions = {
7521            width: doc.documentElement.clientWidth,
7522            height: doc.documentElement.clientHeight
7523          };
7524        } else if (await platform3.isElement?.(offsetParent)) {
7525          offsetDimensions = await platform3.getDimensions(offsetParent);
7526        }
7527        const currentSide = getSide(placement);
7528        let x = rawX;
7529        let y = rawY;
7530        if (currentSide === "left") {
7531          x = offsetDimensions.width - (rawX + floatRect.width);
7532        }
7533        if (currentSide === "top") {
7534          y = offsetDimensions.height - (rawY + floatRect.height);
7535        }
7536        const sideX = currentSide === "left" ? "right" : DEFAULT_SIDES.sideX;
7537        const sideY = currentSide === "top" ? "bottom" : DEFAULT_SIDES.sideY;
7538        return {
7539          x,
7540          y,
7541          data: {
7542            sideX,
7543            sideY
7544          }
7545        };
7546      }
7547    };
7548  
7549    // node_modules/@base-ui/react/utils/usePopupViewport.mjs
7550    var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
7551    var popupViewportStateMapping = {
7552      activationDirection: (value) => value ? {
7553        "data-activation-direction": value
7554      } : null
7555    };
7556    function usePopupViewport(parameters) {
7557      const {
7558        store: store2,
7559        side,
7560        children
7561      } = parameters;
7562      const direction = useDirection();
7563      const activeTrigger = store2.useState("activeTriggerElement");
7564      const activeTriggerId = store2.useState("activeTriggerId");
7565      const open = store2.useState("open");
7566      const payload = store2.useState("payload");
7567      const mounted = store2.useState("mounted");
7568      const popupElement = store2.useState("popupElement");
7569      const positionerElement = store2.useState("positionerElement");
7570      const previousActiveTrigger = usePreviousValue(open ? activeTrigger : null);
7571      const currentContentKey = usePopupContentKey(activeTriggerId, payload);
7572      const capturedNodeRef = React33.useRef(null);
7573      const [previousContentNode, setPreviousContentNode] = React33.useState(null);
7574      const [newTriggerOffset, setNewTriggerOffset] = React33.useState(null);
7575      const currentContainerRef = React33.useRef(null);
7576      const previousContainerRef = React33.useRef(null);
7577      const onAnimationsFinished = useAnimationsFinished(currentContainerRef, true);
7578      const cleanupFrame = useAnimationFrame();
7579      const cleanupControllerRef = React33.useRef(null);
7580      const [previousContentDimensions, setPreviousContentDimensions] = React33.useState(null);
7581      const [showStartingStyleAttribute, setShowStartingStyleAttribute] = React33.useState(false);
7582      useIsoLayoutEffect(() => {
7583        store2.set("adaptiveOrigin", adaptiveOrigin);
7584        return () => {
7585          store2.set("adaptiveOrigin", void 0);
7586        };
7587      }, [store2]);
7588      const handleMeasureLayout = useStableCallback(() => {
7589        currentContainerRef.current?.style.setProperty("animation", "none");
7590        currentContainerRef.current?.style.setProperty("transition", "none");
7591        previousContainerRef.current?.style.setProperty("display", "none");
7592      });
7593      const handleMeasureLayoutComplete = useStableCallback((previousDimensions) => {
7594        currentContainerRef.current?.style.removeProperty("animation");
7595        currentContainerRef.current?.style.removeProperty("transition");
7596        previousContainerRef.current?.style.removeProperty("display");
7597        if (previousDimensions) {
7598          setPreviousContentDimensions(previousDimensions);
7599        }
7600      });
7601      const armViewportCleanup = useStableCallback(() => {
7602        cleanupControllerRef.current?.abort();
7603        const controller = new AbortController();
7604        cleanupControllerRef.current = controller;
7605        onAnimationsFinished(() => {
7606          setPreviousContentNode(null);
7607          setPreviousContentDimensions(null);
7608          capturedNodeRef.current = null;
7609        }, controller.signal);
7610      });
7611      const lastHandledTriggerRef = React33.useRef(null);
7612      useIsoLayoutEffect(() => {
7613        if (!open || !mounted) {
7614          lastHandledTriggerRef.current = null;
7615        }
7616      }, [open, mounted]);
7617      useIsoLayoutEffect(() => {
7618        if (activeTrigger && previousActiveTrigger && activeTrigger !== previousActiveTrigger && lastHandledTriggerRef.current !== activeTrigger && capturedNodeRef.current) {
7619          setPreviousContentNode(capturedNodeRef.current);
7620          setShowStartingStyleAttribute(true);
7621          const offset4 = calculateRelativePosition(previousActiveTrigger, activeTrigger);
7622          setNewTriggerOffset(offset4);
7623          lastHandledTriggerRef.current = activeTrigger;
7624        }
7625      }, [activeTrigger, previousActiveTrigger]);
7626      useIsoLayoutEffect(() => {
7627        if (previousContentNode == null) {
7628          return;
7629        }
7630        cleanupControllerRef.current?.abort();
7631        setShowStartingStyleAttribute(true);
7632        cleanupFrame.request(() => {
7633          ReactDOM6.flushSync(() => {
7634            setShowStartingStyleAttribute(false);
7635          });
7636          armViewportCleanup();
7637        });
7638      }, [currentContentKey, previousContentNode, armViewportCleanup, cleanupFrame]);
7639      useIsoLayoutEffect(() => {
7640        const source = currentContainerRef.current;
7641        if (!source) {
7642          return;
7643        }
7644        const wrapper = ownerDocument(source).createElement("div");
7645        for (const child of Array.from(source.childNodes)) {
7646          wrapper.appendChild(child.cloneNode(true));
7647        }
7648        capturedNodeRef.current = wrapper;
7649      });
7650      const isTransitioning = previousContentNode != null;
7651      let childrenToRender;
7652      if (!isTransitioning) {
7653        childrenToRender = /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", {
7654          "data-current": true,
7655          ref: currentContainerRef,
7656          children
7657        }, currentContentKey);
7658      } else {
7659        childrenToRender = /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(React33.Fragment, {
7660          children: [/* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", {
7661            "data-previous": true,
7662            inert: inertValue(true),
7663            ref: previousContainerRef,
7664            style: {
7665              ...previousContentDimensions ? {
7666                "--popup-width": `$previousContentDimensions.width}px`,
7667                "--popup-height": `$previousContentDimensions.height}px`
7668              } : null,
7669              position: "absolute"
7670            },
7671            "data-ending-style": showStartingStyleAttribute ? void 0 : ""
7672          }, "previous"), /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", {
7673            "data-current": true,
7674            ref: currentContainerRef,
7675            "data-starting-style": showStartingStyleAttribute ? "" : void 0,
7676            children
7677          }, currentContentKey)]
7678        });
7679      }
7680      useIsoLayoutEffect(() => {
7681        const container = previousContainerRef.current;
7682        if (!container || !previousContentNode) {
7683          return;
7684        }
7685        container.replaceChildren(...Array.from(previousContentNode.childNodes));
7686      }, [previousContentNode]);
7687      usePopupAutoResize({
7688        popupElement,
7689        positionerElement,
7690        mounted,
7691        content: payload,
7692        onMeasureLayout: handleMeasureLayout,
7693        onMeasureLayoutComplete: handleMeasureLayoutComplete,
7694        side,
7695        direction
7696      });
7697      const state = {
7698        activationDirection: getActivationDirection(newTriggerOffset),
7699        transitioning: isTransitioning
7700      };
7701      return {
7702        children: childrenToRender,
7703        state
7704      };
7705    }
7706    function getActivationDirection(offset4) {
7707      if (!offset4) {
7708        return void 0;
7709      }
7710      return `$getValueWithTolerance(offset4.horizontal, 5, "right", "left")} $getValueWithTolerance(offset4.vertical, 5, "down", "up")}`;
7711    }
7712    function getValueWithTolerance(value, tolerance, positiveLabel, negativeLabel) {
7713      if (value > tolerance) {
7714        return positiveLabel;
7715      }
7716      if (value < -tolerance) {
7717        return negativeLabel;
7718      }
7719      return "";
7720    }
7721    function calculateRelativePosition(from, to) {
7722      const fromRect = from.getBoundingClientRect();
7723      const toRect = to.getBoundingClientRect();
7724      const fromCenter = {
7725        x: fromRect.left + fromRect.width / 2,
7726        y: fromRect.top + fromRect.height / 2
7727      };
7728      const toCenter = {
7729        x: toRect.left + toRect.width / 2,
7730        y: toRect.top + toRect.height / 2
7731      };
7732      return {
7733        horizontal: toCenter.x - fromCenter.x,
7734        vertical: toCenter.y - fromCenter.y
7735      };
7736    }
7737    function usePopupContentKey(activeTriggerId, payload) {
7738      const [contentKey, setContentKey] = React33.useState(0);
7739      const previousActiveTriggerIdRef = React33.useRef(activeTriggerId);
7740      const previousPayloadRef = React33.useRef(payload);
7741      const pendingPayloadUpdateRef = React33.useRef(false);
7742      useIsoLayoutEffect(() => {
7743        const previousActiveTriggerId = previousActiveTriggerIdRef.current;
7744        const previousPayload = previousPayloadRef.current;
7745        const triggerIdChanged = activeTriggerId !== previousActiveTriggerId;
7746        const payloadChanged = payload !== previousPayload;
7747        if (triggerIdChanged) {
7748          setContentKey((value) => value + 1);
7749          pendingPayloadUpdateRef.current = !payloadChanged;
7750        } else if (pendingPayloadUpdateRef.current && payloadChanged) {
7751          setContentKey((value) => value + 1);
7752          pendingPayloadUpdateRef.current = false;
7753        }
7754        previousActiveTriggerIdRef.current = activeTriggerId;
7755        previousPayloadRef.current = payload;
7756      }, [activeTriggerId, payload]);
7757      return `$activeTriggerId ?? "current"}-$contentKey}`;
7758    }
7759  
7760    // node_modules/@base-ui/react/utils/FloatingPortalLite.mjs
7761    var React34 = __toESM(require_react(), 1);
7762    var ReactDOM7 = __toESM(require_react_dom(), 1);
7763    var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
7764    var FloatingPortalLite = /* @__PURE__ */ React34.forwardRef(function FloatingPortalLite2(componentProps, forwardedRef) {
7765      const {
7766        children,
7767        container,
7768        className,
7769        render,
7770        style,
7771        ...elementProps
7772      } = componentProps;
7773      const {
7774        node: portalNode,
7775        subtree: portalSubtree
7776      } = useFloatingPortalNode({
7777        container,
7778        ref: forwardedRef,
7779        componentProps,
7780        elementProps
7781      });
7782      if (!portalSubtree && !portalNode) {
7783        return null;
7784      }
7785      return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(React34.Fragment, {
7786        children: [portalSubtree, portalNode && /* @__PURE__ */ ReactDOM7.createPortal(children, portalNode)]
7787      });
7788    });
7789    if (true) FloatingPortalLite.displayName = "FloatingPortalLite";
7790  
7791    // node_modules/@base-ui/react/tooltip/index.parts.mjs
7792    var index_parts_exports = {};
7793    __export(index_parts_exports, {
7794      Arrow: () => TooltipArrow,
7795      Handle: () => TooltipHandle,
7796      Popup: () => TooltipPopup,
7797      Portal: () => TooltipPortal,
7798      Positioner: () => TooltipPositioner,
7799      Provider: () => TooltipProvider,
7800      Root: () => TooltipRoot,
7801      Trigger: () => TooltipTrigger,
7802      Viewport: () => TooltipViewport,
7803      createHandle: () => createTooltipHandle
7804    });
7805  
7806    // node_modules/@base-ui/react/tooltip/root/TooltipRoot.mjs
7807    var React37 = __toESM(require_react(), 1);
7808  
7809    // node_modules/@base-ui/react/tooltip/root/TooltipRootContext.mjs
7810    var React35 = __toESM(require_react(), 1);
7811    var TooltipRootContext = /* @__PURE__ */ React35.createContext(void 0);
7812    if (true) TooltipRootContext.displayName = "TooltipRootContext";
7813    function useTooltipRootContext(optional) {
7814      const context = React35.useContext(TooltipRootContext);
7815      if (context === void 0 && !optional) {
7816        throw new Error(true ? "Base UI: TooltipRootContext is missing. Tooltip parts must be placed within <Tooltip.Root>." : formatErrorMessage_default(72));
7817      }
7818      return context;
7819    }
7820  
7821    // node_modules/@base-ui/react/tooltip/store/TooltipStore.mjs
7822    var React36 = __toESM(require_react(), 1);
7823    var selectors2 = {
7824      ...popupStoreSelectors,
7825      disabled: (state) => state.disabled,
7826      instantType: (state) => state.instantType,
7827      isInstantPhase: (state) => state.isInstantPhase,
7828      trackCursorAxis: (state) => state.trackCursorAxis,
7829      disableHoverablePopup: (state) => state.disableHoverablePopup,
7830      lastOpenChangeReason: (state) => state.openChangeReason,
7831      closeOnClick: (state) => state.closeOnClick,
7832      closeDelay: (state) => state.closeDelay,
7833      adaptiveOrigin: (state) => state.adaptiveOrigin
7834    };
7835    var TooltipStore = class extends ReactStore {
7836      constructor(initialState, floatingId, nested) {
7837        const triggerElements = new PopupTriggerMap();
7838        super(createInitialState(initialState, triggerElements, floatingId, nested), createInitialContext(triggerElements), selectors2);
7839      }
7840      setOpen = (nextOpen, eventDetails) => {
7841        applyPopupOpenChange(this, nextOpen, eventDetails, {
7842          extraState: {
7843            openChangeReason: eventDetails.reason
7844          }
7845        });
7846      };
7847      // Used by trigger clicks to clear a delayed hover open without reporting a public open-state change.
7848      cancelPendingOpen(event) {
7849        this.state.floatingRootContext.dispatchOpenChange(false, createChangeEventDetails(reason_parts_exports.triggerPress, event));
7850      }
7851    };
7852    function createNullTooltipStore() {
7853      const triggerElements = new PopupTriggerMap();
7854      const store2 = new NullStore(Object.freeze(createInitialState(void 0, triggerElements)), Object.freeze(createInitialContext(triggerElements)), selectors2);
7855      return Object.assign(store2, {
7856        setOpen: NOOP,
7857        cancelPendingOpen: NOOP
7858      });
7859    }
7860    function createInitialState(initialState, triggerElements, floatingId, nested = false) {
7861      const state = {
7862        ...createInitialPopupStoreState(),
7863        disabled: false,
7864        instantType: void 0,
7865        isInstantPhase: false,
7866        trackCursorAxis: "none",
7867        disableHoverablePopup: false,
7868        openChangeReason: null,
7869        closeOnClick: true,
7870        closeDelay: 0,
7871        adaptiveOrigin: void 0,
7872        ...initialState
7873      };
7874      state.floatingRootContext = createPopupFloatingRootContext(triggerElements, floatingId, nested);
7875      return state;
7876    }
7877    function createInitialContext(triggerElements) {
7878      return {
7879        popupRef: /* @__PURE__ */ React36.createRef(),
7880        onOpenChange: void 0,
7881        onOpenChangeComplete: void 0,
7882        triggerElements
7883      };
7884    }
7885  
7886    // node_modules/@base-ui/react/tooltip/root/TooltipRoot.mjs
7887    var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
7888    var TooltipRoot = fastComponent(function TooltipRoot2(props) {
7889      const {
7890        disabled: disabled2 = false,
7891        defaultOpen = false,
7892        open: openProp,
7893        disableHoverablePopup = false,
7894        trackCursorAxis = "none",
7895        actionsRef,
7896        onOpenChange,
7897        onOpenChangeComplete,
7898        handle,
7899        triggerId: triggerIdProp,
7900        defaultTriggerId: defaultTriggerIdProp = null,
7901        children
7902      } = props;
7903      const store2 = usePopupRootStore((floatingId, nested) => new TooltipStore({
7904        open: defaultOpen,
7905        openProp,
7906        activeTriggerId: defaultTriggerIdProp,
7907        triggerIdProp
7908      }, floatingId, nested));
7909      store2.useControlledProp("openProp", openProp);
7910      store2.useControlledProp("triggerIdProp", triggerIdProp);
7911      store2.useContextCallback("onOpenChange", onOpenChange);
7912      store2.useContextCallback("onOpenChangeComplete", onOpenChangeComplete);
7913      const openState = store2.useState("open");
7914      const open = !disabled2 && openState;
7915      const activeTriggerId = store2.useState("activeTriggerId");
7916      const mounted = store2.useState("mounted");
7917      const payload = store2.useState("payload");
7918      store2.useSyncedValues({
7919        trackCursorAxis,
7920        disableHoverablePopup,
7921        disabled: disabled2
7922      });
7923      useImplicitActiveTrigger(store2, {
7924        closeOnActiveTriggerUnmount: true
7925      });
7926      const {
7927        forceUnmount,
7928        transitionStatus
7929      } = useOpenStateTransitions(open, store2);
7930      const isInstantPhase = store2.useState("isInstantPhase");
7931      const instantType = store2.useState("instantType");
7932      const lastOpenChangeReason = store2.useState("lastOpenChangeReason");
7933      const previousInstantTypeRef = React37.useRef(null);
7934      useIsoLayoutEffect(() => {
7935        if (openState && disabled2) {
7936          store2.setOpen(false, createChangeEventDetails(reason_parts_exports.disabled));
7937        }
7938      }, [openState, disabled2, store2]);
7939      useIsoLayoutEffect(() => {
7940        if (transitionStatus === "ending" && lastOpenChangeReason === reason_parts_exports.none || transitionStatus !== "ending" && isInstantPhase) {
7941          if (instantType !== "delay") {
7942            previousInstantTypeRef.current = instantType;
7943          }
7944          store2.set("instantType", "delay");
7945        } else if (previousInstantTypeRef.current !== null) {
7946          store2.set("instantType", previousInstantTypeRef.current);
7947          previousInstantTypeRef.current = null;
7948        }
7949      }, [transitionStatus, isInstantPhase, lastOpenChangeReason, instantType, store2]);
7950      useIsoLayoutEffect(() => {
7951        if (open) {
7952          if (activeTriggerId == null) {
7953            store2.set("payload", void 0);
7954          }
7955        }
7956      }, [store2, activeTriggerId, open]);
7957      React37.useImperativeHandle(actionsRef, () => ({
7958        unmount: forceUnmount,
7959        close: () => store2.setOpen(false, createChangeEventDetails(reason_parts_exports.imperativeAction))
7960      }), [forceUnmount, store2]);
7961      const shouldRenderInteractions = open || mounted || !disabled2 && trackCursorAxis !== "none";
7962      return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(TooltipRootContext.Provider, {
7963        value: store2,
7964        children: [handle && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(PopupHandleAttachment, {
7965          handle,
7966          store: store2
7967        }), shouldRenderInteractions && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(TooltipInteractions, {
7968          store: store2,
7969          disabled: disabled2,
7970          trackCursorAxis
7971        }), typeof children === "function" ? children({
7972          payload
7973        }) : children]
7974      });
7975    });
7976    if (true) TooltipRoot.displayName = "TooltipRoot";
7977    function TooltipInteractions({
7978      store: store2,
7979      disabled: disabled2,
7980      trackCursorAxis
7981    }) {
7982      const floatingRootContext = store2.useState("floatingRootContext");
7983      const dismiss = useDismiss(floatingRootContext, {
7984        enabled: !disabled2,
7985        referencePress: () => store2.select("closeOnClick")
7986      });
7987      const clientPoint = useClientPoint(floatingRootContext, {
7988        enabled: !disabled2 && trackCursorAxis !== "none",
7989        axis: trackCursorAxis === "none" ? void 0 : trackCursorAxis
7990      });
7991      const triggerProps = React37.useMemo(() => mergeProps(clientPoint.reference, dismiss.reference), [clientPoint.reference, dismiss.reference]);
7992      usePopupInteractionProps(store2, {
7993        activeTriggerProps: triggerProps,
7994        inactiveTriggerProps: triggerProps,
7995        popupProps: dismiss.floating ?? EMPTY_OBJECT
7996      });
7997      return null;
7998    }
7999  
8000    // node_modules/@base-ui/react/tooltip/trigger/TooltipTrigger.mjs
8001    var React39 = __toESM(require_react(), 1);
8002  
8003    // node_modules/@base-ui/react/tooltip/provider/TooltipProviderContext.mjs
8004    var React38 = __toESM(require_react(), 1);
8005    var TooltipProviderContext = /* @__PURE__ */ React38.createContext(void 0);
8006    if (true) TooltipProviderContext.displayName = "TooltipProviderContext";
8007    function useTooltipProviderContext() {
8008      return React38.useContext(TooltipProviderContext);
8009    }
8010  
8011    // node_modules/@base-ui/react/tooltip/utils/constants.mjs
8012    var OPEN_DELAY = 600;
8013  
8014    // node_modules/@base-ui/react/tooltip/trigger/TooltipTrigger.mjs
8015    var TOOLTIP_TRIGGER_IDENTIFIER = "data-base-ui-tooltip-trigger";
8016    function getTargetElement(event) {
8017      if ("composedPath" in event) {
8018        const path = event.composedPath();
8019        for (let i = 0; i < path.length; i += 1) {
8020          const element = path[i];
8021          if (isElement(element)) {
8022            return element;
8023          }
8024        }
8025      }
8026      const target = event.target;
8027      if (isElement(target)) {
8028        return target;
8029      }
8030      return null;
8031    }
8032    function closestEnabledTooltipTrigger(element) {
8033      let current = element;
8034      while (current) {
8035        const trigger = current.closest(`[$TOOLTIP_TRIGGER_IDENTIFIER}]`);
8036        if (trigger) {
8037          return trigger;
8038        }
8039        const root = current.getRootNode();
8040        current = "host" in root && isElement(root.host) ? root.host : null;
8041      }
8042      return null;
8043    }
8044    var TooltipTrigger = fastComponentRef(function TooltipTrigger2(componentProps, forwardedRef) {
8045      const {
8046        render,
8047        className,
8048        style,
8049        handle,
8050        payload,
8051        disabled: disabledProp,
8052        delay,
8053        closeOnClick = true,
8054        closeDelay,
8055        id: idProp,
8056        ...elementProps
8057      } = componentProps;
8058      const rootContext = useTooltipRootContext(true);
8059      const handleStore = usePopupHandleStore(handle);
8060      const store2 = handleStore ?? rootContext;
8061      if (!store2) {
8062        throw new Error(true ? "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle." : formatErrorMessage_default(82));
8063      }
8064      const thisTriggerId = useBaseUiId(idProp);
8065      const isTriggerActive = store2.useState("isTriggerActive", thisTriggerId);
8066      const isOpenedByThisTrigger = store2.useState("isOpenedByTrigger", thisTriggerId);
8067      const floatingRootContext = store2.useState("floatingRootContext");
8068      const triggerElementRef = React39.useRef(null);
8069      const delayWithDefault = delay ?? OPEN_DELAY;
8070      const closeDelayWithDefault = closeDelay ?? 0;
8071      const {
8072        registerTrigger,
8073        isMountedByThisTrigger
8074      } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store2, {
8075        payload,
8076        closeOnClick,
8077        closeDelay: closeDelayWithDefault
8078      });
8079      const providerDelay = useTooltipProviderContext();
8080      const {
8081        delayRef,
8082        isInstantPhase,
8083        hasProvider
8084      } = useDelayGroup(floatingRootContext, {
8085        open: isOpenedByThisTrigger
8086      });
8087      const hoverInteraction = useHoverInteractionSharedState(floatingRootContext);
8088      store2.useSyncedValue("isInstantPhase", isInstantPhase);
8089      const rootDisabled = store2.useState("disabled");
8090      const disabled2 = disabledProp ?? rootDisabled;
8091      const disabledRef = useValueAsRef(disabled2);
8092      const trackCursorAxis = store2.useState("trackCursorAxis");
8093      const disableHoverablePopup = store2.useState("disableHoverablePopup");
8094      const isNestedTriggerHoveredRef = React39.useRef(false);
8095      const nestedTriggerOpenTimeout = useTimeout();
8096      const pointerTypeRef = React39.useRef(void 0);
8097      function getOpenDelay() {
8098        if (!hasProvider) {
8099          return delayWithDefault;
8100        }
8101        return getDelay(delayRef.current, "open") === 0 ? 0 : delay ?? providerDelay ?? OPEN_DELAY;
8102      }
8103      function isEnabledNestedTriggerTarget(target) {
8104        const triggerEl = triggerElementRef.current;
8105        if (!triggerEl || !target) {
8106          return false;
8107        }
8108        const nearestTrigger = closestEnabledTooltipTrigger(target);
8109        return nearestTrigger !== null && nearestTrigger !== triggerEl && contains(triggerEl, nearestTrigger);
8110      }
8111      function detectNestedTriggerHover(target) {
8112        const nestedTriggerHovered = isEnabledNestedTriggerTarget(target);
8113        isNestedTriggerHoveredRef.current = nestedTriggerHovered;
8114        if (nestedTriggerHovered) {
8115          hoverInteraction.openChangeTimeout.clear();
8116          hoverInteraction.restTimeout.clear();
8117          hoverInteraction.restTimeoutPending = false;
8118          nestedTriggerOpenTimeout.clear();
8119        }
8120        return nestedTriggerHovered;
8121      }
8122      const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
8123        enabled: !disabled2,
8124        mouseOnly: true,
8125        move: false,
8126        handleClose: !disableHoverablePopup && trackCursorAxis !== "both" ? safePolygon() : null,
8127        restMs: getOpenDelay,
8128        delay() {
8129          if (closeDelay == null && hasProvider) {
8130            return {
8131              close: getDelay(delayRef.current, "close")
8132            };
8133          }
8134          return {
8135            close: closeDelayWithDefault
8136          };
8137        },
8138        triggerElementRef,
8139        isActiveTrigger: isTriggerActive,
8140        isClosing: () => store2.select("transitionStatus") === "ending",
8141        shouldOpen() {
8142          return !isNestedTriggerHoveredRef.current;
8143        }
8144      });
8145      const focusProps = useFocus(floatingRootContext, {
8146        enabled: !disabled2
8147      }).reference;
8148      const handleNestedTriggerHover = (event) => {
8149        const wasNestedTriggerHovered = isNestedTriggerHoveredRef.current;
8150        const target = getTargetElement(event);
8151        const nestedTriggerHovered = detectNestedTriggerHover(target);
8152        const triggerEl = triggerElementRef.current;
8153        const targetInsideTrigger = triggerEl && target && contains(triggerEl, target);
8154        if (nestedTriggerHovered && store2.select("open") && store2.select("lastOpenChangeReason") === reason_parts_exports.triggerHover) {
8155          store2.setOpen(false, createChangeEventDetails(reason_parts_exports.triggerHover, event));
8156          return;
8157        }
8158        if (wasNestedTriggerHovered && !nestedTriggerHovered && targetInsideTrigger && !disabledRef.current && !store2.select("open") && triggerEl && // Match the hover hook's non-strict mouse fallback for mouse-only event sequences.
8159        isMouseLikePointerType(pointerTypeRef.current)) {
8160          const open = () => {
8161            if (!isNestedTriggerHoveredRef.current && !disabledRef.current && !store2.select("open")) {
8162              store2.setOpen(true, createChangeEventDetails(reason_parts_exports.triggerHover, event, triggerEl));
8163            }
8164          };
8165          const openDelay = getOpenDelay();
8166          if (openDelay === 0) {
8167            nestedTriggerOpenTimeout.clear();
8168            open();
8169          } else {
8170            nestedTriggerOpenTimeout.start(openDelay, open);
8171          }
8172        }
8173      };
8174      const rootTriggerProps = store2.useState("triggerProps", isMountedByThisTrigger);
8175      const shouldApplyRootTriggerProps = isMountedByThisTrigger || trackCursorAxis !== "none";
8176      const state = {
8177        open: isOpenedByThisTrigger
8178      };
8179      const element = useRenderElement("button", componentProps, {
8180        state,
8181        ref: [forwardedRef, registerTrigger, triggerElementRef],
8182        props: [hoverProps, focusProps, shouldApplyRootTriggerProps ? rootTriggerProps : void 0, {
8183          onMouseOver(event) {
8184            handleNestedTriggerHover(event.nativeEvent);
8185          },
8186          onFocus(event) {
8187            if (isEnabledNestedTriggerTarget(getTargetElement(event.nativeEvent))) {
8188              event.preventBaseUIHandler();
8189            }
8190          },
8191          onMouseLeave() {
8192            isNestedTriggerHoveredRef.current = false;
8193            nestedTriggerOpenTimeout.clear();
8194            pointerTypeRef.current = void 0;
8195          },
8196          onPointerEnter(event) {
8197            pointerTypeRef.current = event.pointerType;
8198          },
8199          onPointerDown(event) {
8200            pointerTypeRef.current = event.pointerType;
8201            store2.set("closeOnClick", closeOnClick);
8202            if (closeOnClick && !store2.select("open")) {
8203              store2.cancelPendingOpen(event.nativeEvent);
8204            }
8205          },
8206          onClick(event) {
8207            if (closeOnClick && !store2.select("open")) {
8208              store2.cancelPendingOpen(event.nativeEvent);
8209            }
8210          },
8211          id: thisTriggerId,
8212          "data-trigger-disabled": disabled2 ? "" : void 0,
8213          [TOOLTIP_TRIGGER_IDENTIFIER]: disabled2 ? void 0 : ""
8214        }, elementProps],
8215        stateAttributesMapping: triggerOpenStateMapping
8216      });
8217      return element;
8218    });
8219    if (true) TooltipTrigger.displayName = "TooltipTrigger";
8220  
8221    // node_modules/@base-ui/react/tooltip/portal/TooltipPortal.mjs
8222    var React41 = __toESM(require_react(), 1);
8223  
8224    // node_modules/@base-ui/react/tooltip/portal/TooltipPortalContext.mjs
8225    var React40 = __toESM(require_react(), 1);
8226    var TooltipPortalContext = /* @__PURE__ */ React40.createContext(void 0);
8227    if (true) TooltipPortalContext.displayName = "TooltipPortalContext";
8228    function useTooltipPortalContext() {
8229      const value = React40.useContext(TooltipPortalContext);
8230      if (value === void 0) {
8231        throw new Error(true ? "Base UI: <Tooltip.Portal> is missing." : formatErrorMessage_default(70));
8232      }
8233      return value;
8234    }
8235  
8236    // node_modules/@base-ui/react/tooltip/portal/TooltipPortal.mjs
8237    var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
8238    var TooltipPortal = /* @__PURE__ */ React41.forwardRef(function TooltipPortal2(props, forwardedRef) {
8239      const {
8240        keepMounted = false,
8241        ...portalProps
8242      } = props;
8243      const store2 = useTooltipRootContext();
8244      const mounted = store2.useState("mounted");
8245      const shouldRender = mounted || keepMounted;
8246      if (!shouldRender) {
8247        return null;
8248      }
8249      return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(TooltipPortalContext.Provider, {
8250        value: keepMounted,
8251        children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(FloatingPortalLite, {
8252          ref: forwardedRef,
8253          ...portalProps
8254        })
8255      });
8256    });
8257    if (true) TooltipPortal.displayName = "TooltipPortal";
8258  
8259    // node_modules/@base-ui/react/tooltip/positioner/TooltipPositioner.mjs
8260    var React43 = __toESM(require_react(), 1);
8261  
8262    // node_modules/@base-ui/react/tooltip/positioner/TooltipPositionerContext.mjs
8263    var React42 = __toESM(require_react(), 1);
8264    var TooltipPositionerContext = /* @__PURE__ */ React42.createContext(void 0);
8265    if (true) TooltipPositionerContext.displayName = "TooltipPositionerContext";
8266    function useTooltipPositionerContext() {
8267      const context = React42.useContext(TooltipPositionerContext);
8268      if (context === void 0) {
8269        throw new Error(true ? "Base UI: TooltipPositionerContext is missing. TooltipPositioner parts must be placed within <Tooltip.Positioner>." : formatErrorMessage_default(71));
8270      }
8271      return context;
8272    }
8273  
8274    // node_modules/@base-ui/react/tooltip/positioner/TooltipPositioner.mjs
8275    var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
8276    var TooltipPositioner = /* @__PURE__ */ React43.forwardRef(function TooltipPositioner2(componentProps, forwardedRef) {
8277      const {
8278        render,
8279        className,
8280        anchor,
8281        positionMethod = "absolute",
8282        side = "top",
8283        align = "center",
8284        sideOffset = 0,
8285        alignOffset = 0,
8286        collisionBoundary = "clipping-ancestors",
8287        collisionPadding = 5,
8288        arrowPadding = 5,
8289        sticky = false,
8290        disableAnchorTracking = false,
8291        collisionAvoidance = POPUP_COLLISION_AVOIDANCE,
8292        style,
8293        ...elementProps
8294      } = componentProps;
8295      const store2 = useTooltipRootContext();
8296      const keepMounted = useTooltipPortalContext();
8297      const open = store2.useState("open");
8298      const mounted = store2.useState("mounted");
8299      const trackCursorAxis = store2.useState("trackCursorAxis");
8300      const disableHoverablePopup = store2.useState("disableHoverablePopup");
8301      const floatingRootContext = store2.useState("floatingRootContext");
8302      const instantType = store2.useState("instantType");
8303      const transitionStatus = store2.useState("transitionStatus");
8304      const adaptiveOrigin2 = store2.useState("adaptiveOrigin");
8305      const positioning = useAnchorPositioning({
8306        anchor,
8307        positionMethod,
8308        floatingRootContext,
8309        mounted,
8310        side,
8311        sideOffset,
8312        align,
8313        alignOffset,
8314        collisionBoundary,
8315        collisionPadding,
8316        sticky,
8317        arrowPadding,
8318        disableAnchorTracking,
8319        keepMounted,
8320        collisionAvoidance,
8321        adaptiveOrigin: adaptiveOrigin2
8322      });
8323      const state = React43.useMemo(() => ({
8324        open,
8325        side: positioning.side,
8326        align: positioning.align,
8327        anchorHidden: positioning.anchorHidden,
8328        instant: trackCursorAxis !== "none" ? "tracking-cursor" : instantType
8329      }), [open, positioning.side, positioning.align, positioning.anchorHidden, trackCursorAxis, instantType]);
8330      const element = usePositioner(componentProps, state, {
8331        styles: positioning.positionerStyles,
8332        transitionStatus,
8333        props: elementProps,
8334        refs: [forwardedRef, store2.useStateSetter("positionerElement")],
8335        hidden: !mounted,
8336        inert: !open || trackCursorAxis === "both" || disableHoverablePopup
8337      });
8338      return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(TooltipPositionerContext.Provider, {
8339        value: positioning,
8340        children: element
8341      });
8342    });
8343    if (true) TooltipPositioner.displayName = "TooltipPositioner";
8344  
8345    // node_modules/@base-ui/react/tooltip/popup/TooltipPopup.mjs
8346    var React44 = __toESM(require_react(), 1);
8347    var TooltipPopup = /* @__PURE__ */ React44.forwardRef(function TooltipPopup2(componentProps, forwardedRef) {
8348      const {
8349        render,
8350        className,
8351        style,
8352        ...elementProps
8353      } = componentProps;
8354      const store2 = useTooltipRootContext();
8355      const {
8356        side,
8357        align
8358      } = useTooltipPositionerContext();
8359      const open = store2.useState("open");
8360      const instantType = store2.useState("instantType");
8361      const transitionStatus = store2.useState("transitionStatus");
8362      const popupProps = store2.useState("popupProps");
8363      const floatingContext = store2.useState("floatingRootContext");
8364      const disabled2 = store2.useState("disabled");
8365      const closeDelay = store2.useState("closeDelay");
8366      useOpenChangeComplete({
8367        open,
8368        ref: store2.context.popupRef,
8369        onComplete() {
8370          if (open) {
8371            store2.context.onOpenChangeComplete?.(true);
8372          }
8373        }
8374      });
8375      useHoverFloatingInteraction(floatingContext, {
8376        enabled: !disabled2,
8377        closeDelay
8378      });
8379      const setPopupElement = store2.useStateSetter("popupElement");
8380      const state = {
8381        open,
8382        side,
8383        align,
8384        instant: instantType,
8385        transitionStatus
8386      };
8387      const element = useRenderElement("div", componentProps, {
8388        state,
8389        ref: [forwardedRef, store2.context.popupRef, setPopupElement],
8390        props: [FOCUSABLE_POPUP_PROPS, popupProps, getDisabledMountTransitionStyles(transitionStatus), elementProps],
8391        stateAttributesMapping: popupTransitionStateMapping
8392      });
8393      return element;
8394    });
8395    if (true) TooltipPopup.displayName = "TooltipPopup";
8396  
8397    // node_modules/@base-ui/react/tooltip/arrow/TooltipArrow.mjs
8398    var React45 = __toESM(require_react(), 1);
8399    var TooltipArrow = /* @__PURE__ */ React45.forwardRef(function TooltipArrow2(componentProps, forwardedRef) {
8400      const {
8401        render,
8402        className,
8403        style,
8404        ...elementProps
8405      } = componentProps;
8406      const store2 = useTooltipRootContext();
8407      const {
8408        arrowRef,
8409        side,
8410        align,
8411        arrowUncentered,
8412        arrowStyles
8413      } = useTooltipPositionerContext();
8414      const open = store2.useState("open");
8415      const instantType = store2.useState("instantType");
8416      const state = {
8417        open,
8418        side,
8419        align,
8420        uncentered: arrowUncentered,
8421        instant: instantType
8422      };
8423      const element = useRenderElement("div", componentProps, {
8424        state,
8425        ref: [forwardedRef, arrowRef],
8426        props: [{
8427          style: arrowStyles,
8428          "aria-hidden": true
8429        }, elementProps],
8430        stateAttributesMapping: popupStateMapping
8431      });
8432      return element;
8433    });
8434    if (true) TooltipArrow.displayName = "TooltipArrow";
8435  
8436    // node_modules/@base-ui/react/tooltip/provider/TooltipProvider.mjs
8437    var React46 = __toESM(require_react(), 1);
8438    var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
8439    var TooltipProvider = function TooltipProvider2(props) {
8440      const {
8441        delay,
8442        closeDelay,
8443        timeout = 400
8444      } = props;
8445      const delayValue = React46.useMemo(() => ({
8446        open: delay,
8447        close: closeDelay
8448      }), [delay, closeDelay]);
8449      return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(TooltipProviderContext.Provider, {
8450        value: delay,
8451        children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(FloatingDelayGroup, {
8452          delay: delayValue,
8453          timeoutMs: timeout,
8454          children: props.children
8455        })
8456      });
8457    };
8458    if (true) TooltipProvider.displayName = "TooltipProvider";
8459  
8460    // node_modules/@base-ui/react/tooltip/viewport/TooltipViewport.mjs
8461    var React47 = __toESM(require_react(), 1);
8462    var TooltipViewport = /* @__PURE__ */ React47.forwardRef(function TooltipViewport2(componentProps, forwardedRef) {
8463      const {
8464        render,
8465        className,
8466        style,
8467        children,
8468        ...elementProps
8469      } = componentProps;
8470      const store2 = useTooltipRootContext();
8471      const positioner = useTooltipPositionerContext();
8472      const instantType = store2.useState("instantType");
8473      const {
8474        children: childrenToRender,
8475        state: viewportState
8476      } = usePopupViewport({
8477        store: store2,
8478        side: positioner.side,
8479        children
8480      });
8481      const state = {
8482        activationDirection: viewportState.activationDirection,
8483        transitioning: viewportState.transitioning,
8484        instant: instantType
8485      };
8486      return useRenderElement("div", componentProps, {
8487        state,
8488        ref: forwardedRef,
8489        props: [elementProps, {
8490          children: childrenToRender
8491        }],
8492        stateAttributesMapping: popupViewportStateMapping
8493      });
8494    });
8495    if (true) TooltipViewport.displayName = "TooltipViewport";
8496  
8497    // node_modules/@base-ui/react/tooltip/store/TooltipHandle.mjs
8498    var TooltipHandle = class extends BasePopupHandle {
8499      constructor() {
8500        super(createNullTooltipStore(), "Tooltip");
8501      }
8502      /**
8503       * Opens the tooltip and associates it with the trigger with the given id.
8504       *
8505       * This method should only be called in an event handler or an effect (not during rendering).
8506       *
8507       * @param triggerId ID of the trigger to associate with the tooltip. The trigger must be a matching
8508       * `Tooltip.Trigger` with this handle passed as a prop.
8509       */
8510      open(triggerId) {
8511        this.openByTrigger(triggerId);
8512      }
8513      /**
8514       * Closes the tooltip.
8515       *
8516       * This method should only be called in an event handler or an effect (not during rendering).
8517       */
8518      close() {
8519        this.closePopup();
8520      }
8521      /**
8522       * Whether the tooltip is currently open. Returns `false` while no root is attached to the handle.
8523       */
8524      get isOpen() {
8525        return this.attachedStore?.select("open") ?? false;
8526      }
8527    };
8528    function createTooltipHandle() {
8529      return new TooltipHandle();
8530    }
8531  
8532    // node_modules/@base-ui/react/use-render/useRender.mjs
8533    function useRender(params) {
8534      return useRenderElement(params.defaultTagName ?? "div", params, params);
8535    }
8536  
8537    // packages/ui/build-module/tooltip/index.mjs
8538    var tooltip_exports = {};
8539    __export(tooltip_exports, {
8540      Popup: () => Popup,
8541      Portal: () => Portal,
8542      Positioner: () => Positioner,
8543      Provider: () => Provider,
8544      Root: () => Root,
8545      Trigger: () => Trigger
8546    });
8547  
8548    // packages/ui/build-module/tooltip/popup.mjs
8549    var import_element13 = __toESM(require_element(), 1);
8550  
8551    // packages/ui/build-module/tooltip/portal.mjs
8552    var import_element10 = __toESM(require_element(), 1);
8553  
8554    // packages/ui/build-module/utils/wp-compat-overlay-slot.mjs
8555    var STYLE_HASH_ATTRIBUTE = "data-wp-hash";
8556    function getRuntime() {
8557      const globalScope = globalThis;
8558      if (globalScope.__wpStyleRuntime) {
8559        return globalScope.__wpStyleRuntime;
8560      }
8561      globalScope.__wpStyleRuntime = {
8562        documents: /* @__PURE__ */ new Map(),
8563        styles: /* @__PURE__ */ new Map(),
8564        injectedStyles: /* @__PURE__ */ new WeakMap()
8565      };
8566      if (typeof document !== "undefined") {
8567        registerDocument(document);
8568      }
8569      return globalScope.__wpStyleRuntime;
8570    }
8571    function documentContainsStyleHash(targetDocument, hash) {
8572      if (!targetDocument.head) {
8573        return false;
8574      }
8575      for (const style of targetDocument.head.querySelectorAll(
8576        `style[$STYLE_HASH_ATTRIBUTE}]`
8577      )) {
8578        if (style.getAttribute(STYLE_HASH_ATTRIBUTE) === hash) {
8579          return true;
8580        }
8581      }
8582      return false;
8583    }
8584    function injectStyle(targetDocument, hash, css) {
8585      if (!targetDocument.head) {
8586        return;
8587      }
8588      const runtime = getRuntime();
8589      let injectedStyles = runtime.injectedStyles.get(targetDocument);
8590      if (!injectedStyles) {
8591        injectedStyles = /* @__PURE__ */ new Set();
8592        runtime.injectedStyles.set(targetDocument, injectedStyles);
8593      }
8594      if (injectedStyles.has(hash)) {
8595        return;
8596      }
8597      if (documentContainsStyleHash(targetDocument, hash)) {
8598        injectedStyles.add(hash);
8599        return;
8600      }
8601      const style = targetDocument.createElement("style");
8602      style.setAttribute(STYLE_HASH_ATTRIBUTE, hash);
8603      style.appendChild(targetDocument.createTextNode(css));
8604      targetDocument.head.appendChild(style);
8605      injectedStyles.add(hash);
8606    }
8607    function registerDocument(targetDocument) {
8608      const runtime = getRuntime();
8609      runtime.documents.set(
8610        targetDocument,
8611        (runtime.documents.get(targetDocument) ?? 0) + 1
8612      );
8613      for (const [hash, css] of runtime.styles) {
8614        injectStyle(targetDocument, hash, css);
8615      }
8616      return () => {
8617        const count = runtime.documents.get(targetDocument);
8618        if (count === void 0) {
8619          return;
8620        }
8621        if (count <= 1) {
8622          runtime.documents.delete(targetDocument);
8623          return;
8624        }
8625        runtime.documents.set(targetDocument, count - 1);
8626      };
8627    }
8628    function registerStyle(hash, css) {
8629      const runtime = getRuntime();
8630      runtime.styles.set(hash, css);
8631      for (const targetDocument of runtime.documents.keys()) {
8632        injectStyle(targetDocument, hash, css);
8633      }
8634    }
8635    if (typeof process === "undefined" || true) {
8636      registerStyle("be37f31c1e", "._11fc52b637ff8a7e__slot{inset:0;isolation:isolate;pointer-events:none;position:fixed;z-index:1000000003}@layer wp-ui{@layer utilities, components, compositions, overrides;@layer utilities{._11fc52b637ff8a7e__slot>*{pointer-events:auto}}}");
8637    }
8638    var wp_compat_overlay_slot_default = { "slot": "_11fc52b637ff8a7e__slot" };
8639    var WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE = "data-wp-compat-overlay-slot";
8640    function resolveOwnerDocument() {
8641      return typeof document === "undefined" ? null : document;
8642    }
8643    function isInWordPressEnvironment() {
8644      let topWp;
8645      try {
8646        topWp = window.top?.wp;
8647      } catch {
8648      }
8649      const wp = topWp ?? window.wp;
8650      return typeof wp?.components === "object" && wp.components !== null;
8651    }
8652    var cachedSlot = null;
8653    function ensureSlotIsAccessible(element) {
8654      element.setAttribute("aria-hidden", "false");
8655      return element;
8656    }
8657    function createSlot(ownerDocument2) {
8658      const element = ownerDocument2.createElement("div");
8659      element.setAttribute(WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE, "");
8660      if (wp_compat_overlay_slot_default.slot) {
8661        element.classList.add(wp_compat_overlay_slot_default.slot);
8662      }
8663      ownerDocument2.body.appendChild(element);
8664      return element;
8665    }
8666    function getWpCompatOverlaySlot() {
8667      if (typeof window === "undefined") {
8668        return void 0;
8669      }
8670      if (!isInWordPressEnvironment() && window.__wpUiCompatOverlaySlotEnabled !== true) {
8671        return void 0;
8672      }
8673      const ownerDocument2 = resolveOwnerDocument();
8674      if (!ownerDocument2 || !ownerDocument2.body) {
8675        return void 0;
8676      }
8677      if (cachedSlot && cachedSlot.ownerDocument === ownerDocument2 && cachedSlot.isConnected) {
8678        return ensureSlotIsAccessible(cachedSlot);
8679      }
8680      const existing = ownerDocument2.querySelector(
8681        `[$WP_COMPAT_OVERLAY_SLOT_ATTRIBUTE}]`
8682      );
8683      if (existing instanceof HTMLDivElement) {
8684        cachedSlot = ensureSlotIsAccessible(existing);
8685        return cachedSlot;
8686      }
8687      if (cachedSlot?.isConnected) {
8688        cachedSlot.remove();
8689      }
8690      cachedSlot = ensureSlotIsAccessible(createSlot(ownerDocument2));
8691      return cachedSlot;
8692    }
8693  
8694    // packages/ui/build-module/tooltip/portal.mjs
8695    var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
8696    var Portal = (0, import_element10.forwardRef)(
8697      function TooltipPortal3({ container, ...restProps }, ref) {
8698        return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
8699          index_parts_exports.Portal,
8700          {
8701            container: container ?? getWpCompatOverlaySlot(),
8702            ...restProps,
8703            ref
8704          }
8705        );
8706      }
8707    );
8708  
8709    // packages/ui/build-module/tooltip/positioner.mjs
8710    var import_element11 = __toESM(require_element(), 1);
8711    var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
8712    var STYLE_HASH_ATTRIBUTE2 = "data-wp-hash";
8713    function getRuntime2() {
8714      const globalScope = globalThis;
8715      if (globalScope.__wpStyleRuntime) {
8716        return globalScope.__wpStyleRuntime;
8717      }
8718      globalScope.__wpStyleRuntime = {
8719        documents: /* @__PURE__ */ new Map(),
8720        styles: /* @__PURE__ */ new Map(),
8721        injectedStyles: /* @__PURE__ */ new WeakMap()
8722      };
8723      if (typeof document !== "undefined") {
8724        registerDocument2(document);
8725      }
8726      return globalScope.__wpStyleRuntime;
8727    }
8728    function documentContainsStyleHash2(targetDocument, hash) {
8729      if (!targetDocument.head) {
8730        return false;
8731      }
8732      for (const style of targetDocument.head.querySelectorAll(
8733        `style[$STYLE_HASH_ATTRIBUTE2}]`
8734      )) {
8735        if (style.getAttribute(STYLE_HASH_ATTRIBUTE2) === hash) {
8736          return true;
8737        }
8738      }
8739      return false;
8740    }
8741    function injectStyle2(targetDocument, hash, css) {
8742      if (!targetDocument.head) {
8743        return;
8744      }
8745      const runtime = getRuntime2();
8746      let injectedStyles = runtime.injectedStyles.get(targetDocument);
8747      if (!injectedStyles) {
8748        injectedStyles = /* @__PURE__ */ new Set();
8749        runtime.injectedStyles.set(targetDocument, injectedStyles);
8750      }
8751      if (injectedStyles.has(hash)) {
8752        return;
8753      }
8754      if (documentContainsStyleHash2(targetDocument, hash)) {
8755        injectedStyles.add(hash);
8756        return;
8757      }
8758      const style = targetDocument.createElement("style");
8759      style.setAttribute(STYLE_HASH_ATTRIBUTE2, hash);
8760      style.appendChild(targetDocument.createTextNode(css));
8761      targetDocument.head.appendChild(style);
8762      injectedStyles.add(hash);
8763    }
8764    function registerDocument2(targetDocument) {
8765      const runtime = getRuntime2();
8766      runtime.documents.set(
8767        targetDocument,
8768        (runtime.documents.get(targetDocument) ?? 0) + 1
8769      );
8770      for (const [hash, css] of runtime.styles) {
8771        injectStyle2(targetDocument, hash, css);
8772      }
8773      return () => {
8774        const count = runtime.documents.get(targetDocument);
8775        if (count === void 0) {
8776          return;
8777        }
8778        if (count <= 1) {
8779          runtime.documents.delete(targetDocument);
8780          return;
8781        }
8782        runtime.documents.set(targetDocument, count - 1);
8783      };
8784    }
8785    function registerStyle2(hash, css) {
8786      const runtime = getRuntime2();
8787      runtime.styles.set(hash, css);
8788      for (const targetDocument of runtime.documents.keys()) {
8789        injectStyle2(targetDocument, hash, css);
8790      }
8791    }
8792    if (typeof process === "undefined" || true) {
8793      registerStyle2("10f3806643", "@layer wp-ui{@layer utilities, components, compositions, overrides;@layer utilities{._336cd3e4e743482f__box-sizing{box-sizing:border-box;*,:after,:before{box-sizing:inherit}}}}");
8794    }
8795    var resets_default = { "box-sizing": "_336cd3e4e743482f__box-sizing" };
8796    if (typeof process === "undefined" || true) {
8797      registerStyle2("19fcc06039", '@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{._480b748dd3510e64__positioner{z-index:var(--wp-ui-tooltip-z-index,initial)}._50096b232db7709d__popup{--_wp-ui-elevation-sm:0 1px 2px rgba(0,0,0,.05),0 2px 3px rgba(0,0,0,.04),0 6px 6px rgba(0,0,0,.03),0 8px 8px rgba(0,0,0,.02);background-color:var(--wpds-color-background-surface-neutral-strong,#fff);border-radius:var(--wpds-border-radius-md,4px);box-shadow:var(--_wp-ui-elevation-sm);color:var(--wpds-color-foreground-content-neutral,#1e1e1e);font-family:var(--wpds-typography-font-family-body,-apple-system,system-ui,"Segoe UI","Roboto","Oxygen-Sans","Ubuntu","Cantarell","Helvetica Neue",sans-serif);font-size:var(--wpds-typography-font-size-sm,12px);line-height:1.4;padding:var(--wpds-dimension-padding-xs,4px) var(--wpds-dimension-padding-sm,8px);@media (forced-colors:active){border-bottom-color:CanvasText;border-bottom-style:solid;border-bottom-width:1px;border-left-color:CanvasText;border-left-style:solid;border-left-width:1px;border-right-color:CanvasText;border-right-style:solid;border-right-width:1px;border-top-color:CanvasText;border-top-style:solid;border-top-width:1px}}}}');
8798    }
8799    var style_default = { "positioner": "_480b748dd3510e64__positioner", "popup": "_50096b232db7709d__popup" };
8800    var Positioner = (0, import_element11.forwardRef)(
8801      function TooltipPositioner3({ align = "center", className, side = "top", sideOffset = 4, ...props }, ref) {
8802        return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
8803          index_parts_exports.Positioner,
8804          {
8805            ref,
8806            align,
8807            side,
8808            sideOffset,
8809            ...props,
8810            className: clsx_default(
8811              resets_default["box-sizing"],
8812              style_default.positioner,
8813              className
8814            )
8815          }
8816        );
8817      }
8818    );
8819  
8820    // packages/ui/build-module/utils/render-slot-with-children.mjs
8821    var import_element12 = __toESM(require_element(), 1);
8822    function renderSlotWithChildren(slot, defaultSlot, children) {
8823      return (0, import_element12.cloneElement)(slot ?? defaultSlot, { children });
8824    }
8825  
8826    // packages/ui/build-module/utils/theme-provider.mjs
8827    var theme = __toESM(require_theme(), 1);
8828  
8829    // packages/ui/build-module/lock-unlock.mjs
8830    var import_private_apis = __toESM(require_private_apis(), 1);
8831    var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
8832      "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
8833      "@wordpress/ui"
8834    );
8835  
8836    // packages/ui/build-module/utils/theme-provider.mjs
8837    function getThemeProvider() {
8838      const themePackage = theme;
8839      if (themePackage.ThemeProvider) {
8840        return themePackage.ThemeProvider;
8841      }
8842      if (!themePackage.privateApis) {
8843        throw new Error(
8844          "@wordpress/ui: @wordpress/theme must expose `ThemeProvider` or `privateApis.ThemeProvider`."
8845        );
8846      }
8847      return unlock(
8848        themePackage.privateApis
8849      ).ThemeProvider;
8850    }
8851    var ThemeProvider = getThemeProvider();
8852  
8853    // packages/ui/build-module/tooltip/popup.mjs
8854    var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
8855    var STYLE_HASH_ATTRIBUTE3 = "data-wp-hash";
8856    function getRuntime3() {
8857      const globalScope = globalThis;
8858      if (globalScope.__wpStyleRuntime) {
8859        return globalScope.__wpStyleRuntime;
8860      }
8861      globalScope.__wpStyleRuntime = {
8862        documents: /* @__PURE__ */ new Map(),
8863        styles: /* @__PURE__ */ new Map(),
8864        injectedStyles: /* @__PURE__ */ new WeakMap()
8865      };
8866      if (typeof document !== "undefined") {
8867        registerDocument3(document);
8868      }
8869      return globalScope.__wpStyleRuntime;
8870    }
8871    function documentContainsStyleHash3(targetDocument, hash) {
8872      if (!targetDocument.head) {
8873        return false;
8874      }
8875      for (const style of targetDocument.head.querySelectorAll(
8876        `style[$STYLE_HASH_ATTRIBUTE3}]`
8877      )) {
8878        if (style.getAttribute(STYLE_HASH_ATTRIBUTE3) === hash) {
8879          return true;
8880        }
8881      }
8882      return false;
8883    }
8884    function injectStyle3(targetDocument, hash, css) {
8885      if (!targetDocument.head) {
8886        return;
8887      }
8888      const runtime = getRuntime3();
8889      let injectedStyles = runtime.injectedStyles.get(targetDocument);
8890      if (!injectedStyles) {
8891        injectedStyles = /* @__PURE__ */ new Set();
8892        runtime.injectedStyles.set(targetDocument, injectedStyles);
8893      }
8894      if (injectedStyles.has(hash)) {
8895        return;
8896      }
8897      if (documentContainsStyleHash3(targetDocument, hash)) {
8898        injectedStyles.add(hash);
8899        return;
8900      }
8901      const style = targetDocument.createElement("style");
8902      style.setAttribute(STYLE_HASH_ATTRIBUTE3, hash);
8903      style.appendChild(targetDocument.createTextNode(css));
8904      targetDocument.head.appendChild(style);
8905      injectedStyles.add(hash);
8906    }
8907    function registerDocument3(targetDocument) {
8908      const runtime = getRuntime3();
8909      runtime.documents.set(
8910        targetDocument,
8911        (runtime.documents.get(targetDocument) ?? 0) + 1
8912      );
8913      for (const [hash, css] of runtime.styles) {
8914        injectStyle3(targetDocument, hash, css);
8915      }
8916      return () => {
8917        const count = runtime.documents.get(targetDocument);
8918        if (count === void 0) {
8919          return;
8920        }
8921        if (count <= 1) {
8922          runtime.documents.delete(targetDocument);
8923          return;
8924        }
8925        runtime.documents.set(targetDocument, count - 1);
8926      };
8927    }
8928    function registerStyle3(hash, css) {
8929      const runtime = getRuntime3();
8930      runtime.styles.set(hash, css);
8931      for (const targetDocument of runtime.documents.keys()) {
8932        injectStyle3(targetDocument, hash, css);
8933      }
8934    }
8935    if (typeof process === "undefined" || true) {
8936      registerStyle3("19fcc06039", '@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{._480b748dd3510e64__positioner{z-index:var(--wp-ui-tooltip-z-index,initial)}._50096b232db7709d__popup{--_wp-ui-elevation-sm:0 1px 2px rgba(0,0,0,.05),0 2px 3px rgba(0,0,0,.04),0 6px 6px rgba(0,0,0,.03),0 8px 8px rgba(0,0,0,.02);background-color:var(--wpds-color-background-surface-neutral-strong,#fff);border-radius:var(--wpds-border-radius-md,4px);box-shadow:var(--_wp-ui-elevation-sm);color:var(--wpds-color-foreground-content-neutral,#1e1e1e);font-family:var(--wpds-typography-font-family-body,-apple-system,system-ui,"Segoe UI","Roboto","Oxygen-Sans","Ubuntu","Cantarell","Helvetica Neue",sans-serif);font-size:var(--wpds-typography-font-size-sm,12px);line-height:1.4;padding:var(--wpds-dimension-padding-xs,4px) var(--wpds-dimension-padding-sm,8px);@media (forced-colors:active){border-bottom-color:CanvasText;border-bottom-style:solid;border-bottom-width:1px;border-left-color:CanvasText;border-left-style:solid;border-left-width:1px;border-right-color:CanvasText;border-right-style:solid;border-right-width:1px;border-top-color:CanvasText;border-top-style:solid;border-top-width:1px}}}}');
8937    }
8938    var style_default2 = { "positioner": "_480b748dd3510e64__positioner", "popup": "_50096b232db7709d__popup" };
8939    var POPUP_COLOR = { background: "#1e1e1e" };
8940    var Popup = (0, import_element13.forwardRef)(function TooltipPopup3({ portal, positioner, children, className, ...props }, ref) {
8941      const popupContent = /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(ThemeProvider, { color: POPUP_COLOR, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
8942        index_parts_exports.Popup,
8943        {
8944          ref,
8945          className: clsx_default(style_default2.popup, className),
8946          ...props,
8947          children
8948        }
8949      ) });
8950      const positionedPopup = renderSlotWithChildren(
8951        positioner,
8952        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Positioner, {}),
8953        popupContent
8954      );
8955      return renderSlotWithChildren(portal, /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Portal, {}), positionedPopup);
8956    });
8957  
8958    // packages/ui/build-module/tooltip/trigger.mjs
8959    var import_element14 = __toESM(require_element(), 1);
8960    var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
8961    var Trigger = (0, import_element14.forwardRef)(
8962      function TooltipTrigger3(props, ref) {
8963        return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(index_parts_exports.Trigger, { ref, ...props });
8964      }
8965    );
8966  
8967    // packages/ui/build-module/utils/direction-provider.mjs
8968    var import_i18n = __toESM(require_i18n(), 1);
8969    var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
8970    function DirectionProvider3({ children }) {
8971      return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(DirectionProvider, { direction: (0, import_i18n.isRTL)() ? "rtl" : "ltr", children });
8972    }
8973  
8974    // packages/ui/build-module/tooltip/root.mjs
8975    var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
8976    function Root(props) {
8977      return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(DirectionProvider3, { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(index_parts_exports.Root, { ...props }) });
8978    }
8979  
8980    // packages/ui/build-module/tooltip/provider.mjs
8981    var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
8982    function Provider({ ...props }) {
8983      return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(index_parts_exports.Provider, { ...props });
8984    }
8985  
8986    // packages/icons/build-module/library/chevron-down.mjs
8987    var import_primitives = __toESM(require_primitives(), 1);
8988    var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
8989    var chevron_down_default = /* @__PURE__ */ (0, import_jsx_runtime19.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_runtime19.jsx)(import_primitives.Path, { d: "M7 11L12 15L17 11", vectorEffect: "non-scaling-stroke" }) });
8990  
8991    // packages/icons/build-module/library/chevron-left.mjs
8992    var import_primitives2 = __toESM(require_primitives(), 1);
8993    var import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
8994    var chevron_left_default = /* @__PURE__ */ (0, import_jsx_runtime20.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_runtime20.jsx)(import_primitives2.Path, { d: "M14 6.5L9 12L14 17.5", vectorEffect: "non-scaling-stroke" }) });
8995  
8996    // packages/icons/build-module/library/chevron-right.mjs
8997    var import_primitives3 = __toESM(require_primitives(), 1);
8998    var import_jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
8999    var chevron_right_default = /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_primitives3.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", style: { fill: "none" }, stroke: "currentColor", strokeWidth: "1.5", children: /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_primitives3.Path, { d: "M10 6.5L15 12L10 17.5", vectorEffect: "non-scaling-stroke" }) });
9000  
9001    // packages/icons/build-module/library/chevron-up.mjs
9002    var import_primitives4 = __toESM(require_primitives(), 1);
9003    var import_jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
9004    var chevron_up_default = /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(import_primitives4.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_runtime22.jsx)(import_primitives4.Path, { d: "M7 13L12 9L17 13", vectorEffect: "non-scaling-stroke" }) });
9005  
9006    // packages/icons/build-module/library/fullscreen.mjs
9007    var import_primitives5 = __toESM(require_primitives(), 1);
9008    var import_jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
9009    var fullscreen_default = /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_primitives5.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(import_primitives5.Path, { d: "M6 4a2 2 0 0 0-2 2v3h1.5V6a.5.5 0 0 1 .5-.5h3V4H6Zm3 14.5H6a.5.5 0 0 1-.5-.5v-3H4v3a2 2 0 0 0 2 2h3v-1.5Zm6 1.5v-1.5h3a.5.5 0 0 0 .5-.5v-3H20v3a2 2 0 0 1-2 2h-3Zm3-16a2 2 0 0 1 2 2v3h-1.5V6a.5.5 0 0 0-.5-.5h-3V4h3Z" }) });
9010  
9011    // packages/ui/build-module/visually-hidden/visually-hidden.mjs
9012    var import_element15 = __toESM(require_element(), 1);
9013    var STYLE_HASH_ATTRIBUTE4 = "data-wp-hash";
9014    function getRuntime4() {
9015      const globalScope = globalThis;
9016      if (globalScope.__wpStyleRuntime) {
9017        return globalScope.__wpStyleRuntime;
9018      }
9019      globalScope.__wpStyleRuntime = {
9020        documents: /* @__PURE__ */ new Map(),
9021        styles: /* @__PURE__ */ new Map(),
9022        injectedStyles: /* @__PURE__ */ new WeakMap()
9023      };
9024      if (typeof document !== "undefined") {
9025        registerDocument4(document);
9026      }
9027      return globalScope.__wpStyleRuntime;
9028    }
9029    function documentContainsStyleHash4(targetDocument, hash) {
9030      if (!targetDocument.head) {
9031        return false;
9032      }
9033      for (const style of targetDocument.head.querySelectorAll(
9034        `style[$STYLE_HASH_ATTRIBUTE4}]`
9035      )) {
9036        if (style.getAttribute(STYLE_HASH_ATTRIBUTE4) === hash) {
9037          return true;
9038        }
9039      }
9040      return false;
9041    }
9042    function injectStyle4(targetDocument, hash, css) {
9043      if (!targetDocument.head) {
9044        return;
9045      }
9046      const runtime = getRuntime4();
9047      let injectedStyles = runtime.injectedStyles.get(targetDocument);
9048      if (!injectedStyles) {
9049        injectedStyles = /* @__PURE__ */ new Set();
9050        runtime.injectedStyles.set(targetDocument, injectedStyles);
9051      }
9052      if (injectedStyles.has(hash)) {
9053        return;
9054      }
9055      if (documentContainsStyleHash4(targetDocument, hash)) {
9056        injectedStyles.add(hash);
9057        return;
9058      }
9059      const style = targetDocument.createElement("style");
9060      style.setAttribute(STYLE_HASH_ATTRIBUTE4, hash);
9061      style.appendChild(targetDocument.createTextNode(css));
9062      targetDocument.head.appendChild(style);
9063      injectedStyles.add(hash);
9064    }
9065    function registerDocument4(targetDocument) {
9066      const runtime = getRuntime4();
9067      runtime.documents.set(
9068        targetDocument,
9069        (runtime.documents.get(targetDocument) ?? 0) + 1
9070      );
9071      for (const [hash, css] of runtime.styles) {
9072        injectStyle4(targetDocument, hash, css);
9073      }
9074      return () => {
9075        const count = runtime.documents.get(targetDocument);
9076        if (count === void 0) {
9077          return;
9078        }
9079        if (count <= 1) {
9080          runtime.documents.delete(targetDocument);
9081          return;
9082        }
9083        runtime.documents.set(targetDocument, count - 1);
9084      };
9085    }
9086    function registerStyle4(hash, css) {
9087      const runtime = getRuntime4();
9088      runtime.styles.set(hash, css);
9089      for (const targetDocument of runtime.documents.keys()) {
9090        injectStyle4(targetDocument, hash, css);
9091      }
9092    }
9093    if (typeof process === "undefined" || true) {
9094      registerStyle4("fa606a57ae", "@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{.f37b9e2e191ebd66__visually-hidden{word-wrap:normal;border:0;clip-path:inset(50%);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px;word-break:normal}}}");
9095    }
9096    var style_default3 = { "visually-hidden": "f37b9e2e191ebd66__visually-hidden" };
9097    var VisuallyHidden = (0, import_element15.forwardRef)(
9098      function VisuallyHidden2({ render, ...restProps }, ref) {
9099        const element = useRender({
9100          render,
9101          ref,
9102          props: mergeProps(
9103            { className: style_default3["visually-hidden"] },
9104            restProps,
9105            {
9106              // @ts-expect-error Arbitrary data-* attributes aren't indexable on the typed div props. Kept hardcoded so consumers can't change or remove it.
9107              "data-visually-hidden": ""
9108            }
9109          )
9110        });
9111        return element;
9112      }
9113    );
9114  
9115    // packages/ui/build-module/stack/stack.mjs
9116    var import_element16 = __toESM(require_element(), 1);
9117    var STYLE_HASH_ATTRIBUTE5 = "data-wp-hash";
9118    function getRuntime5() {
9119      const globalScope = globalThis;
9120      if (globalScope.__wpStyleRuntime) {
9121        return globalScope.__wpStyleRuntime;
9122      }
9123      globalScope.__wpStyleRuntime = {
9124        documents: /* @__PURE__ */ new Map(),
9125        styles: /* @__PURE__ */ new Map(),
9126        injectedStyles: /* @__PURE__ */ new WeakMap()
9127      };
9128      if (typeof document !== "undefined") {
9129        registerDocument5(document);
9130      }
9131      return globalScope.__wpStyleRuntime;
9132    }
9133    function documentContainsStyleHash5(targetDocument, hash) {
9134      if (!targetDocument.head) {
9135        return false;
9136      }
9137      for (const style of targetDocument.head.querySelectorAll(
9138        `style[$STYLE_HASH_ATTRIBUTE5}]`
9139      )) {
9140        if (style.getAttribute(STYLE_HASH_ATTRIBUTE5) === hash) {
9141          return true;
9142        }
9143      }
9144      return false;
9145    }
9146    function injectStyle5(targetDocument, hash, css) {
9147      if (!targetDocument.head) {
9148        return;
9149      }
9150      const runtime = getRuntime5();
9151      let injectedStyles = runtime.injectedStyles.get(targetDocument);
9152      if (!injectedStyles) {
9153        injectedStyles = /* @__PURE__ */ new Set();
9154        runtime.injectedStyles.set(targetDocument, injectedStyles);
9155      }
9156      if (injectedStyles.has(hash)) {
9157        return;
9158      }
9159      if (documentContainsStyleHash5(targetDocument, hash)) {
9160        injectedStyles.add(hash);
9161        return;
9162      }
9163      const style = targetDocument.createElement("style");
9164      style.setAttribute(STYLE_HASH_ATTRIBUTE5, hash);
9165      style.appendChild(targetDocument.createTextNode(css));
9166      targetDocument.head.appendChild(style);
9167      injectedStyles.add(hash);
9168    }
9169    function registerDocument5(targetDocument) {
9170      const runtime = getRuntime5();
9171      runtime.documents.set(
9172        targetDocument,
9173        (runtime.documents.get(targetDocument) ?? 0) + 1
9174      );
9175      for (const [hash, css] of runtime.styles) {
9176        injectStyle5(targetDocument, hash, css);
9177      }
9178      return () => {
9179        const count = runtime.documents.get(targetDocument);
9180        if (count === void 0) {
9181          return;
9182        }
9183        if (count <= 1) {
9184          runtime.documents.delete(targetDocument);
9185          return;
9186        }
9187        runtime.documents.set(targetDocument, count - 1);
9188      };
9189    }
9190    function registerStyle5(hash, css) {
9191      const runtime = getRuntime5();
9192      runtime.styles.set(hash, css);
9193      for (const targetDocument of runtime.documents.keys()) {
9194        injectStyle5(targetDocument, hash, css);
9195      }
9196    }
9197    if (typeof process === "undefined" || true) {
9198      registerStyle5("32aba35fe1", "@layer wp-ui{@layer utilities, components, compositions, overrides;@layer components{._19ce0419607e1896__stack{display:flex}}}");
9199    }
9200    var style_default4 = { "stack": "_19ce0419607e1896__stack" };
9201    var gapTokens = {
9202      xs: "var(--wpds-dimension-gap-xs, 4px)",
9203      sm: "var(--wpds-dimension-gap-sm, 8px)",
9204      md: "var(--wpds-dimension-gap-md, 12px)",
9205      lg: "var(--wpds-dimension-gap-lg, 16px)",
9206      xl: "var(--wpds-dimension-gap-xl, 24px)",
9207      "2xl": "var(--wpds-dimension-gap-2xl, 32px)",
9208      "3xl": "var(--wpds-dimension-gap-3xl, 40px)"
9209    };
9210    var Stack = (0, import_element16.forwardRef)(function Stack2({ direction, gap, align, justify, wrap, render, ...props }, ref) {
9211      const style = {
9212        gap: gap && gapTokens[gap],
9213        alignItems: align,
9214        justifyContent: justify,
9215        flexDirection: direction,
9216        flexWrap: wrap
9217      };
9218      const element = useRender({
9219        render,
9220        ref,
9221        props: mergeProps(props, { style, className: style_default4.stack })
9222      });
9223      return element;
9224    });
9225  
9226    // packages/admin-ui/build-module/navigable-region/index.mjs
9227    var import_element17 = __toESM(require_element(), 1);
9228    var import_jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
9229    var NavigableRegion = (0, import_element17.forwardRef)(
9230      ({ children, className, ariaLabel, as: Tag = "div", ...props }, ref) => {
9231        return /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
9232          Tag,
9233          {
9234            ref,
9235            className: clsx_default("admin-ui-navigable-region", className),
9236            "aria-label": ariaLabel,
9237            role: "region",
9238            tabIndex: "-1",
9239            ...props,
9240            children
9241          }
9242        );
9243      }
9244    );
9245    NavigableRegion.displayName = "NavigableRegion";
9246    var navigable_region_default = NavigableRegion;
9247  
9248    // packages/admin-ui/build-module/admin-theme-colors/index.mjs
9249    var DEFAULT_THEME_COLORS = {
9250      primary: "#3858e9",
9251      background: "#222524"
9252    };
9253    var ADMIN_THEME_COLORS = /* @__PURE__ */ new Map([
9254      ["modern", DEFAULT_THEME_COLORS],
9255      ["fresh", { primary: "#007cba", background: "#25292b" }],
9256      ["midnight", { primary: "#cf4339", background: "#3d4042" }],
9257      ["coffee", { primary: "#916745", background: "#5b534d" }],
9258      ["ocean", { primary: "#567958", background: "#5f787f" }],
9259      ["blue", { primary: "#437aa8", background: "#3876a8" }],
9260      ["ectoplasm", { primary: "#646c3e", background: "#4f386e" }],
9261      ["sunrise", { primary: "#ad631e", background: "#cc4541" }],
9262      ["light", { primary: "#007cba", background: "#eaeeed" }]
9263    ]);
9264    function getAdminThemeColors() {
9265      const scheme = document.body.className.match(/admin-color-([\w-]+)/)?.[1] ?? "modern";
9266      return ADMIN_THEME_COLORS.get(scheme) ?? DEFAULT_THEME_COLORS;
9267    }
9268  
9269    // packages/edit-post/build-module/components/layout/index.mjs
9270    var import_editor19 = __toESM(require_editor(), 1);
9271    var import_data26 = __toESM(require_data(), 1);
9272    var import_block_editor2 = __toESM(require_block_editor(), 1);
9273  
9274    // packages/global-styles-engine/build-module/utils/common.mjs
9275    var import_style_engine = __toESM(require_style_engine(), 1);
9276    var ROOT_BLOCK_SELECTOR = "body";
9277    var ROOT_CSS_PROPERTIES_SELECTOR = ":root";
9278  
9279    // packages/global-styles-engine/build-module/core/render.mjs
9280    var import_blocks = __toESM(require_blocks(), 1);
9281    var import_style_engine2 = __toESM(require_style_engine(), 1);
9282    var import_data = __toESM(require_data(), 1);
9283  
9284    // packages/global-styles-engine/build-module/utils/spacing.mjs
9285    function getSpacingPresetCssVar(value) {
9286      if (!value) {
9287        return;
9288      }
9289      const slug = value.match(/var:preset\|spacing\|(.+)/);
9290      if (!slug) {
9291        return value;
9292      }
9293      return `var(--wp--preset--spacing--$slug[1]})`;
9294    }
9295  
9296    // packages/global-styles-engine/build-module/utils/gap.mjs
9297    function getGapBoxControlValueFromStyle(blockGapValue) {
9298      if (!blockGapValue) {
9299        return null;
9300      }
9301      const isValueString = typeof blockGapValue === "string";
9302      return {
9303        top: isValueString ? blockGapValue : blockGapValue?.top,
9304        left: isValueString ? blockGapValue : blockGapValue?.left
9305      };
9306    }
9307    function getGapCSSValue(blockGapValue, defaultValue = "0") {
9308      const blockGapBoxControlValue = getGapBoxControlValueFromStyle(blockGapValue);
9309      if (!blockGapBoxControlValue) {
9310        return null;
9311      }
9312      const row = getSpacingPresetCssVar(blockGapBoxControlValue?.top) || defaultValue;
9313      const column = getSpacingPresetCssVar(blockGapBoxControlValue?.left) || defaultValue;
9314      return row === column ? row : `$row} $column}`;
9315    }
9316  
9317    // packages/global-styles-engine/build-module/utils/layout.mjs
9318    var LAYOUT_DEFINITIONS = {
9319      default: {
9320        name: "default",
9321        slug: "flow",
9322        className: "is-layout-flow",
9323        baseStyles: [
9324          {
9325            selector: " > .alignleft",
9326            rules: {
9327              float: "left",
9328              "margin-inline-start": "0",
9329              "margin-inline-end": "2em"
9330            }
9331          },
9332          {
9333            selector: " > .alignright",
9334            rules: {
9335              float: "right",
9336              "margin-inline-start": "2em",
9337              "margin-inline-end": "0"
9338            }
9339          },
9340          {
9341            selector: " > .aligncenter",
9342            rules: {
9343              "margin-left": "auto !important",
9344              "margin-right": "auto !important"
9345            }
9346          }
9347        ],
9348        spacingStyles: [
9349          {
9350            selector: " > :first-child",
9351            rules: {
9352              "margin-block-start": "0"
9353            }
9354          },
9355          {
9356            selector: " > :last-child",
9357            rules: {
9358              "margin-block-end": "0"
9359            }
9360          },
9361          {
9362            selector: " > *",
9363            rules: {
9364              "margin-block-start": null,
9365              "margin-block-end": "0"
9366            }
9367          }
9368        ]
9369      },
9370      constrained: {
9371        name: "constrained",
9372        slug: "constrained",
9373        className: "is-layout-constrained",
9374        baseStyles: [
9375          {
9376            selector: " > .alignleft",
9377            rules: {
9378              float: "left",
9379              "margin-inline-start": "0",
9380              "margin-inline-end": "2em"
9381            }
9382          },
9383          {
9384            selector: " > .alignright",
9385            rules: {
9386              float: "right",
9387              "margin-inline-start": "2em",
9388              "margin-inline-end": "0"
9389            }
9390          },
9391          {
9392            selector: " > .aligncenter",
9393            rules: {
9394              "margin-left": "auto !important",
9395              "margin-right": "auto !important"
9396            }
9397          },
9398          {
9399            selector: " > :where(:not(.alignleft):not(.alignright):not(.alignfull))",
9400            rules: {
9401              "max-width": "var(--wp--style--global--content-size)",
9402              "margin-left": "auto !important",
9403              "margin-right": "auto !important"
9404            }
9405          },
9406          {
9407            selector: " > .alignwide",
9408            rules: {
9409              "max-width": "var(--wp--style--global--wide-size)"
9410            }
9411          }
9412        ],
9413        spacingStyles: [
9414          {
9415            selector: " > :first-child",
9416            rules: {
9417              "margin-block-start": "0"
9418            }
9419          },
9420          {
9421            selector: " > :last-child",
9422            rules: {
9423              "margin-block-end": "0"
9424            }
9425          },
9426          {
9427            selector: " > *",
9428            rules: {
9429              "margin-block-start": null,
9430              "margin-block-end": "0"
9431            }
9432          }
9433        ]
9434      },
9435      flex: {
9436        name: "flex",
9437        slug: "flex",
9438        className: "is-layout-flex",
9439        displayMode: "flex",
9440        baseStyles: [
9441          {
9442            selector: "",
9443            rules: {
9444              "flex-wrap": "wrap",
9445              "align-items": "center"
9446            }
9447          },
9448          {
9449            selector: " > :is(*, div)",
9450            // :is(*, div) instead of just * increases the specificity by 001.
9451            rules: {
9452              margin: "0"
9453            }
9454          }
9455        ],
9456        spacingStyles: [
9457          {
9458            selector: "",
9459            rules: {
9460              gap: null
9461            }
9462          }
9463        ]
9464      },
9465      grid: {
9466        name: "grid",
9467        slug: "grid",
9468        className: "is-layout-grid",
9469        displayMode: "grid",
9470        baseStyles: [
9471          {
9472            selector: " > :is(*, div)",
9473            // :is(*, div) instead of just * increases the specificity by 001.
9474            rules: {
9475              margin: "0"
9476            }
9477          }
9478        ],
9479        spacingStyles: [
9480          {
9481            selector: "",
9482            rules: {
9483              gap: null
9484            }
9485          }
9486        ]
9487      }
9488    };
9489  
9490    // packages/global-styles-engine/build-module/core/render.mjs
9491    function getLayoutStyles({
9492      layoutDefinitions = LAYOUT_DEFINITIONS,
9493      style,
9494      selector,
9495      hasBlockGapSupport,
9496      hasFallbackGapSupport,
9497      fallbackGapValue
9498    }) {
9499      let ruleset = "";
9500      const blockGapValue = style?.spacing?.blockGap;
9501      let gapValue = hasBlockGapSupport ? getGapCSSValue(blockGapValue) : "";
9502      if (hasFallbackGapSupport) {
9503        if (selector === ROOT_BLOCK_SELECTOR) {
9504          gapValue = !gapValue ? "0.5em" : gapValue;
9505        } else if (!hasBlockGapSupport && fallbackGapValue) {
9506          gapValue = fallbackGapValue;
9507        }
9508      }
9509      const rowGapValue = hasBlockGapSupport && blockGapValue && typeof blockGapValue !== "string" ? getGapCSSValue(blockGapValue.top) : gapValue;
9510      if (gapValue && layoutDefinitions) {
9511        Object.values(layoutDefinitions).forEach(
9512          ({ className, name, spacingStyles }) => {
9513            if (!hasBlockGapSupport && "flex" !== name && "grid" !== name) {
9514              return;
9515            }
9516            const layoutGapValue = ["default", "constrained"].includes(
9517              name
9518            ) ? rowGapValue : gapValue;
9519            if (spacingStyles?.length) {
9520              spacingStyles.forEach((spacingStyle) => {
9521                const declarations = [];
9522                if (spacingStyle.rules) {
9523                  Object.entries(spacingStyle.rules).forEach(
9524                    ([cssProperty, cssValue]) => {
9525                      declarations.push(
9526                        `$cssProperty}: $cssValue ? cssValue : layoutGapValue}`
9527                      );
9528                    }
9529                  );
9530                }
9531                if (declarations.length) {
9532                  let combinedSelector = "";
9533                  if (!hasBlockGapSupport) {
9534                    combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:where(.$className}$spacingStyle?.selector || ""})` : `:where($selector}.$className}$spacingStyle?.selector || ""})`;
9535                  } else {
9536                    combinedSelector = selector === ROOT_BLOCK_SELECTOR ? `:root :where(.$className})$spacingStyle?.selector || ""}` : `:root :where($selector}-$className})$spacingStyle?.selector || ""}`;
9537                  }
9538                  ruleset += `$combinedSelector} { $declarations.join(
9539                    "; "
9540                  )}; }`;
9541                }
9542              });
9543            }
9544          }
9545        );
9546        if (selector === ROOT_BLOCK_SELECTOR && hasBlockGapSupport) {
9547          ruleset += `$ROOT_CSS_PROPERTIES_SELECTOR} { --wp--style--block-gap: $gapValue}; }`;
9548        }
9549      }
9550      if (selector === ROOT_BLOCK_SELECTOR && layoutDefinitions) {
9551        const validDisplayModes = ["block", "flex", "grid"];
9552        Object.values(layoutDefinitions).forEach(
9553          ({ className, displayMode, baseStyles }) => {
9554            if (displayMode && validDisplayModes.includes(displayMode)) {
9555              ruleset += `$selector} .$className} { display:$displayMode}; }`;
9556            }
9557            if (baseStyles?.length) {
9558              baseStyles.forEach((baseStyle) => {
9559                const declarations = [];
9560                if (baseStyle.rules) {
9561                  Object.entries(baseStyle.rules).forEach(
9562                    ([cssProperty, cssValue]) => {
9563                      declarations.push(
9564                        `$cssProperty}: $cssValue}`
9565                      );
9566                    }
9567                  );
9568                }
9569                if (declarations.length) {
9570                  const combinedSelector = `.$className}$baseStyle?.selector || ""}`;
9571                  ruleset += `$combinedSelector} { $declarations.join(
9572                    "; "
9573                  )}; }`;
9574                }
9575              });
9576            }
9577          }
9578        );
9579      }
9580      return ruleset;
9581    }
9582  
9583    // packages/edit-post/build-module/components/layout/index.mjs
9584    var import_plugins = __toESM(require_plugins(), 1);
9585    var import_i18n15 = __toESM(require_i18n(), 1);
9586    var import_element29 = __toESM(require_element(), 1);
9587    var import_notices3 = __toESM(require_notices(), 1);
9588    var import_preferences10 = __toESM(require_preferences(), 1);
9589    var import_commands2 = __toESM(require_commands(), 1);
9590    var import_url6 = __toESM(require_url(), 1);
9591    var import_html_entities = __toESM(require_html_entities(), 1);
9592    var import_core_data9 = __toESM(require_core_data(), 1);
9593    var import_components8 = __toESM(require_components(), 1);
9594    var import_compose2 = __toESM(require_compose(), 1);
9595    var import_theme = __toESM(require_theme(), 1);
9596  
9597    // packages/edit-post/build-module/components/back-button/index.mjs
9598    var import_editor2 = __toESM(require_editor(), 1);
9599    var import_components2 = __toESM(require_components(), 1);
9600    var import_preferences = __toESM(require_preferences(), 1);
9601    var import_data3 = __toESM(require_data(), 1);
9602  
9603    // packages/edit-post/build-module/components/back-button/fullscreen-mode-close.mjs
9604    var import_data2 = __toESM(require_data(), 1);
9605    var import_components = __toESM(require_components(), 1);
9606    var import_i18n2 = __toESM(require_i18n(), 1);
9607    var import_url = __toESM(require_url(), 1);
9608    var import_editor = __toESM(require_editor(), 1);
9609    var import_core_data = __toESM(require_core_data(), 1);
9610    var import_jsx_runtime25 = __toESM(require_jsx_runtime(), 1);
9611    function FullscreenModeClose({ showTooltip, icon, href, initialPost }) {
9612      const postType = (0, import_data2.useSelect)(
9613        (select3) => {
9614          const { getCurrentPostType } = select3(import_editor.store);
9615          const { getPostType } = select3(import_core_data.store);
9616          return getPostType(initialPost?.type || getCurrentPostType());
9617        },
9618        [initialPost?.type]
9619      );
9620      if (!postType) {
9621        return null;
9622      }
9623      const buttonHref = href ?? (0, import_url.addQueryArgs)("edit.php", {
9624        post_type: postType.slug
9625      });
9626      const buttonLabel = postType?.labels?.view_items ?? (0, import_i18n2.__)("Back");
9627      return /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(
9628        import_components.Button,
9629        {
9630          size: "compact",
9631          href: buttonHref,
9632          label: buttonLabel,
9633          showTooltip,
9634          tooltipPosition: "bottom",
9635          icon: icon ?? ((0, import_i18n2.isRTL)() ? chevron_right_default : chevron_left_default)
9636        }
9637      );
9638    }
9639    var fullscreen_mode_close_default = FullscreenModeClose;
9640  
9641    // packages/edit-post/build-module/lock-unlock.mjs
9642    var import_private_apis2 = __toESM(require_private_apis(), 1);
9643    var { lock: lock2, unlock: unlock2 } = (0, import_private_apis2.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
9644      "I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
9645      "@wordpress/edit-post"
9646    );
9647  
9648    // packages/edit-post/build-module/components/back-button/index.mjs
9649    var import_jsx_runtime26 = __toESM(require_jsx_runtime(), 1);
9650    var { BackButton: BackButtonFill } = unlock2(import_editor2.privateApis);
9651    var slideX = {
9652      hidden: { x: "-100%" },
9653      distractionFreeInactive: { x: 0 },
9654      hover: { x: 0, transition: { type: "tween", delay: 0.2 } }
9655    };
9656    function BackButton({ initialPost }) {
9657      const showIconLabels = (0, import_data3.useSelect)((select3) => {
9658        return select3(import_preferences.store).get("core", "showIconLabels");
9659      }, []);
9660      return /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(BackButtonFill, { children: ({ length }) => length <= 1 && /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
9661        import_components2.__unstableMotion.div,
9662        {
9663          variants: slideX,
9664          transition: { type: "tween", delay: 0.8 },
9665          children: /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(
9666            fullscreen_mode_close_default,
9667            {
9668              showTooltip: !showIconLabels,
9669              initialPost
9670            }
9671          )
9672        }
9673      ) });
9674    }
9675    var back_button_default = BackButton;
9676  
9677    // packages/edit-post/build-module/components/editor-initialization/listener-hooks.mjs
9678    var import_data4 = __toESM(require_data(), 1);
9679    var import_element18 = __toESM(require_element(), 1);
9680    var import_editor3 = __toESM(require_editor(), 1);
9681    var import_core_data2 = __toESM(require_core_data(), 1);
9682  
9683    // packages/edit-post/build-module/store/constants.mjs
9684    var STORE_NAME = "core/edit-post";
9685    var VIEW_AS_LINK_SELECTOR = "#wp-admin-bar-view a";
9686    var VIEW_AS_PREVIEW_LINK_SELECTOR = "#wp-admin-bar-preview a";
9687  
9688    // packages/edit-post/build-module/components/editor-initialization/listener-hooks.mjs
9689    var useUpdatePostLinkListener = () => {
9690      const { isViewable, newPermalink } = (0, import_data4.useSelect)((select3) => {
9691        const { getPostType } = select3(import_core_data2.store);
9692        const { getCurrentPost, getEditedPostAttribute } = select3(import_editor3.store);
9693        const postType = getPostType(getEditedPostAttribute("type"));
9694        return {
9695          isViewable: postType?.viewable,
9696          newPermalink: getCurrentPost().link
9697        };
9698      }, []);
9699      const nodeToUpdateRef = (0, import_element18.useRef)();
9700      (0, import_element18.useEffect)(() => {
9701        nodeToUpdateRef.current = document.querySelector(VIEW_AS_PREVIEW_LINK_SELECTOR) || document.querySelector(VIEW_AS_LINK_SELECTOR);
9702      }, []);
9703      (0, import_element18.useEffect)(() => {
9704        if (!newPermalink || !nodeToUpdateRef.current) {
9705          return;
9706        }
9707        if (!isViewable) {
9708          nodeToUpdateRef.current.style.display = "none";
9709          return;
9710        }
9711        nodeToUpdateRef.current.style.display = "";
9712        nodeToUpdateRef.current.setAttribute("href", newPermalink);
9713      }, [newPermalink, isViewable]);
9714    };
9715  
9716    // packages/edit-post/build-module/components/editor-initialization/index.mjs
9717    function EditorInitialization() {
9718      useUpdatePostLinkListener();
9719      return null;
9720    }
9721  
9722    // packages/edit-post/build-module/components/keyboard-shortcuts/index.mjs
9723    var import_element19 = __toESM(require_element(), 1);
9724    var import_data8 = __toESM(require_data(), 1);
9725    var import_keyboard_shortcuts = __toESM(require_keyboard_shortcuts(), 1);
9726    var import_i18n4 = __toESM(require_i18n(), 1);
9727  
9728    // packages/edit-post/build-module/store/index.mjs
9729    var import_data7 = __toESM(require_data(), 1);
9730  
9731    // packages/edit-post/build-module/store/reducer.mjs
9732    var import_data5 = __toESM(require_data(), 1);
9733    function isSavingMetaBoxes(state = false, action) {
9734      switch (action.type) {
9735        case "REQUEST_META_BOX_UPDATES":
9736          return true;
9737        case "META_BOX_UPDATES_SUCCESS":
9738        case "META_BOX_UPDATES_FAILURE":
9739          return false;
9740        default:
9741          return state;
9742      }
9743    }
9744    function mergeMetaboxes(metaboxes = [], newMetaboxes) {
9745      const mergedMetaboxes = [...metaboxes];
9746      for (const metabox of newMetaboxes) {
9747        const existing = mergedMetaboxes.findIndex(
9748          (box) => box.id === metabox.id
9749        );
9750        if (existing !== -1) {
9751          mergedMetaboxes[existing] = {
9752            ...mergedMetaboxes[existing],
9753            ...metabox
9754          };
9755        } else {
9756          mergedMetaboxes.push(metabox);
9757        }
9758      }
9759      return mergedMetaboxes;
9760    }
9761    function metaBoxLocations(state = {}, action) {
9762      switch (action.type) {
9763        case "SET_META_BOXES_PER_LOCATIONS": {
9764          const newState = { ...state };
9765          for (const [location, metaboxes] of Object.entries(
9766            action.metaBoxesPerLocation
9767          )) {
9768            newState[location] = mergeMetaboxes(
9769              newState[location],
9770              metaboxes
9771            );
9772          }
9773          return newState;
9774        }
9775      }
9776      return state;
9777    }
9778    function metaBoxesInitialized(state = false, action) {
9779      switch (action.type) {
9780        case "META_BOXES_INITIALIZED":
9781          return true;
9782      }
9783      return state;
9784    }
9785    var metaBoxes = (0, import_data5.combineReducers)({
9786      isSaving: isSavingMetaBoxes,
9787      locations: metaBoxLocations,
9788      initialized: metaBoxesInitialized
9789    });
9790    var reducer_default = (0, import_data5.combineReducers)({
9791      metaBoxes
9792    });
9793  
9794    // packages/edit-post/build-module/store/actions.mjs
9795    var actions_exports = {};
9796    __export(actions_exports, {
9797      __experimentalSetPreviewDeviceType: () => __experimentalSetPreviewDeviceType,
9798      __unstableCreateTemplate: () => __unstableCreateTemplate,
9799      closeGeneralSidebar: () => closeGeneralSidebar,
9800      closeModal: () => closeModal,
9801      closePublishSidebar: () => closePublishSidebar,
9802      hideBlockTypes: () => hideBlockTypes,
9803      initializeMetaBoxes: () => initializeMetaBoxes,
9804      metaBoxUpdatesFailure: () => metaBoxUpdatesFailure,
9805      metaBoxUpdatesSuccess: () => metaBoxUpdatesSuccess,
9806      openGeneralSidebar: () => openGeneralSidebar,
9807      openModal: () => openModal,
9808      openPublishSidebar: () => openPublishSidebar,
9809      removeEditorPanel: () => removeEditorPanel,
9810      requestMetaBoxUpdates: () => requestMetaBoxUpdates,
9811      setAvailableMetaBoxesPerLocation: () => setAvailableMetaBoxesPerLocation,
9812      setIsEditingTemplate: () => setIsEditingTemplate,
9813      setIsInserterOpened: () => setIsInserterOpened,
9814      setIsListViewOpened: () => setIsListViewOpened,
9815      showBlockTypes: () => showBlockTypes,
9816      switchEditorMode: () => switchEditorMode,
9817      toggleDistractionFree: () => toggleDistractionFree,
9818      toggleEditorPanelEnabled: () => toggleEditorPanelEnabled,
9819      toggleEditorPanelOpened: () => toggleEditorPanelOpened,
9820      toggleFeature: () => toggleFeature,
9821      toggleFullscreenMode: () => toggleFullscreenMode,
9822      togglePinnedPluginItem: () => togglePinnedPluginItem,
9823      togglePublishSidebar: () => togglePublishSidebar,
9824      updatePreferredStyleVariations: () => updatePreferredStyleVariations
9825    });
9826    var import_api_fetch = __toESM(require_api_fetch(), 1);
9827    var import_preferences2 = __toESM(require_preferences(), 1);
9828    var import_editor4 = __toESM(require_editor(), 1);
9829    var import_deprecated = __toESM(require_deprecated(), 1);
9830    var import_hooks = __toESM(require_hooks(), 1);
9831    var import_core_data3 = __toESM(require_core_data(), 1);
9832    var import_notices = __toESM(require_notices(), 1);
9833    var import_i18n3 = __toESM(require_i18n(), 1);
9834  
9835    // packages/edit-post/build-module/utils/meta-boxes.mjs
9836    var getMetaBoxContainer = (location) => {
9837      const area = document.querySelector(
9838        `.edit-post-meta-boxes-area.is-$location} .metabox-location-$location}`
9839      );
9840      if (area) {
9841        return area;
9842      }
9843      return document.querySelector("#metaboxes .metabox-location-" + location);
9844    };
9845  
9846    // packages/edit-post/build-module/store/actions.mjs
9847    var { interfaceStore } = unlock2(import_editor4.privateApis);
9848    var openGeneralSidebar = (name) => ({ registry }) => {
9849      registry.dispatch(interfaceStore).enableComplementaryArea("core", name);
9850    };
9851    var closeGeneralSidebar = () => ({ registry }) => registry.dispatch(interfaceStore).disableComplementaryArea("core");
9852    var openModal = (name) => ({ registry }) => {
9853      (0, import_deprecated.default)("select( 'core/edit-post' ).openModal( name )", {
9854        since: "6.3",
9855        alternative: "select( 'core/interface').openModal( name )"
9856      });
9857      return registry.dispatch(interfaceStore).openModal(name);
9858    };
9859    var closeModal = () => ({ registry }) => {
9860      (0, import_deprecated.default)("select( 'core/edit-post' ).closeModal()", {
9861        since: "6.3",
9862        alternative: "select( 'core/interface').closeModal()"
9863      });
9864      return registry.dispatch(interfaceStore).closeModal();
9865    };
9866    var openPublishSidebar = () => ({ registry }) => {
9867      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).openPublishSidebar", {
9868        since: "6.6",
9869        alternative: "dispatch( 'core/editor').openPublishSidebar"
9870      });
9871      registry.dispatch(import_editor4.store).openPublishSidebar();
9872    };
9873    var closePublishSidebar = () => ({ registry }) => {
9874      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).closePublishSidebar", {
9875        since: "6.6",
9876        alternative: "dispatch( 'core/editor').closePublishSidebar"
9877      });
9878      registry.dispatch(import_editor4.store).closePublishSidebar();
9879    };
9880    var togglePublishSidebar = () => ({ registry }) => {
9881      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).togglePublishSidebar", {
9882        since: "6.6",
9883        alternative: "dispatch( 'core/editor').togglePublishSidebar"
9884      });
9885      registry.dispatch(import_editor4.store).togglePublishSidebar();
9886    };
9887    var toggleEditorPanelEnabled = (panelName) => ({ registry }) => {
9888      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).toggleEditorPanelEnabled", {
9889        since: "6.5",
9890        alternative: "dispatch( 'core/editor').toggleEditorPanelEnabled"
9891      });
9892      registry.dispatch(import_editor4.store).toggleEditorPanelEnabled(panelName);
9893    };
9894    var toggleEditorPanelOpened = (panelName) => ({ registry }) => {
9895      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).toggleEditorPanelOpened", {
9896        since: "6.5",
9897        alternative: "dispatch( 'core/editor').toggleEditorPanelOpened"
9898      });
9899      registry.dispatch(import_editor4.store).toggleEditorPanelOpened(panelName);
9900    };
9901    var removeEditorPanel = (panelName) => ({ registry }) => {
9902      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).removeEditorPanel", {
9903        since: "6.5",
9904        alternative: "dispatch( 'core/editor').removeEditorPanel"
9905      });
9906      registry.dispatch(import_editor4.store).removeEditorPanel(panelName);
9907    };
9908    var toggleFeature = (feature) => ({ registry }) => registry.dispatch(import_preferences2.store).toggle("core/edit-post", feature);
9909    var switchEditorMode = (mode) => ({ registry }) => {
9910      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).switchEditorMode", {
9911        since: "6.6",
9912        alternative: "dispatch( 'core/editor').switchEditorMode"
9913      });
9914      registry.dispatch(import_editor4.store).switchEditorMode(mode);
9915    };
9916    var togglePinnedPluginItem = (pluginName) => ({ registry }) => {
9917      const isPinned = registry.select(interfaceStore).isItemPinned("core", pluginName);
9918      registry.dispatch(interfaceStore)[isPinned ? "unpinItem" : "pinItem"]("core", pluginName);
9919    };
9920    function updatePreferredStyleVariations() {
9921      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).updatePreferredStyleVariations", {
9922        since: "6.6",
9923        hint: "Preferred Style Variations are not supported anymore."
9924      });
9925      return { type: "NOTHING" };
9926    }
9927    var showBlockTypes = (blockNames) => ({ registry }) => {
9928      unlock2(registry.dispatch(import_editor4.store)).showBlockTypes(blockNames);
9929    };
9930    var hideBlockTypes = (blockNames) => ({ registry }) => {
9931      unlock2(registry.dispatch(import_editor4.store)).hideBlockTypes(blockNames);
9932    };
9933    function setAvailableMetaBoxesPerLocation(metaBoxesPerLocation) {
9934      return {
9935        type: "SET_META_BOXES_PER_LOCATIONS",
9936        metaBoxesPerLocation
9937      };
9938    }
9939    var requestMetaBoxUpdates = () => async ({ registry, select: select3, dispatch: dispatch2 }) => {
9940      dispatch2({
9941        type: "REQUEST_META_BOX_UPDATES"
9942      });
9943      if (window.tinyMCE) {
9944        window.tinyMCE.triggerSave();
9945      }
9946      const baseFormData = new window.FormData(
9947        document.querySelector(".metabox-base-form")
9948      );
9949      const postId = baseFormData.get("post_ID");
9950      const postType = baseFormData.get("post_type");
9951      const post = registry.select(import_core_data3.store).getEditedEntityRecord("postType", postType, postId);
9952      const additionalData = [
9953        post.comment_status ? ["comment_status", post.comment_status] : false,
9954        post.ping_status ? ["ping_status", post.ping_status] : false,
9955        post.sticky ? ["sticky", post.sticky] : false,
9956        post.author ? ["post_author", post.author] : false
9957      ].filter(Boolean);
9958      const activeMetaBoxLocations = select3.getActiveMetaBoxLocations();
9959      const formDataToMerge = [
9960        baseFormData,
9961        ...activeMetaBoxLocations.map(
9962          (location) => new window.FormData(getMetaBoxContainer(location))
9963        )
9964      ];
9965      const formData = formDataToMerge.reduce((memo, currentFormData) => {
9966        for (const [key, value] of currentFormData) {
9967          memo.append(key, value);
9968        }
9969        return memo;
9970      }, new window.FormData());
9971      additionalData.forEach(
9972        ([key, value]) => formData.append(key, value)
9973      );
9974      try {
9975        await (0, import_api_fetch.default)({
9976          url: window._wpMetaBoxUrl,
9977          method: "POST",
9978          body: formData,
9979          parse: false
9980        });
9981        dispatch2.metaBoxUpdatesSuccess();
9982      } catch {
9983        dispatch2.metaBoxUpdatesFailure();
9984      }
9985    };
9986    function metaBoxUpdatesSuccess() {
9987      return {
9988        type: "META_BOX_UPDATES_SUCCESS"
9989      };
9990    }
9991    function metaBoxUpdatesFailure() {
9992      return {
9993        type: "META_BOX_UPDATES_FAILURE"
9994      };
9995    }
9996    var __experimentalSetPreviewDeviceType = (deviceType) => ({ registry }) => {
9997      (0, import_deprecated.default)(
9998        "dispatch( 'core/edit-post' ).__experimentalSetPreviewDeviceType",
9999        {
10000          since: "6.5",
10001          version: "6.7",
10002          hint: "registry.dispatch( editorStore ).setDeviceType"
10003        }
10004      );
10005      registry.dispatch(import_editor4.store).setDeviceType(deviceType);
10006    };
10007    var setIsInserterOpened = (value) => ({ registry }) => {
10008      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).setIsInserterOpened", {
10009        since: "6.5",
10010        alternative: "dispatch( 'core/editor').setIsInserterOpened"
10011      });
10012      registry.dispatch(import_editor4.store).setIsInserterOpened(value);
10013    };
10014    var setIsListViewOpened = (isOpen) => ({ registry }) => {
10015      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).setIsListViewOpened", {
10016        since: "6.5",
10017        alternative: "dispatch( 'core/editor').setIsListViewOpened"
10018      });
10019      registry.dispatch(import_editor4.store).setIsListViewOpened(isOpen);
10020    };
10021    function setIsEditingTemplate() {
10022      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).setIsEditingTemplate", {
10023        since: "6.5",
10024        alternative: "dispatch( 'core/editor').setRenderingMode"
10025      });
10026      return { type: "NOTHING" };
10027    }
10028    function __unstableCreateTemplate() {
10029      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).__unstableCreateTemplate", {
10030        since: "6.5"
10031      });
10032      return { type: "NOTHING" };
10033    }
10034    var metaBoxesInitialized2 = false;
10035    var initializeMetaBoxes = () => ({ registry, select: select3, dispatch: dispatch2 }) => {
10036      const isEditorReady = registry.select(import_editor4.store).__unstableIsEditorReady();
10037      if (!isEditorReady) {
10038        return;
10039      }
10040      if (metaBoxesInitialized2) {
10041        return;
10042      }
10043      const postType = registry.select(import_editor4.store).getCurrentPostType();
10044      if (window.postboxes.page !== postType) {
10045        window.postboxes.add_postbox_toggles(postType);
10046      }
10047      metaBoxesInitialized2 = true;
10048      (0, import_hooks.addAction)(
10049        "editor.savePost",
10050        "core/edit-post/save-metaboxes",
10051        async (post, options) => {
10052          if (!options.isAutosave && select3.hasMetaBoxes()) {
10053            await dispatch2.requestMetaBoxUpdates();
10054          }
10055        }
10056      );
10057      dispatch2({
10058        type: "META_BOXES_INITIALIZED"
10059      });
10060    };
10061    var toggleDistractionFree = () => ({ registry }) => {
10062      (0, import_deprecated.default)("dispatch( 'core/edit-post' ).toggleDistractionFree", {
10063        since: "6.6",
10064        alternative: "dispatch( 'core/editor').toggleDistractionFree"
10065      });
10066      registry.dispatch(import_editor4.store).toggleDistractionFree();
10067    };
10068    var toggleFullscreenMode = () => ({ registry }) => {
10069      const isFullscreen = registry.select(import_preferences2.store).get("core/edit-post", "fullscreenMode");
10070      registry.dispatch(import_preferences2.store).toggle("core/edit-post", "fullscreenMode");
10071      registry.dispatch(import_notices.store).createInfoNotice(
10072        isFullscreen ? (0, import_i18n3.__)("Fullscreen mode deactivated.") : (0, import_i18n3.__)("Fullscreen mode activated."),
10073        {
10074          id: "core/edit-post/toggle-fullscreen-mode/notice",
10075          type: "snackbar",
10076          actions: [
10077            {
10078              label: (0, import_i18n3.__)("Undo"),
10079              onClick: () => {
10080                registry.dispatch(import_preferences2.store).toggle(
10081                  "core/edit-post",
10082                  "fullscreenMode"
10083                );
10084              }
10085            }
10086          ]
10087        }
10088      );
10089    };
10090  
10091    // packages/edit-post/build-module/store/selectors.mjs
10092    var selectors_exports = {};
10093    __export(selectors_exports, {
10094      __experimentalGetInsertionPoint: () => __experimentalGetInsertionPoint,
10095      __experimentalGetPreviewDeviceType: () => __experimentalGetPreviewDeviceType,
10096      areMetaBoxesInitialized: () => areMetaBoxesInitialized,
10097      getActiveGeneralSidebarName: () => getActiveGeneralSidebarName,
10098      getActiveMetaBoxLocations: () => getActiveMetaBoxLocations,
10099      getAllMetaBoxes: () => getAllMetaBoxes,
10100      getEditedPostTemplate: () => getEditedPostTemplate,
10101      getEditorMode: () => getEditorMode,
10102      getHiddenBlockTypes: () => getHiddenBlockTypes,
10103      getMetaBoxesPerLocation: () => getMetaBoxesPerLocation,
10104      getPreference: () => getPreference,
10105      getPreferences: () => getPreferences,
10106      hasMetaBoxes: () => hasMetaBoxes,
10107      isEditingTemplate: () => isEditingTemplate,
10108      isEditorPanelEnabled: () => isEditorPanelEnabled,
10109      isEditorPanelOpened: () => isEditorPanelOpened,
10110      isEditorPanelRemoved: () => isEditorPanelRemoved,
10111      isEditorSidebarOpened: () => isEditorSidebarOpened,
10112      isFeatureActive: () => isFeatureActive,
10113      isInserterOpened: () => isInserterOpened,
10114      isListViewOpened: () => isListViewOpened,
10115      isMetaBoxLocationActive: () => isMetaBoxLocationActive,
10116      isMetaBoxLocationVisible: () => isMetaBoxLocationVisible,
10117      isModalActive: () => isModalActive,
10118      isPluginItemPinned: () => isPluginItemPinned,
10119      isPluginSidebarOpened: () => isPluginSidebarOpened,
10120      isPublishSidebarOpened: () => isPublishSidebarOpened,
10121      isSavingMetaBoxes: () => isSavingMetaBoxes2
10122    });
10123    var import_data6 = __toESM(require_data(), 1);
10124    var import_preferences3 = __toESM(require_preferences(), 1);
10125    var import_core_data4 = __toESM(require_core_data(), 1);
10126    var import_editor5 = __toESM(require_editor(), 1);
10127    var import_deprecated2 = __toESM(require_deprecated(), 1);
10128    var { interfaceStore: interfaceStore2 } = unlock2(import_editor5.privateApis);
10129    var EMPTY_ARRAY2 = [];
10130    var EMPTY_OBJECT2 = {};
10131    var getEditorMode = (0, import_data6.createRegistrySelector)(
10132      (select3) => () => select3(import_preferences3.store).get("core", "editorMode") ?? "visual"
10133    );
10134    var isEditorSidebarOpened = (0, import_data6.createRegistrySelector)(
10135      (select3) => () => {
10136        const activeGeneralSidebar = select3(interfaceStore2).getActiveComplementaryArea("core");
10137        return ["edit-post/document", "edit-post/block"].includes(
10138          activeGeneralSidebar
10139        );
10140      }
10141    );
10142    var isPluginSidebarOpened = (0, import_data6.createRegistrySelector)(
10143      (select3) => () => {
10144        const activeGeneralSidebar = select3(interfaceStore2).getActiveComplementaryArea("core");
10145        return !!activeGeneralSidebar && !["edit-post/document", "edit-post/block"].includes(
10146          activeGeneralSidebar
10147        );
10148      }
10149    );
10150    var getActiveGeneralSidebarName = (0, import_data6.createRegistrySelector)(
10151      (select3) => () => {
10152        return select3(interfaceStore2).getActiveComplementaryArea("core");
10153      }
10154    );
10155    function convertPanelsToOldFormat(inactivePanels, openPanels) {
10156      const panelsWithEnabledState = inactivePanels?.reduce(
10157        (accumulatedPanels, panelName) => ({
10158          ...accumulatedPanels,
10159          [panelName]: {
10160            enabled: false
10161          }
10162        }),
10163        {}
10164      );
10165      const panels = openPanels?.reduce((accumulatedPanels, panelName) => {
10166        const currentPanelState = accumulatedPanels?.[panelName];
10167        return {
10168          ...accumulatedPanels,
10169          [panelName]: {
10170            ...currentPanelState,
10171            opened: true
10172          }
10173        };
10174      }, panelsWithEnabledState ?? {});
10175      return panels ?? panelsWithEnabledState ?? EMPTY_OBJECT2;
10176    }
10177    var getPreferences = (0, import_data6.createRegistrySelector)((select3) => () => {
10178      (0, import_deprecated2.default)(`select( 'core/edit-post' ).getPreferences`, {
10179        since: "6.0",
10180        alternative: `select( 'core/preferences' ).get`
10181      });
10182      const corePreferences = ["editorMode", "hiddenBlockTypes"].reduce(
10183        (accumulatedPrefs, preferenceKey) => {
10184          const value = select3(import_preferences3.store).get(
10185            "core",
10186            preferenceKey
10187          );
10188          return {
10189            ...accumulatedPrefs,
10190            [preferenceKey]: value
10191          };
10192        },
10193        {}
10194      );
10195      const inactivePanels = select3(import_preferences3.store).get(
10196        "core",
10197        "inactivePanels"
10198      );
10199      const openPanels = select3(import_preferences3.store).get("core", "openPanels");
10200      const panels = convertPanelsToOldFormat(inactivePanels, openPanels);
10201      return {
10202        ...corePreferences,
10203        panels
10204      };
10205    });
10206    function getPreference(state, preferenceKey, defaultValue) {
10207      (0, import_deprecated2.default)(`select( 'core/edit-post' ).getPreference`, {
10208        since: "6.0",
10209        alternative: `select( 'core/preferences' ).get`
10210      });
10211      const preferences = getPreferences(state);
10212      const value = preferences[preferenceKey];
10213      return value === void 0 ? defaultValue : value;
10214    }
10215    var getHiddenBlockTypes = (0, import_data6.createRegistrySelector)((select3) => () => {
10216      return select3(import_preferences3.store).get("core", "hiddenBlockTypes") ?? EMPTY_ARRAY2;
10217    });
10218    var isPublishSidebarOpened = (0, import_data6.createRegistrySelector)(
10219      (select3) => () => {
10220        (0, import_deprecated2.default)(`select( 'core/edit-post' ).isPublishSidebarOpened`, {
10221          since: "6.6",
10222          alternative: `select( 'core/editor' ).isPublishSidebarOpened`
10223        });
10224        return select3(import_editor5.store).isPublishSidebarOpened();
10225      }
10226    );
10227    var isEditorPanelRemoved = (0, import_data6.createRegistrySelector)(
10228      (select3) => (state, panelName) => {
10229        (0, import_deprecated2.default)(`select( 'core/edit-post' ).isEditorPanelRemoved`, {
10230          since: "6.5",
10231          alternative: `select( 'core/editor' ).isEditorPanelRemoved`
10232        });
10233        return select3(import_editor5.store).isEditorPanelRemoved(panelName);
10234      }
10235    );
10236    var isEditorPanelEnabled = (0, import_data6.createRegistrySelector)(
10237      (select3) => (state, panelName) => {
10238        (0, import_deprecated2.default)(`select( 'core/edit-post' ).isEditorPanelEnabled`, {
10239          since: "6.5",
10240          alternative: `select( 'core/editor' ).isEditorPanelEnabled`
10241        });
10242        return select3(import_editor5.store).isEditorPanelEnabled(panelName);
10243      }
10244    );
10245    var isEditorPanelOpened = (0, import_data6.createRegistrySelector)(
10246      (select3) => (state, panelName) => {
10247        (0, import_deprecated2.default)(`select( 'core/edit-post' ).isEditorPanelOpened`, {
10248          since: "6.5",
10249          alternative: `select( 'core/editor' ).isEditorPanelOpened`
10250        });
10251        return select3(import_editor5.store).isEditorPanelOpened(panelName);
10252      }
10253    );
10254    var isModalActive = (0, import_data6.createRegistrySelector)(
10255      (select3) => (state, modalName) => {
10256        (0, import_deprecated2.default)(`select( 'core/edit-post' ).isModalActive`, {
10257          since: "6.3",
10258          alternative: `select( 'core/interface' ).isModalActive`
10259        });
10260        return !!select3(interfaceStore2).isModalActive(modalName);
10261      }
10262    );
10263    var isFeatureActive = (0, import_data6.createRegistrySelector)(
10264      (select3) => (state, feature) => {
10265        return !!select3(import_preferences3.store).get("core/edit-post", feature);
10266      }
10267    );
10268    var isPluginItemPinned = (0, import_data6.createRegistrySelector)(
10269      (select3) => (state, pluginName) => {
10270        return select3(interfaceStore2).isItemPinned("core", pluginName);
10271      }
10272    );
10273    var getActiveMetaBoxLocations = (0, import_data6.createSelector)(
10274      (state) => {
10275        return Object.keys(state.metaBoxes.locations).filter(
10276          (location) => isMetaBoxLocationActive(state, location)
10277        );
10278      },
10279      (state) => [state.metaBoxes.locations]
10280    );
10281    var isMetaBoxLocationVisible = (0, import_data6.createRegistrySelector)(
10282      (select3) => (state, location) => {
10283        return isMetaBoxLocationActive(state, location) && getMetaBoxesPerLocation(state, location)?.some(({ id }) => {
10284          return select3(import_editor5.store).isEditorPanelEnabled(
10285            `meta-box-$id}`
10286          );
10287        });
10288      }
10289    );
10290    function isMetaBoxLocationActive(state, location) {
10291      const metaBoxes2 = getMetaBoxesPerLocation(state, location);
10292      return !!metaBoxes2 && metaBoxes2.length !== 0;
10293    }
10294    function getMetaBoxesPerLocation(state, location) {
10295      return state.metaBoxes.locations[location];
10296    }
10297    var getAllMetaBoxes = (0, import_data6.createSelector)(
10298      (state) => {
10299        return Object.values(state.metaBoxes.locations).flat();
10300      },
10301      (state) => [state.metaBoxes.locations]
10302    );
10303    function hasMetaBoxes(state) {
10304      return getActiveMetaBoxLocations(state).length > 0;
10305    }
10306    function isSavingMetaBoxes2(state) {
10307      return state.metaBoxes.isSaving;
10308    }
10309    var __experimentalGetPreviewDeviceType = (0, import_data6.createRegistrySelector)(
10310      (select3) => () => {
10311        (0, import_deprecated2.default)(
10312          `select( 'core/edit-site' ).__experimentalGetPreviewDeviceType`,
10313          {
10314            since: "6.5",
10315            version: "6.7",
10316            alternative: `select( 'core/editor' ).getDeviceType`
10317          }
10318        );
10319        return select3(import_editor5.store).getDeviceType();
10320      }
10321    );
10322    var isInserterOpened = (0, import_data6.createRegistrySelector)((select3) => () => {
10323      (0, import_deprecated2.default)(`select( 'core/edit-post' ).isInserterOpened`, {
10324        since: "6.5",
10325        alternative: `select( 'core/editor' ).isInserterOpened`
10326      });
10327      return select3(import_editor5.store).isInserterOpened();
10328    });
10329    var __experimentalGetInsertionPoint = (0, import_data6.createRegistrySelector)(
10330      (select3) => () => {
10331        (0, import_deprecated2.default)(
10332          `select( 'core/edit-post' ).__experimentalGetInsertionPoint`,
10333          {
10334            since: "6.5",
10335            version: "6.7"
10336          }
10337        );
10338        return unlock2(select3(import_editor5.store)).getInserter();
10339      }
10340    );
10341    var isListViewOpened = (0, import_data6.createRegistrySelector)((select3) => () => {
10342      (0, import_deprecated2.default)(`select( 'core/edit-post' ).isListViewOpened`, {
10343        since: "6.5",
10344        alternative: `select( 'core/editor' ).isListViewOpened`
10345      });
10346      return select3(import_editor5.store).isListViewOpened();
10347    });
10348    var isEditingTemplate = (0, import_data6.createRegistrySelector)((select3) => () => {
10349      (0, import_deprecated2.default)(`select( 'core/edit-post' ).isEditingTemplate`, {
10350        since: "6.5",
10351        alternative: `select( 'core/editor' ).getRenderingMode`
10352      });
10353      return select3(import_editor5.store).getCurrentPostType() === "wp_template";
10354    });
10355    function areMetaBoxesInitialized(state) {
10356      return state.metaBoxes.initialized;
10357    }
10358    var getEditedPostTemplate = (0, import_data6.createRegistrySelector)(
10359      (select3) => () => {
10360        const { id: postId, type: postType } = select3(import_editor5.store).getCurrentPost();
10361        const templateId = unlock2(select3(import_core_data4.store)).getTemplateId(
10362          postType,
10363          postId
10364        );
10365        if (!templateId) {
10366          return void 0;
10367        }
10368        return select3(import_core_data4.store).getEditedEntityRecord(
10369          "postType",
10370          "wp_template",
10371          templateId
10372        );
10373      }
10374    );
10375  
10376    // packages/edit-post/build-module/store/index.mjs
10377    var store = (0, import_data7.createReduxStore)(STORE_NAME, {
10378      reducer: reducer_default,
10379      actions: actions_exports,
10380      selectors: selectors_exports
10381    });
10382    (0, import_data7.register)(store);
10383  
10384    // packages/edit-post/build-module/components/keyboard-shortcuts/index.mjs
10385    function KeyboardShortcuts() {
10386      const { toggleFullscreenMode: toggleFullscreenMode2 } = (0, import_data8.useDispatch)(store);
10387      const { registerShortcut } = (0, import_data8.useDispatch)(import_keyboard_shortcuts.store);
10388      (0, import_element19.useEffect)(() => {
10389        registerShortcut({
10390          name: "core/edit-post/toggle-fullscreen",
10391          category: "global",
10392          description: (0, import_i18n4.__)("Enable or disable fullscreen mode."),
10393          keyCombination: {
10394            modifier: "secondary",
10395            character: "f"
10396          }
10397        });
10398      }, []);
10399      (0, import_keyboard_shortcuts.useShortcut)("core/edit-post/toggle-fullscreen", () => {
10400        toggleFullscreenMode2();
10401      });
10402      return null;
10403    }
10404    var keyboard_shortcuts_default = KeyboardShortcuts;
10405  
10406    // packages/edit-post/build-module/components/init-pattern-modal/index.mjs
10407    var import_data9 = __toESM(require_data(), 1);
10408    var import_i18n5 = __toESM(require_i18n(), 1);
10409    var import_components3 = __toESM(require_components(), 1);
10410    var import_element20 = __toESM(require_element(), 1);
10411    var import_editor6 = __toESM(require_editor(), 1);
10412    var import_jsx_runtime27 = __toESM(require_jsx_runtime(), 1);
10413    function InitPatternModal() {
10414      const { editPost } = (0, import_data9.useDispatch)(import_editor6.store);
10415      const { isCleanNewPost } = (0, import_data9.useSelect)(import_editor6.store);
10416      const [syncType, setSyncType] = (0, import_element20.useState)(void 0);
10417      const [title, setTitle] = (0, import_element20.useState)("");
10418      const [isModalOpen, setIsModalOpen] = (0, import_element20.useState)(() => isCleanNewPost());
10419      if (!isModalOpen) {
10420        return null;
10421      }
10422      return /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
10423        import_components3.Modal,
10424        {
10425          title: (0, import_i18n5.__)("Create pattern"),
10426          onRequestClose: () => {
10427            setIsModalOpen(false);
10428          },
10429          overlayClassName: "patterns-create-modal",
10430          children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
10431            "form",
10432            {
10433              onSubmit: (event) => {
10434                event.preventDefault();
10435                setIsModalOpen(false);
10436                editPost({
10437                  title,
10438                  meta: {
10439                    wp_pattern_sync_status: syncType
10440                  }
10441                });
10442              },
10443              children: /* @__PURE__ */ (0, import_jsx_runtime27.jsxs)(Stack, { direction: "column", gap: "lg", children: [
10444                /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
10445                  import_components3.TextControl,
10446                  {
10447                    label: (0, import_i18n5.__)("Name"),
10448                    value: title,
10449                    onChange: setTitle,
10450                    placeholder: (0, import_i18n5.__)("My pattern"),
10451                    className: "patterns-create-modal__name-input"
10452                  }
10453                ),
10454                /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
10455                  import_components3.ToggleControl,
10456                  {
10457                    label: (0, import_i18n5._x)("Synced", "pattern (singular)"),
10458                    help: (0, import_i18n5.__)(
10459                      "Sync this pattern across multiple locations."
10460                    ),
10461                    checked: !syncType,
10462                    onChange: () => {
10463                      setSyncType(!syncType ? "unsynced" : void 0);
10464                    }
10465                  }
10466                ),
10467                /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(Stack, { justify: "end", children: /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(
10468                  import_components3.Button,
10469                  {
10470                    __next40pxDefaultSize: true,
10471                    variant: "primary",
10472                    type: "submit",
10473                    disabled: !title,
10474                    accessibleWhenDisabled: true,
10475                    children: (0, import_i18n5.__)("Create")
10476                  }
10477                ) })
10478              ] })
10479            }
10480          )
10481        }
10482      );
10483    }
10484  
10485    // packages/edit-post/build-module/components/browser-url/index.mjs
10486    var import_element22 = __toESM(require_element(), 1);
10487    var import_data11 = __toESM(require_data(), 1);
10488    var import_url3 = __toESM(require_url(), 1);
10489    var import_editor8 = __toESM(require_editor(), 1);
10490  
10491    // packages/edit-post/build-module/components/browser-url/use-classic-revision-redirect.mjs
10492    var import_data10 = __toESM(require_data(), 1);
10493    var import_core_data5 = __toESM(require_core_data(), 1);
10494    var import_editor7 = __toESM(require_editor(), 1);
10495    var import_element21 = __toESM(require_element(), 1);
10496    var import_url2 = __toESM(require_url(), 1);
10497    function useClassicRevisionRedirect() {
10498      const registry = (0, import_data10.useRegistry)();
10499      const { disableVisualRevisions, currentRevisionId, postType, postId } = (0, import_data10.useSelect)((select3) => {
10500        const editor = select3(import_editor7.store);
10501        return {
10502          disableVisualRevisions: !!editor.getEditorSettings().disableVisualRevisions,
10503          currentRevisionId: unlock2(editor).getCurrentRevisionId(),
10504          postType: editor.getCurrentPostType(),
10505          postId: editor.getCurrentPostId()
10506        };
10507      }, []);
10508      const hasClassicRevisionScreen = ![
10509        "wp_template",
10510        "wp_template_part"
10511      ].includes(postType);
10512      (0, import_element21.useEffect)(() => {
10513        if (!disableVisualRevisions || !hasClassicRevisionScreen || !currentRevisionId || !postType || !postId) {
10514          return;
10515        }
10516        let cancelled = false;
10517        registry.resolveSelect(import_core_data5.store).getRevision("postType", postType, postId, currentRevisionId, {
10518          context: "edit",
10519          _fields: "id"
10520        }).then((revision) => {
10521          if (cancelled || !revision) {
10522            return;
10523          }
10524          const editor = registry.select(import_editor7.store);
10525          const isStillSelected = !!editor.getEditorSettings().disableVisualRevisions && editor.getCurrentPostType() === postType && String(editor.getCurrentPostId()) === String(postId) && unlock2(editor).getCurrentRevisionId() === currentRevisionId;
10526          if (!isStillSelected) {
10527            return;
10528          }
10529          window.location.replace(
10530            (0, import_url2.addQueryArgs)("revision.php", {
10531              revision: currentRevisionId
10532            })
10533          );
10534        });
10535        return () => {
10536          cancelled = true;
10537        };
10538      }, [
10539        disableVisualRevisions,
10540        hasClassicRevisionScreen,
10541        currentRevisionId,
10542        postType,
10543        postId,
10544        registry
10545      ]);
10546    }
10547  
10548    // packages/edit-post/build-module/components/browser-url/index.mjs
10549    var URL_WRITE_DEBOUNCE_MS = 300;
10550    function getPostEditURL(postId, revisionId) {
10551      const args = { post: postId, action: "edit" };
10552      if (revisionId) {
10553        args.revision = revisionId;
10554      }
10555      return (0, import_url3.addQueryArgs)("post.php", args);
10556    }
10557    function BrowserURL() {
10558      useClassicRevisionRedirect();
10559      const [initialRevisionId] = (0, import_element22.useState)(() => {
10560        const revision = Number(
10561          (0, import_url3.getQueryArg)(window.location.href, "revision")
10562        );
10563        return Number.isInteger(revision) && revision > 0 ? revision : null;
10564      });
10565      const hasHandledInitialRevisionRef = (0, import_element22.useRef)(false);
10566      const { postId, postStatus, currentRevisionId } = (0, import_data11.useSelect)((select3) => {
10567        const { getCurrentPost } = select3(import_editor8.store);
10568        const { getCurrentRevisionId } = unlock2(select3(import_editor8.store));
10569        const post = getCurrentPost();
10570        let { id, status, type } = post;
10571        const isTemplate = ["wp_template", "wp_template_part"].includes(
10572          type
10573        );
10574        if (isTemplate) {
10575          id = post.wp_id;
10576        }
10577        return {
10578          postId: id,
10579          postStatus: status,
10580          // `post.php` rejects templates because `show_ui` is false. Adding
10581          // their revision ID to this URL would create a dead link.
10582          currentRevisionId: isTemplate ? null : getCurrentRevisionId()
10583        };
10584      }, []);
10585      const { openRevision } = unlock2((0, import_data11.useDispatch)(import_editor8.store));
10586      const lastURLWriteTimeRef = (0, import_element22.useRef)(null);
10587      const lastPostIdRef = (0, import_element22.useRef)(null);
10588      (0, import_element22.useEffect)(() => {
10589        if (!postId) {
10590          return;
10591        }
10592        if (initialRevisionId && !hasHandledInitialRevisionRef.current) {
10593          hasHandledInitialRevisionRef.current = true;
10594          openRevision(initialRevisionId);
10595          return;
10596        }
10597        if (postStatus === "auto-draft") {
10598          return;
10599        }
10600        const previousPostId = lastPostIdRef.current;
10601        lastPostIdRef.current = postId;
10602        const url = getPostEditURL(postId, currentRevisionId);
10603        const write = () => {
10604          lastURLWriteTimeRef.current = Date.now();
10605          try {
10606            window.history.replaceState(
10607              { id: postId },
10608              "Post " + postId,
10609              url
10610            );
10611          } catch {
10612          }
10613        };
10614        if (previousPostId !== null && previousPostId !== postId) {
10615          write();
10616          return;
10617        }
10618        if (lastURLWriteTimeRef.current === null) {
10619          write();
10620          return;
10621        }
10622        if (Date.now() - lastURLWriteTimeRef.current >= URL_WRITE_DEBOUNCE_MS) {
10623          write();
10624          return;
10625        }
10626        const timeoutId = setTimeout(write, URL_WRITE_DEBOUNCE_MS);
10627        return () => clearTimeout(timeoutId);
10628      }, [
10629        postId,
10630        postStatus,
10631        currentRevisionId,
10632        initialRevisionId,
10633        openRevision
10634      ]);
10635      return null;
10636    }
10637  
10638    // packages/edit-post/build-module/components/meta-boxes/index.mjs
10639    var import_data14 = __toESM(require_data(), 1);
10640  
10641    // packages/edit-post/build-module/components/meta-boxes/meta-boxes-area/index.mjs
10642    var import_element23 = __toESM(require_element(), 1);
10643    var import_components4 = __toESM(require_components(), 1);
10644    var import_data12 = __toESM(require_data(), 1);
10645    var import_block_editor = __toESM(require_block_editor(), 1);
10646    var import_jsx_runtime28 = __toESM(require_jsx_runtime(), 1);
10647    var { useNativeUndo } = unlock2(import_block_editor.privateApis);
10648    function move(parent, node) {
10649      if (parent.moveBefore && parent.isConnected && node.isConnected) {
10650        parent.moveBefore(node, null);
10651      } else {
10652        parent.appendChild(node);
10653      }
10654    }
10655    function MetaBoxesArea({ location }) {
10656      const container = (0, import_element23.useRef)(null);
10657      const formRef = (0, import_element23.useRef)(null);
10658      (0, import_element23.useLayoutEffect)(() => {
10659        formRef.current = document.querySelector(
10660          ".metabox-location-" + location
10661        );
10662        if (formRef.current) {
10663          move(container.current, formRef.current);
10664        }
10665        return () => {
10666          if (formRef.current) {
10667            move(document.querySelector("#metaboxes"), formRef.current);
10668          }
10669        };
10670      }, [location]);
10671      const isSaving = (0, import_data12.useSelect)((select3) => {
10672        return select3(store).isSavingMetaBoxes();
10673      }, []);
10674      const classes = clsx_default("edit-post-meta-boxes-area", `is-$location}`, {
10675        "is-loading": isSaving
10676      });
10677      const nativeUndoRef = useNativeUndo();
10678      return /* @__PURE__ */ (0, import_jsx_runtime28.jsxs)("div", { className: classes, ref: nativeUndoRef, children: [
10679        isSaving && /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(import_components4.Spinner, { className: "edit-post-meta-boxes-area__spinner" }),
10680        /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(
10681          "div",
10682          {
10683            className: "edit-post-meta-boxes-area__container",
10684            ref: container
10685          }
10686        ),
10687        /* @__PURE__ */ (0, import_jsx_runtime28.jsx)("div", { className: "edit-post-meta-boxes-area__clear" })
10688      ] });
10689    }
10690    var meta_boxes_area_default = MetaBoxesArea;
10691  
10692    // packages/edit-post/build-module/components/meta-boxes/meta-box-visibility.mjs
10693    var import_element24 = __toESM(require_element(), 1);
10694    var import_data13 = __toESM(require_data(), 1);
10695    var import_editor9 = __toESM(require_editor(), 1);
10696    function MetaBoxVisibility({ id }) {
10697      const isVisible = (0, import_data13.useSelect)(
10698        (select3) => {
10699          return select3(import_editor9.store).isEditorPanelEnabled(
10700            `meta-box-$id}`
10701          );
10702        },
10703        [id]
10704      );
10705      (0, import_element24.useEffect)(() => {
10706        const element = document.getElementById(id);
10707        if (!element) {
10708          return;
10709        }
10710        if (isVisible) {
10711          element.classList.remove("is-hidden");
10712        } else {
10713          element.classList.add("is-hidden");
10714        }
10715      }, [id, isVisible]);
10716      return null;
10717    }
10718  
10719    // packages/edit-post/build-module/components/meta-boxes/index.mjs
10720    var import_jsx_runtime29 = __toESM(require_jsx_runtime(), 1);
10721    function MetaBoxes({ location }) {
10722      const metaBoxes2 = (0, import_data14.useSelect)(
10723        (select3) => select3(store).getMetaBoxesPerLocation(location),
10724        [location]
10725      );
10726      return /* @__PURE__ */ (0, import_jsx_runtime29.jsxs)(import_jsx_runtime29.Fragment, { children: [
10727        (metaBoxes2 ?? []).map(({ id }) => /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(MetaBoxVisibility, { id }, id)),
10728        /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(meta_boxes_area_default, { location })
10729      ] });
10730    }
10731  
10732    // packages/edit-post/build-module/components/more-menu/index.mjs
10733    var import_i18n11 = __toESM(require_i18n(), 1);
10734    var import_compose = __toESM(require_compose(), 1);
10735    var import_editor16 = __toESM(require_editor(), 1);
10736    var import_keycodes = __toESM(require_keycodes(), 1);
10737  
10738    // packages/edit-post/build-module/components/more-menu/manage-patterns-menu-item.mjs
10739    var import_core_data6 = __toESM(require_core_data(), 1);
10740    var import_data15 = __toESM(require_data(), 1);
10741    var import_editor10 = __toESM(require_editor(), 1);
10742    var import_i18n6 = __toESM(require_i18n(), 1);
10743    var import_url4 = __toESM(require_url(), 1);
10744    var import_jsx_runtime30 = __toESM(require_jsx_runtime(), 1);
10745    var { MoreMenuItem } = unlock2(import_editor10.privateApis);
10746    function ManagePatternsMenuItem() {
10747      const url = (0, import_data15.useSelect)((select3) => {
10748        const { canUser } = select3(import_core_data6.store);
10749        const defaultUrl = (0, import_url4.addQueryArgs)("edit.php", {
10750          post_type: "wp_block"
10751        });
10752        const patternsUrl = (0, import_url4.addQueryArgs)("site-editor.php", {
10753          p: "/pattern"
10754        });
10755        return canUser("create", {
10756          kind: "postType",
10757          name: "wp_template"
10758        }) ? patternsUrl : defaultUrl;
10759      }, []);
10760      return /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(MoreMenuItem, { href: url, children: (0, import_i18n6.__)("Manage patterns") });
10761    }
10762    var manage_patterns_menu_item_default = ManagePatternsMenuItem;
10763  
10764    // packages/edit-post/build-module/components/more-menu/welcome-guide-menu-item.mjs
10765    var import_i18n7 = __toESM(require_i18n(), 1);
10766    var import_data16 = __toESM(require_data(), 1);
10767    var import_editor11 = __toESM(require_editor(), 1);
10768    var import_preferences4 = __toESM(require_preferences(), 1);
10769    var import_jsx_runtime31 = __toESM(require_jsx_runtime(), 1);
10770    var { MoreMenuItem: MoreMenuItem2 } = unlock2(import_editor11.privateApis);
10771    function WelcomeGuideMenuItem() {
10772      const isEditingTemplate2 = (0, import_data16.useSelect)(
10773        (select3) => select3(import_editor11.store).getCurrentPostType() === "wp_template",
10774        []
10775      );
10776      const { toggle } = (0, import_data16.useDispatch)(import_preferences4.store);
10777      return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(
10778        MoreMenuItem2,
10779        {
10780          onClick: () => toggle(
10781            "core/edit-post",
10782            isEditingTemplate2 ? "welcomeGuideTemplate" : "welcomeGuide"
10783          ),
10784          children: (0, import_i18n7.__)("Welcome Guide")
10785        }
10786      );
10787    }
10788  
10789    // packages/edit-post/build-module/components/preferences-modal/index.mjs
10790    var import_i18n10 = __toESM(require_i18n(), 1);
10791    var import_preferences8 = __toESM(require_preferences(), 1);
10792    var import_editor15 = __toESM(require_editor(), 1);
10793  
10794    // packages/edit-post/build-module/components/preferences-modal/meta-boxes-section.mjs
10795    var import_i18n9 = __toESM(require_i18n(), 1);
10796    var import_data19 = __toESM(require_data(), 1);
10797    var import_editor14 = __toESM(require_editor(), 1);
10798    var import_preferences7 = __toESM(require_preferences(), 1);
10799  
10800    // packages/edit-post/build-module/components/preferences-modal/enable-custom-fields.mjs
10801    var import_element25 = __toESM(require_element(), 1);
10802    var import_i18n8 = __toESM(require_i18n(), 1);
10803    var import_components5 = __toESM(require_components(), 1);
10804    var import_data17 = __toESM(require_data(), 1);
10805    var import_editor12 = __toESM(require_editor(), 1);
10806    var import_preferences5 = __toESM(require_preferences(), 1);
10807    var import_url5 = __toESM(require_url(), 1);
10808    var import_jsx_runtime32 = __toESM(require_jsx_runtime(), 1);
10809    var { PreferenceBaseOption } = unlock2(import_preferences5.privateApis);
10810    function submitCustomFieldsForm() {
10811      const customFieldsForm = document.getElementById(
10812        "toggle-custom-fields-form"
10813      );
10814      customFieldsForm.querySelector('[name="_wp_http_referer"]').setAttribute("value", (0, import_url5.getPathAndQueryString)(window.location.href));
10815      customFieldsForm.submit();
10816    }
10817    function CustomFieldsConfirmation({ willEnable }) {
10818      const [isReloading, setIsReloading] = (0, import_element25.useState)(false);
10819      return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)(import_jsx_runtime32.Fragment, { children: [
10820        /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("p", { className: "edit-post-preferences-modal__custom-fields-confirmation-message", children: (0, import_i18n8.__)(
10821          "A page reload is required for this change. Make sure your content is saved before reloading."
10822        ) }),
10823        /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
10824          import_components5.Button,
10825          {
10826            __next40pxDefaultSize: true,
10827            variant: "secondary",
10828            isBusy: isReloading,
10829            accessibleWhenDisabled: true,
10830            disabled: isReloading,
10831            onClick: () => {
10832              setIsReloading(true);
10833              submitCustomFieldsForm();
10834            },
10835            children: willEnable ? (0, import_i18n8.__)("Show & Reload Page") : (0, import_i18n8.__)("Hide & Reload Page")
10836          }
10837        )
10838      ] });
10839    }
10840    function EnableCustomFieldsOption({ label }) {
10841      const areCustomFieldsEnabled = (0, import_data17.useSelect)((select3) => {
10842        return !!select3(import_editor12.store).getEditorSettings().enableCustomFields;
10843      }, []);
10844      const [isChecked, setIsChecked] = (0, import_element25.useState)(areCustomFieldsEnabled);
10845      return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(
10846        PreferenceBaseOption,
10847        {
10848          label,
10849          isChecked,
10850          onChange: setIsChecked,
10851          children: isChecked !== areCustomFieldsEnabled && /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(CustomFieldsConfirmation, { willEnable: isChecked })
10852        }
10853      );
10854    }
10855  
10856    // packages/edit-post/build-module/components/preferences-modal/enable-panel.mjs
10857    var import_data18 = __toESM(require_data(), 1);
10858    var import_editor13 = __toESM(require_editor(), 1);
10859    var import_preferences6 = __toESM(require_preferences(), 1);
10860    var import_jsx_runtime33 = __toESM(require_jsx_runtime(), 1);
10861    var { PreferenceBaseOption: PreferenceBaseOption2 } = unlock2(import_preferences6.privateApis);
10862    function EnablePanelOption(props) {
10863      const { toggleEditorPanelEnabled: toggleEditorPanelEnabled2 } = (0, import_data18.useDispatch)(import_editor13.store);
10864      const { isChecked, isRemoved } = (0, import_data18.useSelect)(
10865        (select3) => {
10866          const { isEditorPanelEnabled: isEditorPanelEnabled2, isEditorPanelRemoved: isEditorPanelRemoved2 } = select3(import_editor13.store);
10867          return {
10868            isChecked: isEditorPanelEnabled2(props.panelName),
10869            isRemoved: isEditorPanelRemoved2(props.panelName)
10870          };
10871        },
10872        [props.panelName]
10873      );
10874      if (isRemoved) {
10875        return null;
10876      }
10877      return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(
10878        PreferenceBaseOption2,
10879        {
10880          isChecked,
10881          onChange: () => toggleEditorPanelEnabled2(props.panelName),
10882          ...props
10883        }
10884      );
10885    }
10886  
10887    // packages/edit-post/build-module/components/preferences-modal/meta-boxes-section.mjs
10888    var import_jsx_runtime34 = __toESM(require_jsx_runtime(), 1);
10889    var { PreferencesModalSection } = unlock2(import_preferences7.privateApis);
10890    function MetaBoxesSection(sectionProps) {
10891      const { areCustomFieldsRegistered, metaBoxes: metaBoxes2 } = (0, import_data19.useSelect)((select3) => {
10892        const { getEditorSettings } = select3(import_editor14.store);
10893        const { getAllMetaBoxes: getAllMetaBoxes2 } = select3(store);
10894        return {
10895          areCustomFieldsRegistered: getEditorSettings().enableCustomFields !== void 0,
10896          metaBoxes: getAllMetaBoxes2()
10897        };
10898      }, []);
10899      const thirdPartyMetaBoxes = metaBoxes2.filter(
10900        ({ id }) => id !== "postcustom"
10901      );
10902      if (!areCustomFieldsRegistered && thirdPartyMetaBoxes.length === 0) {
10903        return null;
10904      }
10905      return /* @__PURE__ */ (0, import_jsx_runtime34.jsxs)(PreferencesModalSection, { ...sectionProps, children: [
10906        areCustomFieldsRegistered && /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(EnableCustomFieldsOption, { label: (0, import_i18n9.__)("Custom fields") }),
10907        thirdPartyMetaBoxes.map(({ id, title }) => /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(
10908          EnablePanelOption,
10909          {
10910            label: title,
10911            panelName: `meta-box-$id}`
10912          },
10913          id
10914        ))
10915      ] });
10916    }
10917  
10918    // packages/edit-post/build-module/components/preferences-modal/index.mjs
10919    var import_jsx_runtime35 = __toESM(require_jsx_runtime(), 1);
10920    var { PreferenceToggleControl } = unlock2(import_preferences8.privateApis);
10921    var { PreferencesModal } = unlock2(import_editor15.privateApis);
10922    function EditPostPreferencesModal() {
10923      const extraSections = {
10924        general: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(MetaBoxesSection, { title: (0, import_i18n10.__)("Advanced") }),
10925        appearance: /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(
10926          PreferenceToggleControl,
10927          {
10928            scope: "core/edit-post",
10929            featureName: "themeStyles",
10930            help: (0, import_i18n10.__)("Make the editor look like your theme."),
10931            label: (0, import_i18n10.__)("Use theme styles")
10932          }
10933        )
10934      };
10935      return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(PreferencesModal, { extraSections });
10936    }
10937  
10938    // packages/edit-post/build-module/components/more-menu/index.mjs
10939    var import_jsx_runtime36 = __toESM(require_jsx_runtime(), 1);
10940    var { MoreMenuPreferenceItem, ToolsMoreMenuGroup, ViewMoreMenuGroup } = unlock2(import_editor16.privateApis);
10941    var FULLSCREEN_SHORTCUT = {
10942      ariaKeyShortcut: import_keycodes.ariaKeyShortcut.secondary("f"),
10943      displayShortcut: import_keycodes.displayShortcut.secondary("f"),
10944      label: import_keycodes.shortcutAriaLabel.secondary("f")
10945    };
10946    var MoreMenu = () => {
10947      const isLargeViewport = (0, import_compose.useViewportMatch)("large");
10948      return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(import_jsx_runtime36.Fragment, { children: [
10949        isLargeViewport && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(ViewMoreMenuGroup, { children: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
10950          MoreMenuPreferenceItem,
10951          {
10952            scope: "core/edit-post",
10953            name: "fullscreenMode",
10954            label: (0, import_i18n11.__)("Fullscreen mode"),
10955            info: (0, import_i18n11.__)("Show and hide the admin user interface"),
10956            messageActivated: (0, import_i18n11.__)("Fullscreen mode activated."),
10957            messageDeactivated: (0, import_i18n11.__)(
10958              "Fullscreen mode deactivated."
10959            ),
10960            shortcut: FULLSCREEN_SHORTCUT
10961          }
10962        ) }),
10963        /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(ToolsMoreMenuGroup, { children: [
10964          /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(manage_patterns_menu_item_default, {}),
10965          /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(WelcomeGuideMenuItem, {})
10966        ] }),
10967        /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(EditPostPreferencesModal, {})
10968      ] });
10969    };
10970    var more_menu_default = MoreMenu;
10971  
10972    // packages/edit-post/build-module/components/welcome-guide/index.mjs
10973    var import_data22 = __toESM(require_data(), 1);
10974  
10975    // packages/edit-post/build-module/components/welcome-guide/default.mjs
10976    var import_data20 = __toESM(require_data(), 1);
10977    var import_components6 = __toESM(require_components(), 1);
10978    var import_i18n12 = __toESM(require_i18n(), 1);
10979    var import_element26 = __toESM(require_element(), 1);
10980  
10981    // packages/edit-post/build-module/components/welcome-guide/image.mjs
10982    var import_jsx_runtime37 = __toESM(require_jsx_runtime(), 1);
10983    function WelcomeGuideImage({ nonAnimatedSrc, animatedSrc }) {
10984      return /* @__PURE__ */ (0, import_jsx_runtime37.jsxs)("picture", { className: "edit-post-welcome-guide__image", children: [
10985        /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(
10986          "source",
10987          {
10988            srcSet: nonAnimatedSrc,
10989            media: "(prefers-reduced-motion: reduce)"
10990          }
10991        ),
10992        /* @__PURE__ */ (0, import_jsx_runtime37.jsx)("img", { src: animatedSrc, width: "312", height: "240", alt: "" })
10993      ] });
10994    }
10995  
10996    // packages/edit-post/build-module/components/welcome-guide/default.mjs
10997    var import_jsx_runtime38 = __toESM(require_jsx_runtime(), 1);
10998    function WelcomeGuideDefault() {
10999      const { toggleFeature: toggleFeature2 } = (0, import_data20.useDispatch)(store);
11000      return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
11001        import_components6.Guide,
11002        {
11003          className: "edit-post-welcome-guide",
11004          contentLabel: (0, import_i18n12.__)("Welcome to the editor"),
11005          finishButtonText: (0, import_i18n12.__)("Get started"),
11006          onFinish: () => toggleFeature2("welcomeGuide"),
11007          pages: [
11008            {
11009              image: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
11010                WelcomeGuideImage,
11011                {
11012                  nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-canvas.svg",
11013                  animatedSrc: "https://s.w.org/images/block-editor/welcome-canvas.gif"
11014                }
11015              ),
11016              content: /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(import_jsx_runtime38.Fragment, { children: [
11017                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("h1", { className: "edit-post-welcome-guide__heading", children: (0, import_i18n12.__)("Welcome to the editor") }),
11018                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("p", { className: "edit-post-welcome-guide__text", children: (0, import_i18n12.__)(
11019                  "In the WordPress editor, each paragraph, image, or video is presented as a distinct \u201Cblock\u201D of content."
11020                ) })
11021              ] })
11022            },
11023            {
11024              image: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
11025                WelcomeGuideImage,
11026                {
11027                  nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-editor.svg",
11028                  animatedSrc: "https://s.w.org/images/block-editor/welcome-editor.gif"
11029                }
11030              ),
11031              content: /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(import_jsx_runtime38.Fragment, { children: [
11032                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("h1", { className: "edit-post-welcome-guide__heading", children: (0, import_i18n12.__)("Customize each block") }),
11033                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("p", { className: "edit-post-welcome-guide__text", children: (0, import_i18n12.__)(
11034                  "Each block comes with its own set of controls for changing things like color, width, and alignment. These will show and hide automatically when you have a block selected."
11035                ) })
11036              ] })
11037            },
11038            {
11039              image: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
11040                WelcomeGuideImage,
11041                {
11042                  nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-library.svg",
11043                  animatedSrc: "https://s.w.org/images/block-editor/welcome-library.gif"
11044                }
11045              ),
11046              content: /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(import_jsx_runtime38.Fragment, { children: [
11047                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("h1", { className: "edit-post-welcome-guide__heading", children: (0, import_i18n12.__)("Explore all blocks") }),
11048                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("p", { className: "edit-post-welcome-guide__text", children: (0, import_element26.createInterpolateElement)(
11049                  (0, import_i18n12.__)(
11050                    "All of the blocks available to you live in the block library. You\u2019ll find it wherever you see the <InserterIconImage /> icon."
11051                  ),
11052                  {
11053                    InserterIconImage: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
11054                      "img",
11055                      {
11056                        alt: (0, import_i18n12.__)("inserter"),
11057                        src: "data:image/svg+xml,%3Csvg width='18' height='18' viewBox='0 0 18 18' fill='none' xmlns='http://www.w3.org/2000/svg'%3E%3Crect width='18' height='18' rx='2' fill='%231E1E1E'/%3E%3Cpath d='M9.22727 4V14M4 8.77273H14' stroke='white' stroke-width='1.5'/%3E%3C/svg%3E%0A"
11058                      }
11059                    )
11060                  }
11061                ) })
11062              ] })
11063            },
11064            {
11065              image: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
11066                WelcomeGuideImage,
11067                {
11068                  nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-documentation.svg",
11069                  animatedSrc: "https://s.w.org/images/block-editor/welcome-documentation.gif"
11070                }
11071              ),
11072              content: /* @__PURE__ */ (0, import_jsx_runtime38.jsxs)(import_jsx_runtime38.Fragment, { children: [
11073                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("h1", { className: "edit-post-welcome-guide__heading", children: (0, import_i18n12.__)("Learn more") }),
11074                /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("p", { className: "edit-post-welcome-guide__text", children: (0, import_element26.createInterpolateElement)(
11075                  (0, import_i18n12.__)(
11076                    "New to the block editor? Want to learn more about using it? <a>Here's a detailed guide.</a>"
11077                  ),
11078                  {
11079                    a: /* @__PURE__ */ (0, import_jsx_runtime38.jsx)(
11080                      import_components6.ExternalLink,
11081                      {
11082                        href: (0, import_i18n12.__)(
11083                          "https://wordpress.org/documentation/article/wordpress-block-editor/"
11084                        )
11085                      }
11086                    )
11087                  }
11088                ) })
11089              ] })
11090            }
11091          ]
11092        }
11093      );
11094    }
11095  
11096    // packages/edit-post/build-module/components/welcome-guide/template.mjs
11097    var import_data21 = __toESM(require_data(), 1);
11098    var import_components7 = __toESM(require_components(), 1);
11099    var import_i18n13 = __toESM(require_i18n(), 1);
11100    var import_jsx_runtime39 = __toESM(require_jsx_runtime(), 1);
11101    function WelcomeGuideTemplate() {
11102      const { toggleFeature: toggleFeature2 } = (0, import_data21.useDispatch)(store);
11103      return /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
11104        import_components7.Guide,
11105        {
11106          className: "edit-template-welcome-guide",
11107          contentLabel: (0, import_i18n13.__)("Welcome to the template editor"),
11108          finishButtonText: (0, import_i18n13.__)("Get started"),
11109          onFinish: () => toggleFeature2("welcomeGuideTemplate"),
11110          pages: [
11111            {
11112              image: /* @__PURE__ */ (0, import_jsx_runtime39.jsx)(
11113                WelcomeGuideImage,
11114                {
11115                  nonAnimatedSrc: "https://s.w.org/images/block-editor/welcome-template-editor.svg",
11116                  animatedSrc: "https://s.w.org/images/block-editor/welcome-template-editor.gif"
11117                }
11118              ),
11119              content: /* @__PURE__ */ (0, import_jsx_runtime39.jsxs)(import_jsx_runtime39.Fragment, { children: [
11120                /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("h1", { className: "edit-post-welcome-guide__heading", children: (0, import_i18n13.__)("Welcome to the template editor") }),
11121                /* @__PURE__ */ (0, import_jsx_runtime39.jsx)("p", { className: "edit-post-welcome-guide__text", children: (0, import_i18n13.__)(
11122                  "Templates help define the layout of the site. You can customize all aspects of your posts and pages using blocks and patterns in this editor."
11123                ) })
11124              ] })
11125            }
11126          ]
11127        }
11128      );
11129    }
11130  
11131    // packages/edit-post/build-module/components/welcome-guide/index.mjs
11132    var import_jsx_runtime40 = __toESM(require_jsx_runtime(), 1);
11133    function WelcomeGuide({ postType }) {
11134      const { isActive, isEditingTemplate: isEditingTemplate2 } = (0, import_data22.useSelect)(
11135        (select3) => {
11136          const { isFeatureActive: isFeatureActive2 } = select3(store);
11137          const _isEditingTemplate = postType === "wp_template";
11138          const feature = _isEditingTemplate ? "welcomeGuideTemplate" : "welcomeGuide";
11139          return {
11140            isActive: isFeatureActive2(feature),
11141            isEditingTemplate: _isEditingTemplate
11142          };
11143        },
11144        [postType]
11145      );
11146      if (!isActive) {
11147        return null;
11148      }
11149      return isEditingTemplate2 ? /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(WelcomeGuideTemplate, {}) : /* @__PURE__ */ (0, import_jsx_runtime40.jsx)(WelcomeGuideDefault, {});
11150    }
11151  
11152    // packages/edit-post/build-module/commands/use-commands.mjs
11153    var import_data23 = __toESM(require_data(), 1);
11154    var import_i18n14 = __toESM(require_i18n(), 1);
11155    var import_commands = __toESM(require_commands(), 1);
11156    var import_preferences9 = __toESM(require_preferences(), 1);
11157    var import_notices2 = __toESM(require_notices(), 1);
11158    function useCommands() {
11159      const { isFullscreen } = (0, import_data23.useSelect)((select3) => {
11160        const { get } = select3(import_preferences9.store);
11161        return {
11162          isFullscreen: get("core/edit-post", "fullscreenMode")
11163        };
11164      }, []);
11165      const { toggle } = (0, import_data23.useDispatch)(import_preferences9.store);
11166      const { createInfoNotice } = (0, import_data23.useDispatch)(import_notices2.store);
11167      (0, import_commands.useCommand)({
11168        name: "core/toggle-fullscreen-mode",
11169        label: isFullscreen ? (0, import_i18n14.__)("Exit fullscreen") : (0, import_i18n14.__)("Enter fullscreen"),
11170        icon: fullscreen_default,
11171        category: "command",
11172        callback: ({ close }) => {
11173          toggle("core/edit-post", "fullscreenMode");
11174          close();
11175          createInfoNotice(
11176            isFullscreen ? (0, import_i18n14.__)("Fullscreen off.") : (0, import_i18n14.__)("Fullscreen on."),
11177            {
11178              id: "core/edit-post/toggle-fullscreen-mode/notice",
11179              type: "snackbar",
11180              actions: [
11181                {
11182                  label: (0, import_i18n14.__)("Undo"),
11183                  onClick: () => {
11184                    toggle("core/edit-post", "fullscreenMode");
11185                  }
11186                }
11187              ]
11188            }
11189          );
11190        }
11191      });
11192    }
11193  
11194    // packages/edit-post/build-module/hooks/use-navigate-to-entity-record.mjs
11195    var import_element27 = __toESM(require_element(), 1);
11196    var import_data24 = __toESM(require_data(), 1);
11197    var import_editor17 = __toESM(require_editor(), 1);
11198    var import_core_data7 = __toESM(require_core_data(), 1);
11199    function useNavigateToEntityRecord(initialPostId, initialPostType, defaultRenderingMode) {
11200      const registry = (0, import_data24.useRegistry)();
11201      const [postHistory, dispatch2] = (0, import_element27.useReducer)(
11202        (historyState, { type, post: post2, previousRenderingMode: previousRenderingMode2, selectedBlockClientId }) => {
11203          if (type === "push") {
11204            const updatedHistory = [...historyState];
11205            const currentIndex = updatedHistory.length - 1;
11206            updatedHistory[currentIndex] = {
11207              ...updatedHistory[currentIndex],
11208              selectedBlockClientId
11209            };
11210            return [...updatedHistory, { post: post2, previousRenderingMode: previousRenderingMode2 }];
11211          }
11212          if (type === "pop") {
11213            if (historyState.length > 1) {
11214              return historyState.slice(0, -1);
11215            }
11216          }
11217          return historyState;
11218        },
11219        [
11220          {
11221            post: { postId: initialPostId, postType: initialPostType }
11222          }
11223        ]
11224      );
11225      const { post, previousRenderingMode } = postHistory[postHistory.length - 1];
11226      const { getRenderingMode } = (0, import_data24.useSelect)(import_editor17.store);
11227      const { setRenderingMode } = (0, import_data24.useDispatch)(import_editor17.store);
11228      const { editEntityRecord } = (0, import_data24.useDispatch)(import_core_data7.store);
11229      const onNavigateToEntityRecord = (0, import_element27.useCallback)(
11230        (params) => {
11231          const entityEdits = registry.select(import_core_data7.store).getEntityRecordEdits("postType", post.postType, post.postId);
11232          const externalClientId = entityEdits?.selection?.selectionStart?.clientId ?? null;
11233          dispatch2({
11234            type: "push",
11235            post: { postId: params.postId, postType: params.postType },
11236            // Save the current rendering mode so we can restore it when navigating back.
11237            previousRenderingMode: getRenderingMode(),
11238            selectedBlockClientId: externalClientId
11239          });
11240          setRenderingMode(defaultRenderingMode);
11241        },
11242        [
11243          registry,
11244          post.postType,
11245          post.postId,
11246          getRenderingMode,
11247          setRenderingMode,
11248          defaultRenderingMode
11249        ]
11250      );
11251      const onNavigateToPreviousEntityRecord = (0, import_element27.useCallback)(() => {
11252        if (postHistory.length > 1) {
11253          const previousItem = postHistory[postHistory.length - 2];
11254          if (previousItem.selectedBlockClientId) {
11255            editEntityRecord(
11256              "postType",
11257              previousItem.post.postType,
11258              previousItem.post.postId,
11259              {
11260                selection: {
11261                  selectionStart: {
11262                    clientId: previousItem.selectedBlockClientId
11263                  },
11264                  selectionEnd: {
11265                    clientId: previousItem.selectedBlockClientId
11266                  }
11267                }
11268              },
11269              { undoIgnore: true }
11270            );
11271          }
11272        }
11273        dispatch2({
11274          type: "pop"
11275        });
11276        if (previousRenderingMode) {
11277          setRenderingMode(previousRenderingMode);
11278        }
11279      }, [
11280        setRenderingMode,
11281        previousRenderingMode,
11282        postHistory,
11283        editEntityRecord
11284      ]);
11285      return {
11286        currentPost: post,
11287        onNavigateToEntityRecord,
11288        onNavigateToPreviousEntityRecord: postHistory.length > 1 ? onNavigateToPreviousEntityRecord : void 0
11289      };
11290    }
11291  
11292    // packages/edit-post/build-module/components/meta-boxes/use-meta-box-initialization.mjs
11293    var import_data25 = __toESM(require_data(), 1);
11294    var import_editor18 = __toESM(require_editor(), 1);
11295    var import_core_data8 = __toESM(require_core_data(), 1);
11296    var import_element28 = __toESM(require_element(), 1);
11297    var useMetaBoxInitialization = (enabled) => {
11298      const {
11299        isEnabledAndEditorReady,
11300        isCollaborationEnabled,
11301        hasIncompatibleMetaBoxes,
11302        hasActiveMetaBoxes
11303      } = (0, import_data25.useSelect)(
11304        (select3) => {
11305          const {
11306            __unstableIsEditorReady,
11307            isCollaborationEnabledForCurrentPost
11308          } = unlock2(select3(import_editor18.store));
11309          return {
11310            isEnabledAndEditorReady: enabled && __unstableIsEditorReady(),
11311            isCollaborationEnabled: isCollaborationEnabledForCurrentPost(),
11312            hasIncompatibleMetaBoxes: enabled ? select3(store).getAllMetaBoxes().some((metaBox) => !metaBox.__rtc_compatible) : false,
11313            hasActiveMetaBoxes: enabled && select3(store).hasMetaBoxes()
11314          };
11315        },
11316        [enabled]
11317      );
11318      const { setCollaborationSupported } = unlock2((0, import_data25.useDispatch)(import_core_data8.store));
11319      const { updateEditorSettings } = (0, import_data25.useDispatch)(import_editor18.store);
11320      const { initializeMetaBoxes: initializeMetaBoxes2 } = (0, import_data25.useDispatch)(store);
11321      (0, import_element28.useEffect)(() => {
11322        if (isEnabledAndEditorReady) {
11323          initializeMetaBoxes2();
11324          if (isCollaborationEnabled && hasIncompatibleMetaBoxes) {
11325            setCollaborationSupported(false);
11326          }
11327          if (hasActiveMetaBoxes) {
11328            updateEditorSettings({ disableVisualRevisions: true });
11329          }
11330        }
11331      }, [
11332        isEnabledAndEditorReady,
11333        initializeMetaBoxes2,
11334        isCollaborationEnabled,
11335        setCollaborationSupported,
11336        hasIncompatibleMetaBoxes,
11337        hasActiveMetaBoxes,
11338        updateEditorSettings
11339      ]);
11340    };
11341  
11342    // packages/edit-post/build-module/components/layout/index.mjs
11343    var import_jsx_runtime41 = __toESM(require_jsx_runtime(), 1);
11344    var { useCommandContext } = unlock2(import_commands2.privateApis);
11345    var { useDrag } = unlock2(import_components8.privateApis);
11346    var { Editor, FullscreenMode, UploadProgressSnackbar } = unlock2(import_editor19.privateApis);
11347    var DESIGN_POST_TYPES = [
11348      "wp_template",
11349      "wp_template_part",
11350      "wp_block",
11351      "wp_navigation"
11352    ];
11353    function useEditorStyles(settings) {
11354      const { hasThemeStyleSupport } = (0, import_data26.useSelect)((select3) => {
11355        return {
11356          hasThemeStyleSupport: select3(store).isFeatureActive("themeStyles")
11357        };
11358      }, []);
11359      return (0, import_element29.useMemo)(() => {
11360        const presetStyles = settings.styles?.filter(
11361          (style) => style.__unstableType && style.__unstableType !== "theme"
11362        ) ?? [];
11363        const defaultEditorStyles = [
11364          ...settings?.defaultEditorStyles ?? [],
11365          ...presetStyles
11366        ];
11367        const hasThemeStyles = hasThemeStyleSupport && presetStyles.length !== (settings.styles?.length ?? 0);
11368        if (!settings.disableLayoutStyles && !hasThemeStyles) {
11369          defaultEditorStyles.push({
11370            css: getLayoutStyles({
11371              style: {},
11372              selector: "body",
11373              hasBlockGapSupport: false,
11374              hasFallbackGapSupport: true,
11375              fallbackGapValue: "0.5em"
11376            })
11377          });
11378        }
11379        return hasThemeStyles ? settings.styles ?? [] : defaultEditorStyles;
11380      }, [
11381        settings.defaultEditorStyles,
11382        settings.disableLayoutStyles,
11383        settings.styles,
11384        hasThemeStyleSupport
11385      ]);
11386    }
11387    function MetaBoxesMain() {
11388      const [isOpen, openHeight, hasAnyVisible] = (0, import_data26.useSelect)((select3) => {
11389        const { get } = select3(import_preferences10.store);
11390        const { isMetaBoxLocationVisible: isMetaBoxLocationVisible2 } = select3(store);
11391        return [
11392          !!get("core/edit-post", "metaBoxesMainIsOpen"),
11393          get("core/edit-post", "metaBoxesMainOpenHeight"),
11394          isMetaBoxLocationVisible2("normal") || isMetaBoxLocationVisible2("advanced") || isMetaBoxLocationVisible2("side")
11395        ];
11396      }, []);
11397      const { set: setPreference } = (0, import_data26.useDispatch)(import_preferences10.store);
11398      const isShort = (0, import_compose2.useMediaQuery)("(max-height: 549px)");
11399      const [{ min: min2 = 0, max: max2 }, setHeightConstraints] = (0, import_element29.useState)(() => ({}));
11400      const effectSizeConstraints = (0, import_compose2.useRefEffect)((node) => {
11401        const container = node.closest(
11402          ".interface-interface-skeleton__content"
11403        );
11404        if (!container) {
11405          return;
11406        }
11407        const noticeContainer = container.querySelector(".editor-notices");
11408        const resizeHandle = container.querySelector(
11409          ".edit-post-meta-boxes-main__presenter"
11410        );
11411        const deriveConstraints = () => {
11412          const fullHeight = container.offsetHeight;
11413          let nextMax = fullHeight;
11414          if (noticeContainer) {
11415            nextMax -= noticeContainer.offsetHeight;
11416          }
11417          const nextMin = resizeHandle?.offsetHeight ?? 0;
11418          setHeightConstraints({ min: nextMin, max: nextMax });
11419        };
11420        const observer = new window.ResizeObserver(deriveConstraints);
11421        observer.observe(container);
11422        if (noticeContainer) {
11423          observer.observe(noticeContainer);
11424        }
11425        return () => observer.disconnect();
11426      }, []);
11427      const metaBoxesMainRef = (0, import_element29.useRef)();
11428      const setMainRefs = (0, import_compose2.useMergeRefs)([
11429        metaBoxesMainRef,
11430        effectSizeConstraints
11431      ]);
11432      const separatorRef = (0, import_element29.useRef)();
11433      const separatorHelpId = (0, import_element29.useId)();
11434      const heightRef = (0, import_element29.useRef)();
11435      const getAriaValueNow = (height) => Math.round((height - min2) / (max2 - min2) * 100);
11436      const persistIsOpen = (to = !isOpen) => setPreference("core/edit-post", "metaBoxesMainIsOpen", to);
11437      const applyHeight = (candidateHeight = "auto", isPersistent) => {
11438        let styleHeight;
11439        if (candidateHeight === "auto") {
11440          isPersistent = false;
11441          styleHeight = candidateHeight;
11442        } else {
11443          candidateHeight = Math.min(max2, Math.max(min2, candidateHeight));
11444          heightRef.current = candidateHeight;
11445          styleHeight = `$candidateHeight}px`;
11446        }
11447        if (isPersistent) {
11448          setPreference(
11449            "core/edit-post",
11450            "metaBoxesMainOpenHeight",
11451            candidateHeight
11452          );
11453        } else {
11454          metaBoxesMainRef.current.style.height = styleHeight;
11455          if (!isShort) {
11456            separatorRef.current.ariaValueNow = getAriaValueNow(candidateHeight);
11457          }
11458        }
11459      };
11460      const bindDragGesture = useDrag(
11461        ({ movement, first, last, memo, tap, args }) => {
11462          const pane = metaBoxesMainRef.current;
11463          const [, yMovement] = movement;
11464          if (first) {
11465            pane.classList.add("is-resizing");
11466            let fromHeight = heightRef.current ?? pane.offsetHeight;
11467            if (isOpen) {
11468              if (fromHeight > max2) {
11469                fromHeight = max2;
11470              }
11471            } else {
11472              fromHeight = min2;
11473            }
11474            applyHeight(fromHeight - yMovement);
11475            return { fromHeight };
11476          }
11477          if (!first && !last && !tap) {
11478            applyHeight(memo.fromHeight - yMovement);
11479            return memo;
11480          }
11481          pane.classList.remove("is-resizing");
11482          if (tap) {
11483            const [onTap] = args;
11484            onTap?.();
11485            return;
11486          }
11487          const nextIsOpen = heightRef.current > min2;
11488          persistIsOpen(nextIsOpen);
11489          applyHeight(heightRef.current, nextIsOpen);
11490        },
11491        { keyboardDisplacement: 20, filterTaps: true }
11492      );
11493      if (!hasAnyVisible) {
11494        return;
11495      }
11496      const contents = /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(
11497        "div",
11498        {
11499          className: "edit-post-layout__metaboxes edit-post-meta-boxes-main__liner",
11500          hidden: !isOpen,
11501          children: [
11502            /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(MetaBoxes, { location: "normal" }),
11503            /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(MetaBoxes, { location: "advanced" })
11504          ]
11505        }
11506      );
11507      const isAutoHeight = openHeight === void 0;
11508      const usedOpenHeight = isShort ? "auto" : openHeight;
11509      const usedHeight = isOpen ? usedOpenHeight : min2;
11510      const usedAriaValueNow = max2 === void 0 || isAutoHeight ? 50 : getAriaValueNow(usedHeight);
11511      const paneLabel = (0, import_i18n15.__)("Meta Boxes");
11512      const toggle = /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(
11513        "button",
11514        {
11515          "aria-expanded": isOpen,
11516          onClick: ({ detail }) => {
11517            if (isShort || !detail) {
11518              persistIsOpen();
11519            }
11520          },
11521          ...!isShort && bindDragGesture(persistIsOpen),
11522          children: [
11523            paneLabel,
11524            /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_components8.Icon, { icon: isOpen ? chevron_up_default : chevron_down_default })
11525          ]
11526        }
11527      );
11528      const separator = !isShort && /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(import_jsx_runtime41.Fragment, { children: [
11529        /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(tooltip_exports.Root, { children: [
11530          /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
11531            tooltip_exports.Trigger,
11532            {
11533              render: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
11534                "button",
11535                {
11536                  ref: separatorRef,
11537                  role: "separator",
11538                  "aria-valuenow": usedAriaValueNow,
11539                  "aria-label": (0, import_i18n15.__)("Drag to resize"),
11540                  "aria-describedby": separatorHelpId,
11541                  ...bindDragGesture()
11542                }
11543              )
11544            }
11545          ),
11546          /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(tooltip_exports.Popup, { children: (0, import_i18n15.__)("Drag to resize") })
11547        ] }),
11548        /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(VisuallyHidden, { id: separatorHelpId, children: (0, import_i18n15.__)(
11549          "Use up and down arrow keys to resize the meta box pane."
11550        ) })
11551      ] });
11552      return /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(
11553        navigable_region_default,
11554        {
11555          ariaLabel: paneLabel,
11556          ref: setMainRefs,
11557          className: clsx_default(
11558            "edit-post-meta-boxes-main",
11559            !isShort && "is-resizable"
11560          ),
11561          style: { height: usedHeight },
11562          children: [
11563            /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)("div", { className: "edit-post-meta-boxes-main__presenter", children: [
11564              toggle,
11565              separator
11566            ] }),
11567            contents
11568          ]
11569        }
11570      );
11571    }
11572    function Layout({
11573      postId: initialPostId,
11574      postType: initialPostType,
11575      settings,
11576      initialEdits
11577    }) {
11578      useCommands();
11579      const { createErrorNotice } = (0, import_data26.useDispatch)(import_notices3.store);
11580      const {
11581        currentPost: { postId: currentPostId, postType: currentPostType },
11582        onNavigateToEntityRecord,
11583        onNavigateToPreviousEntityRecord
11584      } = useNavigateToEntityRecord(
11585        initialPostId,
11586        initialPostType,
11587        "post-only"
11588      );
11589      const isEditingTemplate2 = currentPostType === "wp_template";
11590      const {
11591        mode,
11592        isFullscreenActive,
11593        hasResolvedMode,
11594        hasActiveMetaboxes,
11595        hasBlockSelected,
11596        showIconLabels,
11597        isDistractionFree,
11598        showMetaBoxes,
11599        isWelcomeGuideVisible,
11600        templateId
11601      } = (0, import_data26.useSelect)(
11602        (select3) => {
11603          const { get } = select3(import_preferences10.store);
11604          const { isFeatureActive: isFeatureActive2, hasMetaBoxes: hasMetaBoxes2 } = select3(store);
11605          const { canUser, getPostType, getTemplateId } = unlock2(
11606            select3(import_core_data9.store)
11607          );
11608          const supportsTemplateMode = settings.supportsTemplateMode;
11609          const isViewable = getPostType(currentPostType)?.viewable ?? false;
11610          const canViewTemplate = canUser("read", {
11611            kind: "postType",
11612            name: "wp_template"
11613          });
11614          const { getBlockSelectionStart, isZoomOut } = unlock2(
11615            select3(import_block_editor2.store)
11616          );
11617          const { getEditorMode: getEditorMode2, getDefaultRenderingMode } = unlock2(
11618            select3(import_editor19.store)
11619          );
11620          const isNotDesignPostType = !DESIGN_POST_TYPES.includes(currentPostType);
11621          const isDirectlyEditingPattern = currentPostType === "wp_block" && !onNavigateToPreviousEntityRecord;
11622          const _templateId = getTemplateId(currentPostType, currentPostId);
11623          const defaultMode = getDefaultRenderingMode(currentPostType);
11624          return {
11625            mode: getEditorMode2(),
11626            isFullscreenActive: isFeatureActive2("fullscreenMode"),
11627            hasActiveMetaboxes: hasMetaBoxes2(),
11628            hasResolvedMode: defaultMode === "template-locked" ? !!_templateId : defaultMode !== void 0,
11629            hasBlockSelected: !!getBlockSelectionStart(),
11630            showIconLabels: get("core", "showIconLabels"),
11631            isDistractionFree: get("core", "distractionFree"),
11632            showMetaBoxes: isNotDesignPostType && !isZoomOut() || isDirectlyEditingPattern,
11633            isWelcomeGuideVisible: isFeatureActive2("welcomeGuide"),
11634            templateId: supportsTemplateMode && isViewable && canViewTemplate && !isEditingTemplate2 ? _templateId : null
11635          };
11636        },
11637        [
11638          currentPostType,
11639          currentPostId,
11640          isEditingTemplate2,
11641          settings.supportsTemplateMode,
11642          onNavigateToPreviousEntityRecord
11643        ]
11644      );
11645      useMetaBoxInitialization(hasActiveMetaboxes && hasResolvedMode);
11646      const commandContext = hasBlockSelected ? "block-selection-edit" : "entity-edit";
11647      useCommandContext(commandContext);
11648      const styles = useEditorStyles(settings);
11649      const editorSettings = (0, import_element29.useMemo)(
11650        () => ({
11651          ...settings,
11652          styles,
11653          onNavigateToEntityRecord,
11654          onNavigateToPreviousEntityRecord
11655        }),
11656        [
11657          settings,
11658          styles,
11659          onNavigateToEntityRecord,
11660          onNavigateToPreviousEntityRecord
11661        ]
11662      );
11663      if (showIconLabels) {
11664        document.body.classList.add("show-icon-labels");
11665      } else {
11666        document.body.classList.remove("show-icon-labels");
11667      }
11668      const navigateRegionsProps = (0, import_components8.__unstableUseNavigateRegions)();
11669      const className = clsx_default("edit-post-layout", "is-mode-" + mode, {
11670        "has-metaboxes": hasActiveMetaboxes
11671      });
11672      function onPluginAreaError(name) {
11673        createErrorNotice(
11674          (0, import_i18n15.sprintf)(
11675            /* translators: %s: plugin name */
11676            (0, import_i18n15.__)(
11677              'The "%s" plugin has encountered an error and cannot be rendered.'
11678            ),
11679            name
11680          )
11681        );
11682      }
11683      const { createSuccessNotice } = (0, import_data26.useDispatch)(import_notices3.store);
11684      const onActionPerformed = (0, import_element29.useCallback)(
11685        (actionId, items) => {
11686          switch (actionId) {
11687            case "move-to-trash":
11688              {
11689                document.location.href = (0, import_url6.addQueryArgs)("edit.php", {
11690                  trashed: 1,
11691                  post_type: items[0].type,
11692                  ids: items[0].id
11693                });
11694              }
11695              break;
11696            case "duplicate-post":
11697              {
11698                const newItem = items[0];
11699                const title = typeof newItem.title === "string" ? newItem.title : newItem.title?.rendered;
11700                createSuccessNotice(
11701                  (0, import_i18n15.sprintf)(
11702                    // translators: %s: Title of the created post or template, e.g: "Hello world".
11703                    (0, import_i18n15.__)('"%s" successfully created.'),
11704                    (0, import_html_entities.decodeEntities)(title) || (0, import_i18n15.__)("(no title)")
11705                  ),
11706                  {
11707                    type: "snackbar",
11708                    id: "duplicate-post-action",
11709                    actions: [
11710                      {
11711                        label: (0, import_i18n15.__)("Edit"),
11712                        onClick: () => {
11713                          const postId = newItem.id;
11714                          document.location.href = (0, import_url6.addQueryArgs)("post.php", {
11715                            post: postId,
11716                            action: "edit"
11717                          });
11718                        }
11719                      }
11720                    ]
11721                  }
11722                );
11723              }
11724              break;
11725          }
11726        },
11727        [createSuccessNotice]
11728      );
11729      const initialPost = (0, import_element29.useMemo)(() => {
11730        return {
11731          type: initialPostType,
11732          id: initialPostId
11733        };
11734      }, [initialPostType, initialPostId]);
11735      const backButton = (0, import_compose2.useViewportMatch)("medium") && isFullscreenActive ? /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(back_button_default, { initialPost }) : null;
11736      const adminPrimary = (0, import_element29.useMemo)(() => getAdminThemeColors().primary, []);
11737      return /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_components8.SlotFillProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(tooltip_exports.Provider, { children: /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_theme.ThemeProvider, { isRoot: true, color: { primary: adminPrimary }, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(import_editor19.ErrorBoundary, { canCopyContent: true, children: [
11738        /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(WelcomeGuide, { postType: currentPostType }),
11739        /* @__PURE__ */ (0, import_jsx_runtime41.jsx)("div", { ...navigateRegionsProps, children: /* @__PURE__ */ (0, import_jsx_runtime41.jsxs)(
11740          Editor,
11741          {
11742            settings: editorSettings,
11743            initialEdits,
11744            postType: currentPostType,
11745            postId: currentPostId,
11746            templateId,
11747            className,
11748            forceIsDirty: hasActiveMetaboxes,
11749            autoFocus: !isWelcomeGuideVisible,
11750            onActionPerformed,
11751            extraSidebarPanels: showMetaBoxes && /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(MetaBoxes, { location: "side" }),
11752            extraContent: !isDistractionFree && showMetaBoxes && /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(MetaBoxesMain, {}),
11753            children: [
11754              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_editor19.PostLockedModal, {}),
11755              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(EditorInitialization, {}),
11756              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(
11757                FullscreenMode,
11758                {
11759                  isActive: isFullscreenActive
11760                }
11761              ),
11762              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(BrowserURL, {}),
11763              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_editor19.UnsavedChangesWarning, {}),
11764              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_editor19.AutosaveMonitor, {}),
11765              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_editor19.LocalAutosaveMonitor, {}),
11766              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(keyboard_shortcuts_default, {}),
11767              currentPostType === "wp_block" && /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(InitPatternModal, {}),
11768              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_plugins.PluginArea, { onError: onPluginAreaError }),
11769              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(more_menu_default, {}),
11770              backButton,
11771              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(import_notices3.SnackbarNotices, { className: "edit-post-layout__snackbar" }),
11772              /* @__PURE__ */ (0, import_jsx_runtime41.jsx)(UploadProgressSnackbar, {})
11773            ]
11774          }
11775        ) })
11776      ] }) }) }) });
11777    }
11778    var layout_default = Layout;
11779  
11780    // packages/edit-post/build-module/deprecated.mjs
11781    var import_editor20 = __toESM(require_editor(), 1);
11782    var import_url7 = __toESM(require_url(), 1);
11783    var import_deprecated3 = __toESM(require_deprecated(), 1);
11784    var import_jsx_runtime42 = __toESM(require_jsx_runtime(), 1);
11785    var { PluginPostExcerpt } = unlock2(import_editor20.privateApis);
11786    var isSiteEditor = (0, import_url7.getPath)(window.location.href)?.includes(
11787      "site-editor.php"
11788    );
11789    var deprecateSlot = (name) => {
11790      (0, import_deprecated3.default)(`wp.editPost.$name}`, {
11791        since: "6.6",
11792        alternative: `wp.editor.$name}`
11793      });
11794    };
11795    function PluginBlockSettingsMenuItem(props) {
11796      if (isSiteEditor) {
11797        return null;
11798      }
11799      deprecateSlot("PluginBlockSettingsMenuItem");
11800      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginBlockSettingsMenuItem, { ...props });
11801    }
11802    function PluginDocumentSettingPanel(props) {
11803      if (isSiteEditor) {
11804        return null;
11805      }
11806      deprecateSlot("PluginDocumentSettingPanel");
11807      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginDocumentSettingPanel, { ...props });
11808    }
11809    function PluginMoreMenuItem(props) {
11810      if (isSiteEditor) {
11811        return null;
11812      }
11813      deprecateSlot("PluginMoreMenuItem");
11814      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginMoreMenuItem, { ...props });
11815    }
11816    function PluginPrePublishPanel(props) {
11817      if (isSiteEditor) {
11818        return null;
11819      }
11820      deprecateSlot("PluginPrePublishPanel");
11821      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginPrePublishPanel, { ...props });
11822    }
11823    function PluginPostPublishPanel(props) {
11824      if (isSiteEditor) {
11825        return null;
11826      }
11827      deprecateSlot("PluginPostPublishPanel");
11828      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginPostPublishPanel, { ...props });
11829    }
11830    function PluginPostStatusInfo(props) {
11831      if (isSiteEditor) {
11832        return null;
11833      }
11834      deprecateSlot("PluginPostStatusInfo");
11835      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginPostStatusInfo, { ...props });
11836    }
11837    function PluginSidebar(props) {
11838      if (isSiteEditor) {
11839        return null;
11840      }
11841      deprecateSlot("PluginSidebar");
11842      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginSidebar, { ...props });
11843    }
11844    function PluginSidebarMoreMenuItem(props) {
11845      if (isSiteEditor) {
11846        return null;
11847      }
11848      deprecateSlot("PluginSidebarMoreMenuItem");
11849      return /* @__PURE__ */ (0, import_jsx_runtime42.jsx)(import_editor20.PluginSidebarMoreMenuItem, { ...props });
11850    }
11851    function __experimentalPluginPostExcerpt() {
11852      if (isSiteEditor) {
11853        return null;
11854      }
11855      (0, import_deprecated3.default)("wp.editPost.__experimentalPluginPostExcerpt", {
11856        since: "6.6",
11857        hint: "Core and custom panels can be access programmatically using their panel name.",
11858        link: "https://developer.wordpress.org/block-editor/reference-guides/slotfills/plugin-document-setting-panel/#accessing-a-panel-programmatically"
11859      });
11860      return PluginPostExcerpt;
11861    }
11862  
11863    // packages/edit-post/build-module/index.mjs
11864    var import_jsx_runtime43 = __toESM(require_jsx_runtime(), 1);
11865    var {
11866      BackButton: __experimentalMainDashboardButton,
11867      registerCoreBlockBindingsSources
11868    } = unlock2(import_editor21.privateApis);
11869    var { enablePreloadMultiUse, clearPreloadedData } = unlock2(
11870      import_api_fetch2.default.privateApis
11871    );
11872    function initializeEditor(id, postType, postId, settings, initialEdits) {
11873      const target = document.getElementById(id);
11874      const root = (0, import_element30.createRoot)(target);
11875      (0, import_data27.dispatch)(import_preferences11.store).setDefaults("core/edit-post", {
11876        fullscreenMode: true,
11877        themeStyles: true,
11878        welcomeGuide: true,
11879        welcomeGuideTemplate: true
11880      });
11881      (0, import_data27.dispatch)(import_preferences11.store).setDefaults("core", {
11882        allowRightClickOverrides: true,
11883        editorMode: "visual",
11884        editorTool: "edit",
11885        fixedToolbar: false,
11886        hiddenBlockTypes: [],
11887        inactivePanels: [],
11888        openPanels: ["post-status"],
11889        showBlockBreadcrumbs: true,
11890        showIconLabels: false,
11891        showListViewByDefault: false,
11892        enableChoosePatternModal: true,
11893        isPublishSidebarEnabled: true,
11894        showCollaborationCursor: false,
11895        showCollaborationJoinNotifications: true,
11896        showCollaborationLeaveNotifications: true,
11897        showCollaborationPostSaveNotifications: true
11898      });
11899      if (window.__clientSideMediaProcessing) {
11900        (0, import_data27.dispatch)(import_preferences11.store).setDefaults("core/media", {
11901          requireApproval: true,
11902          optimizeOnUpload: true
11903        });
11904      }
11905      (0, import_data27.dispatch)(import_blocks2.store).reapplyBlockTypeFilters();
11906      (0, import_block_library.registerCoreBlocks)();
11907      registerCoreBlockBindingsSources();
11908      (0, import_widgets.registerLegacyWidgetBlock)({ inserter: false });
11909      (0, import_widgets.registerWidgetGroupBlock)({ inserter: false });
11910      if (false) {
11911        (0, import_block_library.__experimentalRegisterExperimentalCoreBlocks)({
11912          enableFSEBlocks: settings.__unstableEnableFullSiteEditingBlocks
11913        });
11914      }
11915      const documentMode = document.compatMode === "CSS1Compat" ? "Standards" : "Quirks";
11916      if (documentMode !== "Standards") {
11917        console.warn(
11918          "Your browser is using Quirks Mode. \nThis can cause rendering issues such as blocks overlaying meta boxes in the editor. Quirks Mode can be triggered by PHP errors or HTML code appearing before the opening <!DOCTYPE html>. Try checking the raw page source or your site's PHP error log and resolving errors there, removing any HTML before the doctype, or disabling plugins."
11919        );
11920      }
11921      window.addEventListener("dragover", (e) => e.preventDefault(), false);
11922      window.addEventListener("drop", (e) => e.preventDefault(), false);
11923      enablePreloadMultiUse();
11924      const preloadedResolutions = preloadResolutions(postType, postId);
11925      preloadedResolutions.finally(() => {
11926        clearPreloadedData();
11927        if (postType && postId) {
11928          const post = (0, import_data27.select)(import_core_data10.store).getEntityRecord(
11929            "postType",
11930            postType,
11931            postId
11932          );
11933          if (post) {
11934            (0, import_data27.dispatch)(import_editor21.store).setupEditor(
11935              post,
11936              initialEdits,
11937              settings.template
11938            );
11939          }
11940        }
11941        root.render(
11942          /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(import_element30.StrictMode, { children: /* @__PURE__ */ (0, import_jsx_runtime43.jsx)(
11943            layout_default,
11944            {
11945              settings,
11946              postId,
11947              postType,
11948              initialEdits
11949            }
11950          ) })
11951        );
11952      });
11953      return root;
11954    }
11955    async function preloadResolutions(postType, postId) {
11956      const core = (0, import_data27.resolveSelect)(import_core_data10.store);
11957      const coreSelect = (0, import_data27.select)(import_core_data10.store);
11958      try {
11959        await Promise.all([
11960          core.getCurrentUser(),
11961          core.getEntitiesConfig("postType"),
11962          core.getEntitiesConfig("taxonomy"),
11963          core.getEntitiesConfig("root"),
11964          core.getEntityRecords("root", "taxonomy"),
11965          core.getCurrentTheme(),
11966          // Forward-resolver alias of `getCurrentTheme` with its own
11967          // resolution metadata, so it needs a separate kick.
11968          core.getThemeSupports(),
11969          core.getBlockPatternCategories(),
11970          core.__experimentalGetCurrentGlobalStylesId(),
11971          core.__experimentalGetCurrentThemeBaseGlobalStyles(),
11972          core.__experimentalGetCurrentThemeGlobalStylesVariations(),
11973          core.getEntityRecord("root", "__unstableBase"),
11974          core.canUser("read", { kind: "root", name: "site" }),
11975          core.canUser("create", { kind: "postType", name: "attachment" }),
11976          core.canUser("create", { kind: "postType", name: "page" }),
11977          core.canUser("create", { kind: "postType", name: "wp_block" }),
11978          core.canUser("create", {
11979            kind: "postType",
11980            name: "wp_template"
11981          }),
11982          // The DataForm-based inspector requests the entity form config
11983          // when the document sidebar mounts. The args must match the
11984          // `useViewConfig` call in `@wordpress/views` exactly for the
11985          // resolution (and its preload entry) to be shared.
11986          ...postType && window?.__experimentalDataFormInspector ? [
11987            unlock2(core).getViewConfig("postType", postType, {
11988              fields: "form"
11989            })
11990          ] : [],
11991          // Per-post resolvers. `getPostType` and `getEditedEntityRecord`
11992          // are shorthand/forward-resolver aliases with their own
11993          // resolution metadata, so they need separate kicks.
11994          ...postType && postId ? [
11995            core.getPostType(postType),
11996            core.getEntityRecord("postType", postType, postId),
11997            core.getEditedEntityRecord(
11998              "postType",
11999              postType,
12000              postId
12001            ),
12002            core.getAutosaves(postType, postId),
12003            core.getDefaultTemplateId({ slug: "front-page" }),
12004            core.canUser("create", {
12005              kind: "postType",
12006              name: postType
12007            })
12008          ] : []
12009        ]);
12010        const tasks = [];
12011        if (coreSelect.canUser("read", { kind: "root", name: "site" })) {
12012          tasks.push(core.getEntityRecord("root", "site"));
12013        }
12014        const globalStylesId = coreSelect.__experimentalGetCurrentGlobalStylesId();
12015        if (globalStylesId) {
12016          tasks.push(
12017            core.canUser("update", {
12018              kind: "root",
12019              name: "globalStyles",
12020              id: globalStylesId
12021            })
12022          );
12023        }
12024        if (postType && postId) {
12025          const post = coreSelect.getEntityRecord(
12026            "postType",
12027            postType,
12028            postId
12029          );
12030          if (post) {
12031            let slug = "page" === postType ? "page" : "single-" + postType;
12032            if (post.slug) {
12033              slug += "-" + post.slug;
12034            }
12035            tasks.push(core.getDefaultTemplateId({ slug }));
12036            if (post.author) {
12037              tasks.push(
12038                core.getUser(post.author, {
12039                  context: "view",
12040                  _fields: "id,name"
12041                })
12042              );
12043            }
12044          }
12045        }
12046        if (tasks.length) {
12047          await Promise.all(tasks);
12048        }
12049        if (globalStylesId) {
12050          if (coreSelect.canUser("update", {
12051            kind: "root",
12052            name: "globalStyles",
12053            id: globalStylesId
12054          })) {
12055            await core.getEntityRecord(
12056              "root",
12057              "globalStyles",
12058              globalStylesId
12059            );
12060          } else {
12061            await core.getEntityRecord(
12062              "root",
12063              "globalStyles",
12064              globalStylesId,
12065              { context: "view" }
12066            );
12067          }
12068        }
12069      } catch {
12070      }
12071    }
12072    function reinitializeEditor() {
12073      (0, import_deprecated4.default)("wp.editPost.reinitializeEditor", {
12074        since: "6.2",
12075        version: "6.3"
12076      });
12077    }
12078    return __toCommonJS(index_exports);
12079  })();
12080  /*! Bundled license information:
12081  
12082  use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
12083    (**
12084     * @license React
12085     * use-sync-external-store-shim.development.js
12086     *
12087     * Copyright (c) Meta Platforms, Inc. and affiliates.
12088     *
12089     * This source code is licensed under the MIT license found in the
12090     * LICENSE file in the root directory of this source tree.
12091     *)
12092  
12093  use-sync-external-store/cjs/use-sync-external-store-shim/with-selector.development.js:
12094    (**
12095     * @license React
12096     * use-sync-external-store-shim/with-selector.development.js
12097     *
12098     * Copyright (c) Meta Platforms, Inc. and affiliates.
12099     *
12100     * This source code is licensed under the MIT license found in the
12101     * LICENSE file in the root directory of this source tree.
12102     *)
12103  */
12104  (window.wp ||= {}).editPost = wp.editPost;
12105  })();