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