"use strict";
var wp;
(wp ||= {}).components = (() => {
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from2, except, desc) => {
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
for (let key of __getOwnPropNames(from2))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// package-external:@wordpress/primitives
var require_primitives = __commonJS({
"package-external:@wordpress/primitives"(exports, module) {
module.exports = window.wp.primitives;
}
});
// package-external:@wordpress/i18n
var require_i18n = __commonJS({
"package-external:@wordpress/i18n"(exports, module) {
module.exports = window.wp.i18n;
}
});
// package-external:@wordpress/compose
var require_compose = __commonJS({
"package-external:@wordpress/compose"(exports, module) {
module.exports = window.wp.compose;
}
});
// package-external:@wordpress/element
var require_element = __commonJS({
"package-external:@wordpress/element"(exports, module) {
module.exports = window.wp.element;
}
});
// vendor-external:react
var require_react = __commonJS({
"vendor-external:react"(exports, module) {
module.exports = window.React;
}
});
// vendor-external:react/jsx-runtime
var require_jsx_runtime = __commonJS({
"vendor-external:react/jsx-runtime"(exports, module) {
module.exports = window.ReactJSXRuntime;
}
});
// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
var require_use_sync_external_store_shim_development = __commonJS({
"node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
"use strict";
(function() {
function is(x2, y3) {
return x2 === y3 && (0 !== x2 || 1 / x2 === 1 / y3) || x2 !== x2 && y3 !== y3;
}
function useSyncExternalStore$2(subscribe2, getSnapshot) {
didWarnOld18Alpha || void 0 === React41.startTransition || (didWarnOld18Alpha = true, console.error(
"You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
));
var value = getSnapshot();
if (!didWarnUncachedGetSnapshot) {
var cachedValue = getSnapshot();
objectIs(value, cachedValue) || (console.error(
"The result of getSnapshot should be cached to avoid an infinite loop"
), didWarnUncachedGetSnapshot = true);
}
cachedValue = useState85({
inst: { value, getSnapshot }
});
var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
useLayoutEffect24(
function() {
inst.value = value;
inst.getSnapshot = getSnapshot;
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
},
[subscribe2, value, getSnapshot]
);
useEffect79(
function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
return subscribe2(function() {
checkIfSnapshotChanged(inst) && forceUpdate({ inst });
});
},
[subscribe2]
);
useDebugValue(value);
return value;
}
function checkIfSnapshotChanged(inst) {
var latestGetSnapshot = inst.getSnapshot;
inst = inst.value;
try {
var nextValue = latestGetSnapshot();
return !objectIs(inst, nextValue);
} catch (error) {
return true;
}
}
function useSyncExternalStore$1(subscribe2, getSnapshot) {
return getSnapshot();
}
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
var React41 = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState85 = React41.useState, useEffect79 = React41.useEffect, useLayoutEffect24 = React41.useLayoutEffect, useDebugValue = React41.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
exports.useSyncExternalStore = void 0 !== React41.useSyncExternalStore ? React41.useSyncExternalStore : shim;
"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
})();
}
});
// node_modules/use-sync-external-store/shim/index.js
var require_shim = __commonJS({
"node_modules/use-sync-external-store/shim/index.js"(exports, module) {
"use strict";
if (false) {
module.exports = null;
} else {
module.exports = require_use_sync_external_store_shim_development();
}
}
});
// vendor-external:react-dom
var require_react_dom = __commonJS({
"vendor-external:react-dom"(exports, module) {
module.exports = window.ReactDOM;
}
});
// package-external:@wordpress/deprecated
var require_deprecated = __commonJS({
"package-external:@wordpress/deprecated"(exports, module) {
module.exports = window.wp.deprecated;
}
});
// node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
function memoize(fn) {
var cache2 = /* @__PURE__ */ Object.create(null);
return function(arg) {
if (cache2[arg] === void 0) cache2[arg] = fn(arg);
return cache2[arg];
};
}
var init_emotion_memoize_esm = __esm({
"node_modules/@emotion/memoize/dist/emotion-memoize.esm.js"() {
}
});
// node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js
var emotion_is_prop_valid_esm_exports = {};
__export(emotion_is_prop_valid_esm_exports, {
default: () => isPropValid
});
var reactPropsRegex, isPropValid;
var init_emotion_is_prop_valid_esm = __esm({
"node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js"() {
init_emotion_memoize_esm();
reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|popover|popoverTarget|popoverTargetAction|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/;
isPropValid = /* @__PURE__ */ memoize(
function(prop) {
return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111 && prop.charCodeAt(1) === 110 && prop.charCodeAt(2) < 91;
}
/* Z+1 */
);
}
});
// node_modules/react-is/cjs/react-is.development.js
var require_react_is_development = __commonJS({
"node_modules/react-is/cjs/react-is.development.js"(exports) {
"use strict";
if (true) {
(function() {
"use strict";
var hasSymbol = typeof Symbol === "function" && Symbol.for;
var REACT_ELEMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
var REACT_PORTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.portal") : 60106;
var REACT_FRAGMENT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fragment") : 60107;
var REACT_STRICT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.strict_mode") : 60108;
var REACT_PROFILER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.profiler") : 60114;
var REACT_PROVIDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.provider") : 60109;
var REACT_CONTEXT_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.context") : 60110;
var REACT_ASYNC_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.async_mode") : 60111;
var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.concurrent_mode") : 60111;
var REACT_FORWARD_REF_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.forward_ref") : 60112;
var REACT_SUSPENSE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense") : 60113;
var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.suspense_list") : 60120;
var REACT_MEMO_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.memo") : 60115;
var REACT_LAZY_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.lazy") : 60116;
var REACT_BLOCK_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.block") : 60121;
var REACT_FUNDAMENTAL_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.fundamental") : 60117;
var REACT_RESPONDER_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.responder") : 60118;
var REACT_SCOPE_TYPE = hasSymbol ? /* @__PURE__ */ Symbol.for("react.scope") : 60119;
function isValidElementType(type) {
return typeof type === "string" || typeof type === "function" || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
}
function typeOf(object) {
if (typeof object === "object" && object !== null) {
var $$typeof = object.$$typeof;
switch ($$typeof) {
case REACT_ELEMENT_TYPE:
var type = object.type;
switch (type) {
case REACT_ASYNC_MODE_TYPE:
case REACT_CONCURRENT_MODE_TYPE:
case REACT_FRAGMENT_TYPE:
case REACT_PROFILER_TYPE:
case REACT_STRICT_MODE_TYPE:
case REACT_SUSPENSE_TYPE:
return type;
default:
var $$typeofType = type && type.$$typeof;
switch ($$typeofType) {
case REACT_CONTEXT_TYPE:
case REACT_FORWARD_REF_TYPE:
case REACT_LAZY_TYPE:
case REACT_MEMO_TYPE:
case REACT_PROVIDER_TYPE:
return $$typeofType;
default:
return $$typeof;
}
}
case REACT_PORTAL_TYPE:
return $$typeof;
}
}
return void 0;
}
var AsyncMode = REACT_ASYNC_MODE_TYPE;
var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element2 = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment11 = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal3 = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false;
function isAsyncMode(object) {
{
if (!hasWarnedAboutDeprecatedIsAsyncMode) {
hasWarnedAboutDeprecatedIsAsyncMode = true;
console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
}
}
return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
}
function isConcurrentMode(object) {
return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
}
function isContextConsumer(object) {
return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement2(object) {
return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
return typeOf(object) === REACT_SUSPENSE_TYPE;
}
exports.AsyncMode = AsyncMode;
exports.ConcurrentMode = ConcurrentMode;
exports.ContextConsumer = ContextConsumer;
exports.ContextProvider = ContextProvider;
exports.Element = Element2;
exports.ForwardRef = ForwardRef;
exports.Fragment = Fragment11;
exports.Lazy = Lazy;
exports.Memo = Memo;
exports.Portal = Portal3;
exports.Profiler = Profiler;
exports.StrictMode = StrictMode;
exports.Suspense = Suspense;
exports.isAsyncMode = isAsyncMode;
exports.isConcurrentMode = isConcurrentMode;
exports.isContextConsumer = isContextConsumer;
exports.isContextProvider = isContextProvider;
exports.isElement = isElement2;
exports.isForwardRef = isForwardRef;
exports.isFragment = isFragment;
exports.isLazy = isLazy;
exports.isMemo = isMemo;
exports.isPortal = isPortal;
exports.isProfiler = isProfiler;
exports.isStrictMode = isStrictMode;
exports.isSuspense = isSuspense;
exports.isValidElementType = isValidElementType;
exports.typeOf = typeOf;
})();
}
}
});
// node_modules/react-is/index.js
var require_react_is = __commonJS({
"node_modules/react-is/index.js"(exports, module) {
"use strict";
if (false) {
module.exports = null;
} else {
module.exports = require_react_is_development();
}
}
});
// node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js
var require_hoist_non_react_statics_cjs = __commonJS({
"node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js"(exports, module) {
"use strict";
var reactIs = require_react_is();
var REACT_STATICS = {
childContextTypes: true,
contextType: true,
contextTypes: true,
defaultProps: true,
displayName: true,
getDefaultProps: true,
getDerivedStateFromError: true,
getDerivedStateFromProps: true,
mixins: true,
propTypes: true,
type: true
};
var KNOWN_STATICS = {
name: true,
length: true,
prototype: true,
caller: true,
callee: true,
arguments: true,
arity: true
};
var FORWARD_REF_STATICS = {
"$$typeof": true,
render: true,
defaultProps: true,
displayName: true,
propTypes: true
};
var MEMO_STATICS = {
"$$typeof": true,
compare: true,
defaultProps: true,
displayName: true,
propTypes: true,
type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
function getStatics(component) {
if (reactIs.isMemo(component)) {
return MEMO_STATICS;
}
return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
}
var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
if (typeof sourceComponent !== "string") {
if (objectPrototype) {
var inheritedComponent = getPrototypeOf(sourceComponent);
if (inheritedComponent && inheritedComponent !== objectPrototype) {
hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
}
}
var keys = getOwnPropertyNames(sourceComponent);
if (getOwnPropertySymbols) {
keys = keys.concat(getOwnPropertySymbols(sourceComponent));
}
var targetStatics = getStatics(targetComponent);
var sourceStatics = getStatics(sourceComponent);
for (var i3 = 0; i3 < keys.length; ++i3) {
var key = keys[i3];
if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
try {
defineProperty(targetComponent, key, descriptor);
} catch (e3) {
}
}
}
}
return targetComponent;
}
module.exports = hoistNonReactStatics;
}
});
// node_modules/deepmerge/dist/cjs.js
var require_cjs = __commonJS({
"node_modules/deepmerge/dist/cjs.js"(exports, module) {
"use strict";
var isMergeableObject = function isMergeableObject2(value) {
return isNonNullObject(value) && !isSpecial(value);
};
function isNonNullObject(value) {
return !!value && typeof value === "object";
}
function isSpecial(value) {
var stringValue = Object.prototype.toString.call(value);
return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
}
var canUseSymbol = typeof Symbol === "function" && Symbol.for;
var REACT_ELEMENT_TYPE = canUseSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
function isReactElement(value) {
return value.$$typeof === REACT_ELEMENT_TYPE;
}
function emptyTarget(val) {
return Array.isArray(val) ? [] : {};
}
function cloneUnlessOtherwiseSpecified(value, options2) {
return options2.clone !== false && options2.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options2) : value;
}
function defaultArrayMerge(target, source, options2) {
return target.concat(source).map(function(element) {
return cloneUnlessOtherwiseSpecified(element, options2);
});
}
function getMergeFunction(key, options2) {
if (!options2.customMerge) {
return deepmerge2;
}
var customMerge = options2.customMerge(key);
return typeof customMerge === "function" ? customMerge : deepmerge2;
}
function getEnumerableOwnPropertySymbols(target) {
return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol4) {
return Object.propertyIsEnumerable.call(target, symbol4);
}) : [];
}
function getKeys2(target) {
return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
}
function propertyIsOnObject(object, property) {
try {
return property in object;
} catch (_2) {
return false;
}
}
function propertyIsUnsafe(target, key) {
return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
}
function mergeObject(target, source, options2) {
var destination = {};
if (options2.isMergeableObject(target)) {
getKeys2(target).forEach(function(key) {
destination[key] = cloneUnlessOtherwiseSpecified(target[key], options2);
});
}
getKeys2(source).forEach(function(key) {
if (propertyIsUnsafe(target, key)) {
return;
}
if (propertyIsOnObject(target, key) && options2.isMergeableObject(source[key])) {
destination[key] = getMergeFunction(key, options2)(target[key], source[key], options2);
} else {
destination[key] = cloneUnlessOtherwiseSpecified(source[key], options2);
}
});
return destination;
}
function deepmerge2(target, source, options2) {
options2 = options2 || {};
options2.arrayMerge = options2.arrayMerge || defaultArrayMerge;
options2.isMergeableObject = options2.isMergeableObject || isMergeableObject;
options2.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
var sourceIsArray = Array.isArray(source);
var targetIsArray = Array.isArray(target);
var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
if (!sourceAndTargetTypesMatch) {
return cloneUnlessOtherwiseSpecified(source, options2);
} else if (sourceIsArray) {
return options2.arrayMerge(target, source, options2);
} else {
return mergeObject(target, source, options2);
}
}
deepmerge2.all = function deepmergeAll(array, options2) {
if (!Array.isArray(array)) {
throw new Error("first argument should be an array");
}
return array.reduce(function(prev2, next2) {
return deepmerge2(prev2, next2, options2);
}, {});
};
var deepmerge_1 = deepmerge2;
module.exports = deepmerge_1;
}
});
// node_modules/fast-deep-equal/es6/index.js
var require_es6 = __commonJS({
"node_modules/fast-deep-equal/es6/index.js"(exports, module) {
"use strict";
module.exports = function equal(a3, b3) {
if (a3 === b3) return true;
if (a3 && b3 && typeof a3 == "object" && typeof b3 == "object") {
if (a3.constructor !== b3.constructor) return false;
var length2, i3, keys;
if (Array.isArray(a3)) {
length2 = a3.length;
if (length2 != b3.length) return false;
for (i3 = length2; i3-- !== 0; )
if (!equal(a3[i3], b3[i3])) return false;
return true;
}
if (a3 instanceof Map && b3 instanceof Map) {
if (a3.size !== b3.size) return false;
for (i3 of a3.entries())
if (!b3.has(i3[0])) return false;
for (i3 of a3.entries())
if (!equal(i3[1], b3.get(i3[0]))) return false;
return true;
}
if (a3 instanceof Set && b3 instanceof Set) {
if (a3.size !== b3.size) return false;
for (i3 of a3.entries())
if (!b3.has(i3[0])) return false;
return true;
}
if (ArrayBuffer.isView(a3) && ArrayBuffer.isView(b3)) {
length2 = a3.length;
if (length2 != b3.length) return false;
for (i3 = length2; i3-- !== 0; )
if (a3[i3] !== b3[i3]) return false;
return true;
}
if (a3.constructor === RegExp) return a3.source === b3.source && a3.flags === b3.flags;
if (a3.valueOf !== Object.prototype.valueOf) return a3.valueOf() === b3.valueOf();
if (a3.toString !== Object.prototype.toString) return a3.toString() === b3.toString();
keys = Object.keys(a3);
length2 = keys.length;
if (length2 !== Object.keys(b3).length) return false;
for (i3 = length2; i3-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b3, keys[i3])) return false;
for (i3 = length2; i3-- !== 0; ) {
var key = keys[i3];
if (!equal(a3[key], b3[key])) return false;
}
return true;
}
return a3 !== a3 && b3 !== b3;
};
}
});
// package-external:@wordpress/warning
var require_warning = __commonJS({
"package-external:@wordpress/warning"(exports, module) {
module.exports = window.wp.warning;
}
});
// node_modules/highlight-words-core/dist/index.js
var require_dist = __commonJS({
"node_modules/highlight-words-core/dist/index.js"(exports, module) {
module.exports = /******/
(function(modules) {
var installedModules = {};
function __webpack_require__(moduleId) {
if (installedModules[moduleId])
return installedModules[moduleId].exports;
var module2 = installedModules[moduleId] = {
/******/
exports: {},
/******/
id: moduleId,
/******/
loaded: false
/******/
};
modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__);
module2.loaded = true;
return module2.exports;
}
__webpack_require__.m = modules;
__webpack_require__.c = installedModules;
__webpack_require__.p = "";
return __webpack_require__(0);
})([
/* 0 */
/***/
(function(module2, exports2, __webpack_require__) {
module2.exports = __webpack_require__(1);
}),
/* 1 */
/***/
(function(module2, exports2, __webpack_require__) {
"use strict";
Object.defineProperty(exports2, "__esModule", {
value: true
});
var _utils = __webpack_require__(2);
Object.defineProperty(exports2, "combineChunks", {
enumerable: true,
get: function get() {
return _utils.combineChunks;
}
});
Object.defineProperty(exports2, "fillInChunks", {
enumerable: true,
get: function get() {
return _utils.fillInChunks;
}
});
Object.defineProperty(exports2, "findAll", {
enumerable: true,
get: function get() {
return _utils.findAll;
}
});
Object.defineProperty(exports2, "findChunks", {
enumerable: true,
get: function get() {
return _utils.findChunks;
}
});
}),
/* 2 */
/***/
(function(module2, exports2) {
"use strict";
Object.defineProperty(exports2, "__esModule", {
value: true
});
var findAll2 = exports2.findAll = function findAll3(_ref11) {
var autoEscape = _ref11.autoEscape, _ref$caseSensitive = _ref11.caseSensitive, caseSensitive = _ref$caseSensitive === void 0 ? false : _ref$caseSensitive, _ref$findChunks = _ref11.findChunks, findChunks = _ref$findChunks === void 0 ? defaultFindChunks : _ref$findChunks, sanitize2 = _ref11.sanitize, searchWords = _ref11.searchWords, textToHighlight = _ref11.textToHighlight;
return fillInChunks({
chunksToHighlight: combineChunks({
chunks: findChunks({
autoEscape,
caseSensitive,
sanitize: sanitize2,
searchWords,
textToHighlight
})
}),
totalLength: textToHighlight ? textToHighlight.length : 0
});
};
var combineChunks = exports2.combineChunks = function combineChunks2(_ref25) {
var chunks = _ref25.chunks;
chunks = chunks.sort(function(first, second) {
return first.start - second.start;
}).reduce(function(processedChunks, nextChunk) {
if (processedChunks.length === 0) {
return [nextChunk];
} else {
var prevChunk = processedChunks.pop();
if (nextChunk.start <= prevChunk.end) {
var endIndex = Math.max(prevChunk.end, nextChunk.end);
processedChunks.push({ highlight: false, start: prevChunk.start, end: endIndex });
} else {
processedChunks.push(prevChunk, nextChunk);
}
return processedChunks;
}
}, []);
return chunks;
};
var defaultFindChunks = function defaultFindChunks2(_ref32) {
var autoEscape = _ref32.autoEscape, caseSensitive = _ref32.caseSensitive, _ref3$sanitize = _ref32.sanitize, sanitize2 = _ref3$sanitize === void 0 ? defaultSanitize : _ref3$sanitize, searchWords = _ref32.searchWords, textToHighlight = _ref32.textToHighlight;
textToHighlight = sanitize2(textToHighlight);
return searchWords.filter(function(searchWord) {
return searchWord;
}).reduce(function(chunks, searchWord) {
searchWord = sanitize2(searchWord);
if (autoEscape) {
searchWord = escapeRegExpFn(searchWord);
}
var regex = new RegExp(searchWord, caseSensitive ? "g" : "gi");
var match4 = void 0;
while (match4 = regex.exec(textToHighlight)) {
var _start = match4.index;
var _end = regex.lastIndex;
if (_end > _start) {
chunks.push({ highlight: false, start: _start, end: _end });
}
if (match4.index === regex.lastIndex) {
regex.lastIndex++;
}
}
return chunks;
}, []);
};
exports2.findChunks = defaultFindChunks;
var fillInChunks = exports2.fillInChunks = function fillInChunks2(_ref42) {
var chunksToHighlight = _ref42.chunksToHighlight, totalLength = _ref42.totalLength;
var allChunks = [];
var append2 = function append3(start, end, highlight) {
if (end - start > 0) {
allChunks.push({
start,
end,
highlight
});
}
};
if (chunksToHighlight.length === 0) {
append2(0, totalLength, false);
} else {
var lastIndex = 0;
chunksToHighlight.forEach(function(chunk) {
append2(lastIndex, chunk.start, false);
append2(chunk.start, chunk.end, true);
lastIndex = chunk.end;
});
append2(lastIndex, totalLength, false);
}
return allChunks;
};
function defaultSanitize(string) {
return string;
}
function escapeRegExpFn(string) {
return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
}
})
/******/
]);
}
});
// node_modules/remove-accents/index.js
var require_remove_accents = __commonJS({
"node_modules/remove-accents/index.js"(exports, module) {
var characterMap = {
"\xC0": "A",
"\xC1": "A",
"\xC2": "A",
"\xC3": "A",
"\xC4": "A",
"\xC5": "A",
"\u1EA4": "A",
"\u1EAE": "A",
"\u1EB2": "A",
"\u1EB4": "A",
"\u1EB6": "A",
"\xC6": "AE",
"\u1EA6": "A",
"\u1EB0": "A",
"\u0202": "A",
"\u1EA2": "A",
"\u1EA0": "A",
"\u1EA8": "A",
"\u1EAA": "A",
"\u1EAC": "A",
"\xC7": "C",
"\u1E08": "C",
"\xC8": "E",
"\xC9": "E",
"\xCA": "E",
"\xCB": "E",
"\u1EBE": "E",
"\u1E16": "E",
"\u1EC0": "E",
"\u1E14": "E",
"\u1E1C": "E",
"\u0206": "E",
"\u1EBA": "E",
"\u1EBC": "E",
"\u1EB8": "E",
"\u1EC2": "E",
"\u1EC4": "E",
"\u1EC6": "E",
"\xCC": "I",
"\xCD": "I",
"\xCE": "I",
"\xCF": "I",
"\u1E2E": "I",
"\u020A": "I",
"\u1EC8": "I",
"\u1ECA": "I",
"\xD0": "D",
"\xD1": "N",
"\xD2": "O",
"\xD3": "O",
"\xD4": "O",
"\xD5": "O",
"\xD6": "O",
"\xD8": "O",
"\u1ED0": "O",
"\u1E4C": "O",
"\u1E52": "O",
"\u020E": "O",
"\u1ECE": "O",
"\u1ECC": "O",
"\u1ED4": "O",
"\u1ED6": "O",
"\u1ED8": "O",
"\u1EDC": "O",
"\u1EDE": "O",
"\u1EE0": "O",
"\u1EDA": "O",
"\u1EE2": "O",
"\xD9": "U",
"\xDA": "U",
"\xDB": "U",
"\xDC": "U",
"\u1EE6": "U",
"\u1EE4": "U",
"\u1EEC": "U",
"\u1EEE": "U",
"\u1EF0": "U",
"\xDD": "Y",
"\xE0": "a",
"\xE1": "a",
"\xE2": "a",
"\xE3": "a",
"\xE4": "a",
"\xE5": "a",
"\u1EA5": "a",
"\u1EAF": "a",
"\u1EB3": "a",
"\u1EB5": "a",
"\u1EB7": "a",
"\xE6": "ae",
"\u1EA7": "a",
"\u1EB1": "a",
"\u0203": "a",
"\u1EA3": "a",
"\u1EA1": "a",
"\u1EA9": "a",
"\u1EAB": "a",
"\u1EAD": "a",
"\xE7": "c",
"\u1E09": "c",
"\xE8": "e",
"\xE9": "e",
"\xEA": "e",
"\xEB": "e",
"\u1EBF": "e",
"\u1E17": "e",
"\u1EC1": "e",
"\u1E15": "e",
"\u1E1D": "e",
"\u0207": "e",
"\u1EBB": "e",
"\u1EBD": "e",
"\u1EB9": "e",
"\u1EC3": "e",
"\u1EC5": "e",
"\u1EC7": "e",
"\xEC": "i",
"\xED": "i",
"\xEE": "i",
"\xEF": "i",
"\u1E2F": "i",
"\u020B": "i",
"\u1EC9": "i",
"\u1ECB": "i",
"\xF0": "d",
"\xF1": "n",
"\xF2": "o",
"\xF3": "o",
"\xF4": "o",
"\xF5": "o",
"\xF6": "o",
"\xF8": "o",
"\u1ED1": "o",
"\u1E4D": "o",
"\u1E53": "o",
"\u020F": "o",
"\u1ECF": "o",
"\u1ECD": "o",
"\u1ED5": "o",
"\u1ED7": "o",
"\u1ED9": "o",
"\u1EDD": "o",
"\u1EDF": "o",
"\u1EE1": "o",
"\u1EDB": "o",
"\u1EE3": "o",
"\xF9": "u",
"\xFA": "u",
"\xFB": "u",
"\xFC": "u",
"\u1EE7": "u",
"\u1EE5": "u",
"\u1EED": "u",
"\u1EEF": "u",
"\u1EF1": "u",
"\xFD": "y",
"\xFF": "y",
"\u0100": "A",
"\u0101": "a",
"\u0102": "A",
"\u0103": "a",
"\u0104": "A",
"\u0105": "a",
"\u0106": "C",
"\u0107": "c",
"\u0108": "C",
"\u0109": "c",
"\u010A": "C",
"\u010B": "c",
"\u010C": "C",
"\u010D": "c",
"C\u0306": "C",
"c\u0306": "c",
"\u010E": "D",
"\u010F": "d",
"\u0110": "D",
"\u0111": "d",
"\u0112": "E",
"\u0113": "e",
"\u0114": "E",
"\u0115": "e",
"\u0116": "E",
"\u0117": "e",
"\u0118": "E",
"\u0119": "e",
"\u011A": "E",
"\u011B": "e",
"\u011C": "G",
"\u01F4": "G",
"\u011D": "g",
"\u01F5": "g",
"\u011E": "G",
"\u011F": "g",
"\u0120": "G",
"\u0121": "g",
"\u0122": "G",
"\u0123": "g",
"\u0124": "H",
"\u0125": "h",
"\u0126": "H",
"\u0127": "h",
"\u1E2A": "H",
"\u1E2B": "h",
"\u0128": "I",
"\u0129": "i",
"\u012A": "I",
"\u012B": "i",
"\u012C": "I",
"\u012D": "i",
"\u012E": "I",
"\u012F": "i",
"\u0130": "I",
"\u0131": "i",
"\u0132": "IJ",
"\u0133": "ij",
"\u0134": "J",
"\u0135": "j",
"\u0136": "K",
"\u0137": "k",
"\u1E30": "K",
"\u1E31": "k",
"K\u0306": "K",
"k\u0306": "k",
"\u0139": "L",
"\u013A": "l",
"\u013B": "L",
"\u013C": "l",
"\u013D": "L",
"\u013E": "l",
"\u013F": "L",
"\u0140": "l",
"\u0141": "l",
"\u0142": "l",
"\u1E3E": "M",
"\u1E3F": "m",
"M\u0306": "M",
"m\u0306": "m",
"\u0143": "N",
"\u0144": "n",
"\u0145": "N",
"\u0146": "n",
"\u0147": "N",
"\u0148": "n",
"\u0149": "n",
"N\u0306": "N",
"n\u0306": "n",
"\u014C": "O",
"\u014D": "o",
"\u014E": "O",
"\u014F": "o",
"\u0150": "O",
"\u0151": "o",
"\u0152": "OE",
"\u0153": "oe",
"P\u0306": "P",
"p\u0306": "p",
"\u0154": "R",
"\u0155": "r",
"\u0156": "R",
"\u0157": "r",
"\u0158": "R",
"\u0159": "r",
"R\u0306": "R",
"r\u0306": "r",
"\u0212": "R",
"\u0213": "r",
"\u015A": "S",
"\u015B": "s",
"\u015C": "S",
"\u015D": "s",
"\u015E": "S",
"\u0218": "S",
"\u0219": "s",
"\u015F": "s",
"\u0160": "S",
"\u0161": "s",
"\u0162": "T",
"\u0163": "t",
"\u021B": "t",
"\u021A": "T",
"\u0164": "T",
"\u0165": "t",
"\u0166": "T",
"\u0167": "t",
"T\u0306": "T",
"t\u0306": "t",
"\u0168": "U",
"\u0169": "u",
"\u016A": "U",
"\u016B": "u",
"\u016C": "U",
"\u016D": "u",
"\u016E": "U",
"\u016F": "u",
"\u0170": "U",
"\u0171": "u",
"\u0172": "U",
"\u0173": "u",
"\u0216": "U",
"\u0217": "u",
"V\u0306": "V",
"v\u0306": "v",
"\u0174": "W",
"\u0175": "w",
"\u1E82": "W",
"\u1E83": "w",
"X\u0306": "X",
"x\u0306": "x",
"\u0176": "Y",
"\u0177": "y",
"\u0178": "Y",
"Y\u0306": "Y",
"y\u0306": "y",
"\u0179": "Z",
"\u017A": "z",
"\u017B": "Z",
"\u017C": "z",
"\u017D": "Z",
"\u017E": "z",
"\u017F": "s",
"\u0192": "f",
"\u01A0": "O",
"\u01A1": "o",
"\u01AF": "U",
"\u01B0": "u",
"\u01CD": "A",
"\u01CE": "a",
"\u01CF": "I",
"\u01D0": "i",
"\u01D1": "O",
"\u01D2": "o",
"\u01D3": "U",
"\u01D4": "u",
"\u01D5": "U",
"\u01D6": "u",
"\u01D7": "U",
"\u01D8": "u",
"\u01D9": "U",
"\u01DA": "u",
"\u01DB": "U",
"\u01DC": "u",
"\u1EE8": "U",
"\u1EE9": "u",
"\u1E78": "U",
"\u1E79": "u",
"\u01FA": "A",
"\u01FB": "a",
"\u01FC": "AE",
"\u01FD": "ae",
"\u01FE": "O",
"\u01FF": "o",
"\xDE": "TH",
"\xFE": "th",
"\u1E54": "P",
"\u1E55": "p",
"\u1E64": "S",
"\u1E65": "s",
"X\u0301": "X",
"x\u0301": "x",
"\u0403": "\u0413",
"\u0453": "\u0433",
"\u040C": "\u041A",
"\u045C": "\u043A",
"A\u030B": "A",
"a\u030B": "a",
"E\u030B": "E",
"e\u030B": "e",
"I\u030B": "I",
"i\u030B": "i",
"\u01F8": "N",
"\u01F9": "n",
"\u1ED2": "O",
"\u1ED3": "o",
"\u1E50": "O",
"\u1E51": "o",
"\u1EEA": "U",
"\u1EEB": "u",
"\u1E80": "W",
"\u1E81": "w",
"\u1EF2": "Y",
"\u1EF3": "y",
"\u0200": "A",
"\u0201": "a",
"\u0204": "E",
"\u0205": "e",
"\u0208": "I",
"\u0209": "i",
"\u020C": "O",
"\u020D": "o",
"\u0210": "R",
"\u0211": "r",
"\u0214": "U",
"\u0215": "u",
"B\u030C": "B",
"b\u030C": "b",
"\u010C\u0323": "C",
"\u010D\u0323": "c",
"\xCA\u030C": "E",
"\xEA\u030C": "e",
"F\u030C": "F",
"f\u030C": "f",
"\u01E6": "G",
"\u01E7": "g",
"\u021E": "H",
"\u021F": "h",
"J\u030C": "J",
"\u01F0": "j",
"\u01E8": "K",
"\u01E9": "k",
"M\u030C": "M",
"m\u030C": "m",
"P\u030C": "P",
"p\u030C": "p",
"Q\u030C": "Q",
"q\u030C": "q",
"\u0158\u0329": "R",
"\u0159\u0329": "r",
"\u1E66": "S",
"\u1E67": "s",
"V\u030C": "V",
"v\u030C": "v",
"W\u030C": "W",
"w\u030C": "w",
"X\u030C": "X",
"x\u030C": "x",
"Y\u030C": "Y",
"y\u030C": "y",
"A\u0327": "A",
"a\u0327": "a",
"B\u0327": "B",
"b\u0327": "b",
"\u1E10": "D",
"\u1E11": "d",
"\u0228": "E",
"\u0229": "e",
"\u0190\u0327": "E",
"\u025B\u0327": "e",
"\u1E28": "H",
"\u1E29": "h",
"I\u0327": "I",
"i\u0327": "i",
"\u0197\u0327": "I",
"\u0268\u0327": "i",
"M\u0327": "M",
"m\u0327": "m",
"O\u0327": "O",
"o\u0327": "o",
"Q\u0327": "Q",
"q\u0327": "q",
"U\u0327": "U",
"u\u0327": "u",
"X\u0327": "X",
"x\u0327": "x",
"Z\u0327": "Z",
"z\u0327": "z",
"\u0439": "\u0438",
"\u0419": "\u0418",
"\u0451": "\u0435",
"\u0401": "\u0415"
};
var chars2 = Object.keys(characterMap).join("|");
var allAccents = new RegExp(chars2, "g");
var firstAccent = new RegExp(chars2, "");
function matcher(match4) {
return characterMap[match4];
}
var removeAccents5 = function(string) {
return string.replace(allAccents, matcher);
};
var hasAccents = function(string) {
return !!string.match(firstAccent);
};
module.exports = removeAccents5;
module.exports.has = hasAccents;
module.exports.remove = removeAccents5;
}
});
// package-external:@wordpress/rich-text
var require_rich_text = __commonJS({
"package-external:@wordpress/rich-text"(exports, module) {
module.exports = window.wp.richText;
}
});
// package-external:@wordpress/a11y
var require_a11y = __commonJS({
"package-external:@wordpress/a11y"(exports, module) {
module.exports = window.wp.a11y;
}
});
// package-external:@wordpress/keycodes
var require_keycodes = __commonJS({
"package-external:@wordpress/keycodes"(exports, module) {
module.exports = window.wp.keycodes;
}
});
// package-external:@wordpress/is-shallow-equal
var require_is_shallow_equal = __commonJS({
"package-external:@wordpress/is-shallow-equal"(exports, module) {
module.exports = window.wp.isShallowEqual;
}
});
// node_modules/gradient-parser/build/node.js
var require_node = __commonJS({
"node_modules/gradient-parser/build/node.js"(exports) {
var GradientParser = GradientParser || {};
GradientParser.stringify = /* @__PURE__ */ (function() {
var visitor = {
"visit_linear-gradient": function(node2) {
return visitor.visit_gradient(node2);
},
"visit_repeating-linear-gradient": function(node2) {
return visitor.visit_gradient(node2);
},
"visit_radial-gradient": function(node2) {
return visitor.visit_gradient(node2);
},
"visit_repeating-radial-gradient": function(node2) {
return visitor.visit_gradient(node2);
},
"visit_gradient": function(node2) {
var orientation = visitor.visit(node2.orientation);
if (orientation) {
orientation += ", ";
}
return node2.type + "(" + orientation + visitor.visit(node2.colorStops) + ")";
},
"visit_shape": function(node2) {
var result = node2.value, at = visitor.visit(node2.at), style2 = visitor.visit(node2.style);
if (style2) {
result += " " + style2;
}
if (at) {
result += " at " + at;
}
return result;
},
"visit_default-radial": function(node2) {
var result = "", at = visitor.visit(node2.at);
if (at) {
result += at;
}
return result;
},
"visit_extent-keyword": function(node2) {
var result = node2.value, at = visitor.visit(node2.at);
if (at) {
result += " at " + at;
}
return result;
},
"visit_position-keyword": function(node2) {
return node2.value;
},
"visit_position": function(node2) {
return visitor.visit(node2.value.x) + " " + visitor.visit(node2.value.y);
},
"visit_%": function(node2) {
return node2.value + "%";
},
"visit_em": function(node2) {
return node2.value + "em";
},
"visit_px": function(node2) {
return node2.value + "px";
},
"visit_calc": function(node2) {
return "calc(" + node2.value + ")";
},
"visit_literal": function(node2) {
return visitor.visit_color(node2.value, node2);
},
"visit_hex": function(node2) {
return visitor.visit_color("#" + node2.value, node2);
},
"visit_rgb": function(node2) {
return visitor.visit_color("rgb(" + node2.value.join(", ") + ")", node2);
},
"visit_rgba": function(node2) {
return visitor.visit_color("rgba(" + node2.value.join(", ") + ")", node2);
},
"visit_hsl": function(node2) {
return visitor.visit_color("hsl(" + node2.value[0] + ", " + node2.value[1] + "%, " + node2.value[2] + "%)", node2);
},
"visit_hsla": function(node2) {
return visitor.visit_color("hsla(" + node2.value[0] + ", " + node2.value[1] + "%, " + node2.value[2] + "%, " + node2.value[3] + ")", node2);
},
"visit_var": function(node2) {
return visitor.visit_color("var(" + node2.value + ")", node2);
},
"visit_color": function(resultColor, node2) {
var result = resultColor, length2 = visitor.visit(node2.length);
if (length2) {
result += " " + length2;
}
return result;
},
"visit_angular": function(node2) {
return node2.value + "deg";
},
"visit_directional": function(node2) {
return "to " + node2.value;
},
"visit_array": function(elements2) {
var result = "", size3 = elements2.length;
elements2.forEach(function(element, i3) {
result += visitor.visit(element);
if (i3 < size3 - 1) {
result += ", ";
}
});
return result;
},
"visit_object": function(obj) {
if (obj.width && obj.height) {
return visitor.visit(obj.width) + " " + visitor.visit(obj.height);
}
return "";
},
"visit": function(element) {
if (!element) {
return "";
}
var result = "";
if (element instanceof Array) {
return visitor.visit_array(element);
} else if (typeof element === "object" && !element.type) {
return visitor.visit_object(element);
} else if (element.type) {
var nodeVisitor = visitor["visit_" + element.type];
if (nodeVisitor) {
return nodeVisitor(element);
} else {
throw Error("Missing visitor visit_" + element.type);
}
} else {
throw Error("Invalid node.");
}
}
};
return function(root) {
return visitor.visit(root);
};
})();
var GradientParser = GradientParser || {};
GradientParser.parse = /* @__PURE__ */ (function() {
var tokens = {
linearGradient: /^(\-(webkit|o|ms|moz)\-)?(linear\-gradient)/i,
repeatingLinearGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-linear\-gradient)/i,
radialGradient: /^(\-(webkit|o|ms|moz)\-)?(radial\-gradient)/i,
repeatingRadialGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-radial\-gradient)/i,
sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
extentKeywords: /^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,
positionKeywords: /^(left|center|right|top|bottom)/i,
pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,
emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
radianValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))rad/,
startCall: /^\(/,
endCall: /^\)/,
comma: /^,/,
hexColor: /^\#([0-9a-fA-F]+)/,
literalColor: /^([a-zA-Z]+)/,
rgbColor: /^rgb/i,
rgbaColor: /^rgba/i,
varColor: /^var/i,
calcValue: /^calc/i,
variableName: /^(--[a-zA-Z0-9-,\s\#]+)/,
number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/,
hslColor: /^hsl/i,
hslaColor: /^hsla/i
};
var input = "";
function error(msg) {
var err = new Error(input + ": " + msg);
err.source = input;
throw err;
}
function getAST() {
var ast = matchListDefinitions();
if (input.length > 0) {
error("Invalid input not EOF");
}
return ast;
}
function matchListDefinitions() {
return matchListing(matchDefinition);
}
function matchDefinition() {
return matchGradient(
"linear-gradient",
tokens.linearGradient,
matchLinearOrientation
) || matchGradient(
"repeating-linear-gradient",
tokens.repeatingLinearGradient,
matchLinearOrientation
) || matchGradient(
"radial-gradient",
tokens.radialGradient,
matchListRadialOrientations
) || matchGradient(
"repeating-radial-gradient",
tokens.repeatingRadialGradient,
matchListRadialOrientations
);
}
function matchGradient(gradientType, pattern, orientationMatcher) {
return matchCall(pattern, function(captures) {
var orientation = orientationMatcher();
if (orientation) {
if (!scan(tokens.comma)) {
error("Missing comma before color stops");
}
}
return {
type: gradientType,
orientation,
colorStops: matchListing(matchColorStop)
};
});
}
function matchCall(pattern, callback) {
var captures = scan(pattern);
if (captures) {
if (!scan(tokens.startCall)) {
error("Missing (");
}
var result = callback(captures);
if (!scan(tokens.endCall)) {
error("Missing )");
}
return result;
}
}
function matchLinearOrientation() {
var sideOrCorner = matchSideOrCorner();
if (sideOrCorner) {
return sideOrCorner;
}
var legacyDirection = match4("position-keyword", tokens.positionKeywords, 1);
if (legacyDirection) {
return {
type: "directional",
value: legacyDirection.value
};
}
return matchAngle();
}
function matchSideOrCorner() {
return match4("directional", tokens.sideOrCorner, 1);
}
function matchAngle() {
return match4("angular", tokens.angleValue, 1) || match4("angular", tokens.radianValue, 1);
}
function matchListRadialOrientations() {
var radialOrientations, radialOrientation = matchRadialOrientation(), lookaheadCache;
if (radialOrientation) {
radialOrientations = [];
radialOrientations.push(radialOrientation);
lookaheadCache = input;
if (scan(tokens.comma)) {
radialOrientation = matchRadialOrientation();
if (radialOrientation) {
radialOrientations.push(radialOrientation);
} else {
input = lookaheadCache;
}
}
}
return radialOrientations;
}
function matchRadialOrientation() {
var radialType = matchCircle() || matchEllipse();
if (radialType) {
radialType.at = matchAtPosition();
} else {
var extent = matchExtentKeyword();
if (extent) {
radialType = extent;
var positionAt = matchAtPosition();
if (positionAt) {
radialType.at = positionAt;
}
} else {
var atPosition = matchAtPosition();
if (atPosition) {
radialType = {
type: "default-radial",
at: atPosition
};
} else {
var defaultPosition = matchPositioning();
if (defaultPosition) {
radialType = {
type: "default-radial",
at: defaultPosition
};
}
}
}
}
return radialType;
}
function matchCircle() {
var circle = match4("shape", /^(circle)/i, 0);
if (circle) {
circle.style = matchLength() || matchExtentKeyword();
}
return circle;
}
function matchEllipse() {
var ellipse = match4("shape", /^(ellipse)/i, 0);
if (ellipse) {
ellipse.style = matchPositioning() || matchDistance() || matchExtentKeyword();
}
return ellipse;
}
function matchExtentKeyword() {
return match4("extent-keyword", tokens.extentKeywords, 1);
}
function matchAtPosition() {
if (match4("position", /^at/, 0)) {
var positioning = matchPositioning();
if (!positioning) {
error("Missing positioning value");
}
return positioning;
}
}
function matchPositioning() {
var location = matchCoordinates();
if (location.x || location.y) {
return {
type: "position",
value: location
};
}
}
function matchCoordinates() {
return {
x: matchDistance(),
y: matchDistance()
};
}
function matchListing(matcher) {
var captures = matcher(), result = [];
if (captures) {
result.push(captures);
while (scan(tokens.comma)) {
captures = matcher();
if (captures) {
result.push(captures);
} else {
error("One extra comma");
}
}
}
return result;
}
function matchColorStop() {
var color2 = matchColor();
if (!color2) {
error("Expected color definition");
}
color2.length = matchDistance();
return color2;
}
function matchColor() {
return matchHexColor() || matchHSLAColor() || matchHSLColor() || matchRGBAColor() || matchRGBColor() || matchVarColor() || matchLiteralColor();
}
function matchLiteralColor() {
return match4("literal", tokens.literalColor, 0);
}
function matchHexColor() {
return match4("hex", tokens.hexColor, 1);
}
function matchRGBColor() {
return matchCall(tokens.rgbColor, function() {
return {
type: "rgb",
value: matchListing(matchNumber)
};
});
}
function matchRGBAColor() {
return matchCall(tokens.rgbaColor, function() {
return {
type: "rgba",
value: matchListing(matchNumber)
};
});
}
function matchVarColor() {
return matchCall(tokens.varColor, function() {
return {
type: "var",
value: matchVariableName()
};
});
}
function matchHSLColor() {
return matchCall(tokens.hslColor, function() {
var lookahead = scan(tokens.percentageValue);
if (lookahead) {
error("HSL hue value must be a number in degrees (0-360) or normalized (-360 to 360), not a percentage");
}
var hue = matchNumber();
scan(tokens.comma);
var captures = scan(tokens.percentageValue);
var sat = captures ? captures[1] : null;
scan(tokens.comma);
captures = scan(tokens.percentageValue);
var light = captures ? captures[1] : null;
if (!sat || !light) {
error("Expected percentage value for saturation and lightness in HSL");
}
return {
type: "hsl",
value: [hue, sat, light]
};
});
}
function matchHSLAColor() {
return matchCall(tokens.hslaColor, function() {
var hue = matchNumber();
scan(tokens.comma);
var captures = scan(tokens.percentageValue);
var sat = captures ? captures[1] : null;
scan(tokens.comma);
captures = scan(tokens.percentageValue);
var light = captures ? captures[1] : null;
scan(tokens.comma);
var alpha2 = matchNumber();
if (!sat || !light) {
error("Expected percentage value for saturation and lightness in HSLA");
}
return {
type: "hsla",
value: [hue, sat, light, alpha2]
};
});
}
function matchPercentage() {
var captures = scan(tokens.percentageValue);
return captures ? captures[1] : null;
}
function matchVariableName() {
return scan(tokens.variableName)[1];
}
function matchNumber() {
return scan(tokens.number)[1];
}
function matchDistance() {
return match4("%", tokens.percentageValue, 1) || matchPositionKeyword() || matchCalc() || matchLength();
}
function matchPositionKeyword() {
return match4("position-keyword", tokens.positionKeywords, 1);
}
function matchCalc() {
return matchCall(tokens.calcValue, function() {
var openParenCount = 1;
var i3 = 0;
while (openParenCount > 0 && i3 < input.length) {
var char2 = input.charAt(i3);
if (char2 === "(") {
openParenCount++;
} else if (char2 === ")") {
openParenCount--;
}
i3++;
}
if (openParenCount > 0) {
error("Missing closing parenthesis in calc() expression");
}
var calcContent = input.substring(0, i3 - 1);
consume(i3 - 1);
return {
type: "calc",
value: calcContent
};
});
}
function matchLength() {
return match4("px", tokens.pixelValue, 1) || match4("em", tokens.emValue, 1);
}
function match4(type, pattern, captureIndex) {
var captures = scan(pattern);
if (captures) {
return {
type,
value: captures[captureIndex]
};
}
}
function scan(regexp) {
var captures, blankCaptures;
blankCaptures = /^[\n\r\t\s]+/.exec(input);
if (blankCaptures) {
consume(blankCaptures[0].length);
}
captures = regexp.exec(input);
if (captures) {
consume(captures[0].length);
}
return captures;
}
function consume(size3) {
input = input.substr(size3);
}
return function(code) {
input = code.toString().trim();
if (input.endsWith(";")) {
input = input.slice(0, -1);
}
return getAST();
};
})();
exports.parse = GradientParser.parse;
exports.stringify = GradientParser.stringify;
}
});
// package-external:@wordpress/dom
var require_dom = __commonJS({
"package-external:@wordpress/dom"(exports, module) {
module.exports = window.wp.dom;
}
});
// package-external:@wordpress/date
var require_date = __commonJS({
"package-external:@wordpress/date"(exports, module) {
module.exports = window.wp.date;
}
});
// package-external:@wordpress/escape-html
var require_escape_html = __commonJS({
"package-external:@wordpress/escape-html"(exports, module) {
module.exports = window.wp.escapeHtml;
}
});
// package-external:@wordpress/html-entities
var require_html_entities = __commonJS({
"package-external:@wordpress/html-entities"(exports, module) {
module.exports = window.wp.htmlEntities;
}
});
// node_modules/fast-memoize/src/index.js
var require_src = __commonJS({
"node_modules/fast-memoize/src/index.js"(exports, module) {
function memoize3(fn, options2) {
var cache2 = options2 && options2.cache ? options2.cache : cacheDefault;
var serializer = options2 && options2.serializer ? options2.serializer : serializerDefault;
var strategy = options2 && options2.strategy ? options2.strategy : strategyDefault;
return strategy(fn, {
cache: cache2,
serializer
});
}
function isPrimitive(value) {
return value == null || typeof value === "number" || typeof value === "boolean";
}
function monadic(fn, cache2, serializer, arg) {
var cacheKey = isPrimitive(arg) ? arg : serializer(arg);
var computedValue = cache2.get(cacheKey);
if (typeof computedValue === "undefined") {
computedValue = fn.call(this, arg);
cache2.set(cacheKey, computedValue);
}
return computedValue;
}
function variadic(fn, cache2, serializer) {
var args = Array.prototype.slice.call(arguments, 3);
var cacheKey = serializer(args);
var computedValue = cache2.get(cacheKey);
if (typeof computedValue === "undefined") {
computedValue = fn.apply(this, args);
cache2.set(cacheKey, computedValue);
}
return computedValue;
}
function assemble(fn, context, strategy, cache2, serialize2) {
return strategy.bind(
context,
fn,
cache2,
serialize2
);
}
function strategyDefault(fn, options2) {
var strategy = fn.length === 1 ? monadic : variadic;
return assemble(
fn,
this,
strategy,
options2.cache.create(),
options2.serializer
);
}
function strategyVariadic(fn, options2) {
var strategy = variadic;
return assemble(
fn,
this,
strategy,
options2.cache.create(),
options2.serializer
);
}
function strategyMonadic(fn, options2) {
var strategy = monadic;
return assemble(
fn,
this,
strategy,
options2.cache.create(),
options2.serializer
);
}
function serializerDefault() {
return JSON.stringify(arguments);
}
function ObjectWithoutPrototypeCache() {
this.cache = /* @__PURE__ */ Object.create(null);
}
ObjectWithoutPrototypeCache.prototype.has = function(key) {
return key in this.cache;
};
ObjectWithoutPrototypeCache.prototype.get = function(key) {
return this.cache[key];
};
ObjectWithoutPrototypeCache.prototype.set = function(key, value) {
this.cache[key] = value;
};
var cacheDefault = {
create: function create2() {
return new ObjectWithoutPrototypeCache();
}
};
module.exports = memoize3;
module.exports.strategies = {
variadic: strategyVariadic,
monadic: strategyMonadic
};
}
});
// package-external:@wordpress/hooks
var require_hooks = __commonJS({
"package-external:@wordpress/hooks"(exports, module) {
module.exports = window.wp.hooks;
}
});
// package-external:@wordpress/private-apis
var require_private_apis = __commonJS({
"package-external:@wordpress/private-apis"(exports, module) {
module.exports = window.wp.privateApis;
}
});
// packages/components/build-module/index.mjs
var index_exports = {};
__export(index_exports, {
AlignmentMatrixControl: () => alignment_matrix_control_default,
AnglePickerControl: () => angle_picker_control_default,
Animate: () => animate_default,
Autocomplete: () => Autocomplete,
BaseControl: () => base_control_default,
BlockQuotation: () => import_primitives36.BlockQuotation,
BorderBoxControl: () => component_default24,
BorderControl: () => component_default21,
BoxControl: () => box_control_default,
Button: () => button_default,
ButtonGroup: () => button_group_default,
Card: () => component_default27,
CardBody: () => component_default29,
CardDivider: () => component_default31,
CardFooter: () => component_default32,
CardHeader: () => component_default33,
CardMedia: () => component_default34,
CheckboxControl: () => checkbox_control_default,
Circle: () => import_primitives36.Circle,
ClipboardButton: () => ClipboardButton,
ColorIndicator: () => color_indicator_default,
ColorPalette: () => color_palette_default,
ColorPicker: () => LegacyAdapter,
ComboboxControl: () => combobox_control_default,
Composite: () => Composite22,
CustomGradientPicker: () => custom_gradient_picker_default,
CustomSelectControl: () => custom_select_control_default,
Dashicon: () => dashicon_default,
DatePicker: () => date_default,
DateTimePicker: () => date_time_default2,
Disabled: () => disabled_default,
Draggable: () => draggable_default,
DropZone: () => drop_zone_default,
DropZoneProvider: () => DropZoneProvider,
Dropdown: () => dropdown_default,
DropdownMenu: () => dropdown_menu_default,
DuotonePicker: () => duotone_picker_default,
DuotoneSwatch: () => duotone_swatch_default,
ExternalLink: () => external_link_default,
Fill: () => Fill,
Flex: () => component_default3,
FlexBlock: () => component_default5,
FlexItem: () => component_default4,
FocalPointPicker: () => focal_point_picker_default,
FocusReturnProvider: () => Provider3,
FocusableIframe: () => FocusableIframe,
FontSizePicker: () => font_size_picker_default,
FormFileUpload: () => form_file_upload_default,
FormToggle: () => form_toggle_default,
FormTokenField: () => form_token_field_default,
G: () => import_primitives36.G,
GradientPicker: () => gradient_picker_default,
Guide: () => guide_default,
GuidePage: () => GuidePage,
HorizontalRule: () => import_primitives36.HorizontalRule,
Icon: () => icon_default3,
IconButton: () => deprecated_default,
IsolatedEventContainer: () => isolated_event_container_default,
KeyboardShortcuts: () => keyboard_shortcuts_default,
Line: () => import_primitives36.Line,
MenuGroup: () => menu_group_default,
MenuItem: () => menu_item_default,
MenuItemsChoice: () => menu_items_choice_default,
Modal: () => modal_default,
NavigableMenu: () => menu_default2,
Navigator: () => Navigator3,
Notice: () => notice_default,
NoticeList: () => list_default,
Panel: () => panel_default,
PanelBody: () => body_default,
PanelHeader: () => header_default,
PanelRow: () => row_default,
Path: () => import_primitives36.Path,
Placeholder: () => placeholder_default,
Polygon: () => import_primitives36.Polygon,
Popover: () => popover_default,
ProgressBar: () => progress_bar_default,
QueryControls: () => query_controls_default,
RadioControl: () => radio_control_default,
RangeControl: () => range_control_default,
Rect: () => import_primitives36.Rect,
ResizableBox: () => resizable_box_default,
ResponsiveWrapper: () => responsive_wrapper_default,
SVG: () => import_primitives36.SVG,
SandBox: () => sandbox_default,
ScrollLock: () => scroll_lock_default,
SearchControl: () => search_control_default,
SelectControl: () => select_control_default,
Slot: () => Slot3,
SlotFillProvider: () => Provider,
Snackbar: () => snackbar_default,
SnackbarList: () => list_default2,
Spinner: () => spinner_default,
TabPanel: () => tab_panel_default,
TabbableContainer: () => tabbable_default,
TextControl: () => text_control_default,
TextHighlight: () => text_highlight_default,
TextareaControl: () => textarea_control_default,
TimePicker: () => time_default,
Tip: () => tip_default2,
ToggleControl: () => toggle_control_default,
Toolbar: () => toolbar_default,
ToolbarButton: () => toolbar_button_default,
ToolbarDropdownMenu: () => toolbar_dropdown_menu_default,
ToolbarGroup: () => toolbar_group_default,
ToolbarItem: () => toolbar_item_default,
Tooltip: () => tooltip_default,
TreeSelect: () => tree_select_default,
VisuallyHidden: () => component_default2,
__experimentalAlignmentMatrixControl: () => alignment_matrix_control_default,
__experimentalApplyValueToSides: () => applyValueToSides,
__experimentalBorderBoxControl: () => component_default24,
__experimentalBorderControl: () => component_default21,
__experimentalBoxControl: () => box_control_default,
__experimentalConfirmDialog: () => component_default37,
__experimentalDivider: () => component_default30,
__experimentalDropdownContentWrapper: () => dropdown_content_wrapper_default,
__experimentalElevation: () => component_default25,
__experimentalGrid: () => component_default22,
__experimentalHStack: () => component_default9,
__experimentalHasSplitBorders: () => hasSplitBorders,
__experimentalHeading: () => component_default19,
__experimentalInputControl: () => input_control_default,
__experimentalInputControlPrefixWrapper: () => input_prefix_wrapper_default,
__experimentalInputControlSuffixWrapper: () => input_suffix_wrapper_default,
__experimentalIsDefinedBorder: () => isDefinedBorder,
__experimentalIsEmptyBorder: () => isEmptyBorder,
__experimentalItem: () => component_default35,
__experimentalItemGroup: () => component_default36,
__experimentalNavigation: () => navigation_default,
__experimentalNavigationBackButton: () => back_button_default,
__experimentalNavigationGroup: () => group_default,
__experimentalNavigationItem: () => item_default2,
__experimentalNavigationMenu: () => menu_default3,
__experimentalNavigatorBackButton: () => NavigatorBackButton2,
__experimentalNavigatorButton: () => NavigatorButton2,
__experimentalNavigatorProvider: () => NavigatorProvider,
__experimentalNavigatorScreen: () => NavigatorScreen2,
__experimentalNavigatorToParentButton: () => NavigatorToParentButton2,
__experimentalNumberControl: () => number_control_default,
__experimentalPaletteEdit: () => palette_edit_default,
__experimentalParseQuantityAndUnitFromRawValue: () => parseQuantityAndUnitFromRawValue,
__experimentalRadio: () => radio_default,
__experimentalRadioGroup: () => radio_group_default,
__experimentalScrollable: () => component_default28,
__experimentalSpacer: () => component_default6,
__experimentalStyleProvider: () => style_provider_default,
__experimentalSurface: () => component_default26,
__experimentalText: () => component_default8,
__experimentalToggleGroupControl: () => component_default12,
__experimentalToggleGroupControlOption: () => component_default14,
__experimentalToggleGroupControlOptionIcon: () => component_default15,
__experimentalToolbarContext: () => toolbar_context_default,
__experimentalToolsPanel: () => component_default39,
__experimentalToolsPanelContext: () => ToolsPanelContext,
__experimentalToolsPanelItem: () => component_default40,
__experimentalTreeGrid: () => tree_grid_default,
__experimentalTreeGridCell: () => cell_default,
__experimentalTreeGridItem: () => item_default3,
__experimentalTreeGridRow: () => row_default2,
__experimentalTruncate: () => component_default7,
__experimentalUnitControl: () => unit_control_default,
__experimentalUseCustomUnits: () => useCustomUnits,
__experimentalUseNavigator: () => useNavigator,
__experimentalUseSlot: () => useSlot,
__experimentalUseSlotFills: () => useSlotFills,
__experimentalVStack: () => component_default18,
__experimentalView: () => component_default,
__experimentalZStack: () => component_default41,
__unstableAnimatePresence: () => AnimatePresence,
__unstableComposite: () => Composite4,
__unstableCompositeGroup: () => CompositeGroup4,
__unstableCompositeItem: () => CompositeItem4,
__unstableDisclosureContent: () => DisclosureContent22,
__unstableGetAnimateClassName: () => getAnimateClassName,
__unstableMotion: () => motion,
__unstableUseAutocompleteProps: () => useAutocompleteProps,
__unstableUseCompositeState: () => useCompositeState,
__unstableUseNavigateRegions: () => useNavigateRegions,
createSlotFill: () => createSlotFill,
navigateRegions: () => navigate_regions_default,
privateApis: () => privateApis,
useBaseControlProps: () => useBaseControlProps,
useNavigator: () => useNavigator,
withConstrainedTabbing: () => with_constrained_tabbing_default,
withFallbackStyles: () => with_fallback_styles_default,
withFilters: () => withFilters,
withFocusOutside: () => with_focus_outside_default,
withFocusReturn: () => with_focus_return_default,
withNotices: () => with_notices_default,
withSpokenMessages: () => with_spoken_messages_default
});
var import_primitives36 = __toESM(require_primitives(), 1);
// node_modules/clsx/dist/clsx.mjs
function r(e3) {
var t4, f3, n3 = "";
if ("string" == typeof e3 || "number" == typeof e3) n3 += e3;
else if ("object" == typeof e3) if (Array.isArray(e3)) {
var o4 = e3.length;
for (t4 = 0; t4 < o4; t4++) e3[t4] && (f3 = r(e3[t4])) && (n3 && (n3 += " "), n3 += f3);
} else for (f3 in e3) e3[f3] && (n3 && (n3 += " "), n3 += f3);
return n3;
}
function clsx() {
for (var e3, t4, f3 = 0, n3 = "", o4 = arguments.length; f3 < o4; f3++) (e3 = arguments[f3]) && (t4 = r(e3)) && (n3 && (n3 += " "), n3 += t4);
return n3;
}
var clsx_default = clsx;
// packages/components/build-module/alignment-matrix-control/index.mjs
var import_i18n4 = __toESM(require_i18n(), 1);
var import_compose2 = __toESM(require_compose(), 1);
var import_element18 = __toESM(require_element(), 1);
// node_modules/@ariakit/core/esm/__chunks/XMCVU3LR.js
function noop(..._2) {
}
function shallowEqual(a3, b3) {
if (a3 === b3) return true;
if (!a3) return false;
if (!b3) return false;
if (typeof a3 !== "object") return false;
if (typeof b3 !== "object") return false;
const aKeys = Object.keys(a3);
const bKeys = Object.keys(b3);
const { length: length2 } = aKeys;
if (bKeys.length !== length2) return false;
for (const key of aKeys) {
if (a3[key] !== b3[key]) {
return false;
}
}
return true;
}
function applyState(argument, currentValue) {
if (isUpdater(argument)) {
const value = isLazyValue(currentValue) ? currentValue() : currentValue;
return argument(value);
}
return argument;
}
function isUpdater(argument) {
return typeof argument === "function";
}
function isLazyValue(value) {
return typeof value === "function";
}
function hasOwnProperty(object, prop) {
if (typeof Object.hasOwn === "function") {
return Object.hasOwn(object, prop);
}
return Object.prototype.hasOwnProperty.call(object, prop);
}
function chain(...fns) {
return (...args) => {
for (const fn of fns) {
if (typeof fn === "function") {
fn(...args);
}
}
};
}
function normalizeString(str) {
return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
}
function omit(object, keys) {
const result = { ...object };
for (const key of keys) {
if (hasOwnProperty(result, key)) {
delete result[key];
}
}
return result;
}
function pick(object, paths) {
const result = {};
for (const key of paths) {
if (hasOwnProperty(object, key)) {
result[key] = object[key];
}
}
return result;
}
function identity(value) {
return value;
}
function invariant(condition, message2) {
if (condition) return;
if (typeof message2 !== "string") throw new Error("Invariant failed");
throw new Error(message2);
}
function getKeys(obj) {
return Object.keys(obj);
}
function isFalsyBooleanCallback(booleanOrCallback, ...args) {
const result = typeof booleanOrCallback === "function" ? booleanOrCallback(...args) : booleanOrCallback;
if (result == null) return false;
return !result;
}
function disabledFromProps(props) {
return props.disabled || props["aria-disabled"] === true || props["aria-disabled"] === "true";
}
function removeUndefinedValues(obj) {
const result = {};
for (const key in obj) {
if (obj[key] !== void 0) {
result[key] = obj[key];
}
}
return result;
}
function defaultValue(...values) {
for (const value of values) {
if (value !== void 0) return value;
}
return void 0;
}
// node_modules/@ariakit/react-core/esm/__chunks/YXGXYGQX.js
var import_react = __toESM(require_react(), 1);
function setRef(ref, value) {
if (typeof ref === "function") {
ref(value);
} else if (ref) {
ref.current = value;
}
}
function isValidElementWithRef(element) {
if (!element) return false;
if (!(0, import_react.isValidElement)(element)) return false;
if ("ref" in element.props) return true;
if ("ref" in element) return true;
return false;
}
function getRefProperty(element) {
if (!isValidElementWithRef(element)) return null;
const props = { ...element.props };
return props.ref || element.ref;
}
function mergeProps(base, overrides) {
const props = { ...base };
for (const key in overrides) {
if (!hasOwnProperty(overrides, key)) continue;
if (key === "className") {
const prop = "className";
props[prop] = base[prop] ? `${base[prop]} ${overrides[prop]}` : overrides[prop];
continue;
}
if (key === "style") {
const prop = "style";
props[prop] = base[prop] ? { ...base[prop], ...overrides[prop] } : overrides[prop];
continue;
}
const overrideValue = overrides[key];
if (typeof overrideValue === "function" && key.startsWith("on")) {
const baseValue = base[key];
if (typeof baseValue === "function") {
props[key] = (...args) => {
overrideValue(...args);
baseValue(...args);
};
continue;
}
}
props[key] = overrideValue;
}
return props;
}
// node_modules/@ariakit/core/esm/__chunks/3DNM6L6E.js
var canUseDOM = checkIsBrowser();
function checkIsBrowser() {
var _a;
return typeof window !== "undefined" && !!((_a = window.document) == null ? void 0 : _a.createElement);
}
function getDocument(node2) {
if (!node2) return document;
if ("self" in node2) return node2.document;
return node2.ownerDocument || document;
}
function getWindow(node2) {
if (!node2) return self;
if ("self" in node2) return node2.self;
return getDocument(node2).defaultView || window;
}
function getActiveElement(node2, activeDescendant = false) {
var _a;
const { activeElement } = getDocument(node2);
if (!(activeElement == null ? void 0 : activeElement.nodeName)) {
return null;
}
if (isFrame(activeElement) && ((_a = activeElement.contentDocument) == null ? void 0 : _a.body)) {
return getActiveElement(
activeElement.contentDocument.body,
activeDescendant
);
}
if (activeDescendant) {
const id3 = activeElement.getAttribute("aria-activedescendant");
if (id3) {
const element = getDocument(activeElement).getElementById(id3);
if (element) {
return element;
}
}
}
return activeElement;
}
function contains(parent, child) {
return parent === child || parent.contains(child);
}
function isFrame(element) {
return element.tagName === "IFRAME";
}
function isButton(element) {
const tagName = element.tagName.toLowerCase();
if (tagName === "button") return true;
if (tagName === "input" && element.type) {
return buttonInputTypes.indexOf(element.type) !== -1;
}
return false;
}
var buttonInputTypes = [
"button",
"color",
"file",
"image",
"reset",
"submit"
];
function isVisible(element) {
if (typeof element.checkVisibility === "function") {
return element.checkVisibility();
}
const htmlElement = element;
return htmlElement.offsetWidth > 0 || htmlElement.offsetHeight > 0 || element.getClientRects().length > 0;
}
function isTextField(element) {
try {
const isTextInput = element instanceof HTMLInputElement && element.selectionStart !== null;
const isTextArea = element.tagName === "TEXTAREA";
return isTextInput || isTextArea || false;
} catch (_error) {
return false;
}
}
function isTextbox(element) {
return element.isContentEditable || isTextField(element);
}
function getTextboxValue(element) {
if (isTextField(element)) {
return element.value;
}
if (element.isContentEditable) {
const range = getDocument(element).createRange();
range.selectNodeContents(element);
return range.toString();
}
return "";
}
function getTextboxSelection(element) {
let start = 0;
let end = 0;
if (isTextField(element)) {
start = element.selectionStart || 0;
end = element.selectionEnd || 0;
} else if (element.isContentEditable) {
const selection = getDocument(element).getSelection();
if ((selection == null ? void 0 : selection.rangeCount) && selection.anchorNode && contains(element, selection.anchorNode) && selection.focusNode && contains(element, selection.focusNode)) {
const range = selection.getRangeAt(0);
const nextRange = range.cloneRange();
nextRange.selectNodeContents(element);
nextRange.setEnd(range.startContainer, range.startOffset);
start = nextRange.toString().length;
nextRange.setEnd(range.endContainer, range.endOffset);
end = nextRange.toString().length;
}
}
return { start, end };
}
function getPopupRole(element, fallback) {
const allowedPopupRoles = ["dialog", "menu", "listbox", "tree", "grid"];
const role = element == null ? void 0 : element.getAttribute("role");
if (role && allowedPopupRoles.indexOf(role) !== -1) {
return role;
}
return fallback;
}
function getPopupItemRole(element, fallback) {
var _a;
const itemRoleByPopupRole = {
menu: "menuitem",
listbox: "option",
tree: "treeitem"
};
const popupRole = getPopupRole(element);
if (!popupRole) return fallback;
const key = popupRole;
return (_a = itemRoleByPopupRole[key]) != null ? _a : fallback;
}
function getScrollingElement(element) {
if (!element) return null;
const isScrollableOverflow = (overflow) => {
if (overflow === "auto") return true;
if (overflow === "scroll") return true;
return false;
};
if (element.clientHeight && element.scrollHeight > element.clientHeight) {
const { overflowY } = getComputedStyle(element);
if (isScrollableOverflow(overflowY)) return element;
} else if (element.clientWidth && element.scrollWidth > element.clientWidth) {
const { overflowX } = getComputedStyle(element);
if (isScrollableOverflow(overflowX)) return element;
}
return getScrollingElement(element.parentElement) || document.scrollingElement || document.body;
}
function sortBasedOnDOMPosition(items, getElement) {
const pairs = items.map((item2, index2) => [index2, item2]);
let isOrderDifferent = false;
pairs.sort(([indexA, a3], [indexB, b3]) => {
const elementA = getElement(a3);
const elementB = getElement(b3);
if (elementA === elementB) return 0;
if (!elementA || !elementB) return 0;
if (isElementPreceding(elementA, elementB)) {
if (indexA > indexB) {
isOrderDifferent = true;
}
return -1;
}
if (indexA < indexB) {
isOrderDifferent = true;
}
return 1;
});
if (isOrderDifferent) {
return pairs.map(([_2, item2]) => item2);
}
return items;
}
function isElementPreceding(a3, b3) {
return Boolean(
b3.compareDocumentPosition(a3) & Node.DOCUMENT_POSITION_PRECEDING
);
}
// node_modules/@ariakit/core/esm/__chunks/SNHYQNEZ.js
function isTouchDevice() {
return canUseDOM && !!navigator.maxTouchPoints;
}
function isApple() {
if (!canUseDOM) return false;
return /mac|iphone|ipad|ipod/i.test(navigator.platform);
}
function isSafari() {
return canUseDOM && isApple() && /apple/i.test(navigator.vendor);
}
function isFirefox() {
return canUseDOM && /firefox\//i.test(navigator.userAgent);
}
function isMac() {
return canUseDOM && navigator.platform.startsWith("Mac") && !isTouchDevice();
}
// node_modules/@ariakit/core/esm/utils/events.js
function isPortalEvent(event) {
return Boolean(
event.currentTarget && !contains(event.currentTarget, event.target)
);
}
function isSelfTarget(event) {
return event.target === event.currentTarget;
}
function isOpeningInNewTab(event) {
const element = event.currentTarget;
if (!element) return false;
const isAppleDevice = isApple();
if (isAppleDevice && !event.metaKey) return false;
if (!isAppleDevice && !event.ctrlKey) return false;
const tagName = element.tagName.toLowerCase();
if (tagName === "a") return true;
if (tagName === "button" && element.type === "submit") return true;
if (tagName === "input" && element.type === "submit") return true;
return false;
}
function isDownloading(event) {
const element = event.currentTarget;
if (!element) return false;
const tagName = element.tagName.toLowerCase();
if (!event.altKey) return false;
if (tagName === "a") return true;
if (tagName === "button" && element.type === "submit") return true;
if (tagName === "input" && element.type === "submit") return true;
return false;
}
function fireEvent(element, type, eventInit) {
const event = new Event(type, eventInit);
return element.dispatchEvent(event);
}
function fireBlurEvent(element, eventInit) {
const event = new FocusEvent("blur", eventInit);
const defaultAllowed = element.dispatchEvent(event);
const bubbleInit = { ...eventInit, bubbles: true };
element.dispatchEvent(new FocusEvent("focusout", bubbleInit));
return defaultAllowed;
}
function fireKeyboardEvent(element, type, eventInit) {
const event = new KeyboardEvent(type, eventInit);
return element.dispatchEvent(event);
}
function fireClickEvent(element, eventInit) {
const event = new MouseEvent("click", eventInit);
return element.dispatchEvent(event);
}
function isFocusEventOutside(event, container) {
const containerElement = container || event.currentTarget;
const relatedTarget = event.relatedTarget;
return !relatedTarget || !contains(containerElement, relatedTarget);
}
function queueBeforeEvent(element, type, callback, timeout) {
const createTimer = (callback2) => {
if (timeout) {
const timerId2 = setTimeout(callback2, timeout);
return () => clearTimeout(timerId2);
}
const timerId = requestAnimationFrame(callback2);
return () => cancelAnimationFrame(timerId);
};
const cancelTimer = createTimer(() => {
element.removeEventListener(type, callSync, true);
callback();
});
const callSync = () => {
cancelTimer();
callback();
};
element.addEventListener(type, callSync, { once: true, capture: true });
return cancelTimer;
}
function addGlobalEventListener(type, listener, options2, scope = window) {
const children = [];
try {
scope.document.addEventListener(type, listener, options2);
for (const frame2 of Array.from(scope.frames)) {
children.push(addGlobalEventListener(type, listener, options2, frame2));
}
} catch (e3) {
}
const removeEventListener = () => {
try {
scope.document.removeEventListener(type, listener, options2);
} catch (e3) {
}
for (const remove of children) {
remove();
}
};
return removeEventListener;
}
// node_modules/@ariakit/react-core/esm/__chunks/KPHZR4MB.js
var React = __toESM(require_react(), 1);
var import_react2 = __toESM(require_react(), 1);
var _React = { ...React };
var useReactId = _React.useId;
var useReactDeferredValue = _React.useDeferredValue;
var useReactInsertionEffect = _React.useInsertionEffect;
var useSafeLayoutEffect = canUseDOM ? import_react2.useLayoutEffect : import_react2.useEffect;
function useInitialValue(value) {
const [initialValue2] = (0, import_react2.useState)(value);
return initialValue2;
}
function useLiveRef(value) {
const ref = (0, import_react2.useRef)(value);
useSafeLayoutEffect(() => {
ref.current = value;
});
return ref;
}
function useEvent(callback) {
const ref = (0, import_react2.useRef)(() => {
throw new Error("Cannot call an event handler while rendering.");
});
if (useReactInsertionEffect) {
useReactInsertionEffect(() => {
ref.current = callback;
});
} else {
ref.current = callback;
}
return (0, import_react2.useCallback)((...args) => {
var _a;
return (_a = ref.current) == null ? void 0 : _a.call(ref, ...args);
}, []);
}
function useTransactionState(callback) {
const [state, setState] = (0, import_react2.useState)(null);
useSafeLayoutEffect(() => {
if (state == null) return;
if (!callback) return;
let prevState = null;
callback((prev2) => {
prevState = prev2;
return state;
});
return () => {
callback(prevState);
};
}, [state, callback]);
return [state, setState];
}
function useMergeRefs(...refs) {
return (0, import_react2.useMemo)(() => {
if (!refs.some(Boolean)) return;
return (value) => {
for (const ref of refs) {
setRef(ref, value);
}
};
}, refs);
}
function useId(defaultId) {
if (useReactId) {
const reactId = useReactId();
if (defaultId) return defaultId;
return reactId;
}
const [id3, setId] = (0, import_react2.useState)(defaultId);
useSafeLayoutEffect(() => {
if (defaultId || id3) return;
const random = Math.random().toString(36).slice(2, 8);
setId(`id-${random}`);
}, [defaultId, id3]);
return defaultId || id3;
}
function useTagName(refOrElement, type) {
const stringOrUndefined = (type2) => {
if (typeof type2 !== "string") return;
return type2;
};
const [tagName, setTagName] = (0, import_react2.useState)(() => stringOrUndefined(type));
useSafeLayoutEffect(() => {
const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
setTagName((element == null ? void 0 : element.tagName.toLowerCase()) || stringOrUndefined(type));
}, [refOrElement, type]);
return tagName;
}
function useAttribute(refOrElement, attributeName, defaultValue2) {
const initialValue2 = useInitialValue(defaultValue2);
const [attribute, setAttribute2] = (0, import_react2.useState)(initialValue2);
(0, import_react2.useEffect)(() => {
const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
if (!element) return;
const callback = () => {
const value = element.getAttribute(attributeName);
setAttribute2(value == null ? initialValue2 : value);
};
const observer = new MutationObserver(callback);
observer.observe(element, { attributeFilter: [attributeName] });
callback();
return () => observer.disconnect();
}, [refOrElement, attributeName, initialValue2]);
return attribute;
}
function useUpdateEffect(effect, deps) {
const mounted = (0, import_react2.useRef)(false);
(0, import_react2.useEffect)(() => {
if (mounted.current) {
return effect();
}
mounted.current = true;
}, deps);
(0, import_react2.useEffect)(
() => () => {
mounted.current = false;
},
[]
);
}
function useForceUpdate() {
return (0, import_react2.useReducer)(() => [], []);
}
function useBooleanEvent(booleanOrCallback) {
return useEvent(
typeof booleanOrCallback === "function" ? booleanOrCallback : () => booleanOrCallback
);
}
function useWrapElement(props, callback, deps = []) {
const wrapElement = (0, import_react2.useCallback)(
(element) => {
if (props.wrapElement) {
element = props.wrapElement(element);
}
return callback(element);
},
[...deps, props.wrapElement]
);
return { ...props, wrapElement };
}
function usePortalRef(portalProp = false, portalRefProp) {
const [portalNode, setPortalNode] = (0, import_react2.useState)(null);
const portalRef = useMergeRefs(setPortalNode, portalRefProp);
const domReady = !portalProp || portalNode;
return { portalRef, portalNode, domReady };
}
function useMetadataProps(props, key, value) {
const parent = props.onLoadedMetadataCapture;
const onLoadedMetadataCapture = (0, import_react2.useMemo)(() => {
return Object.assign(() => {
}, { ...parent, [key]: value });
}, [parent, key, value]);
return [parent == null ? void 0 : parent[key], { onLoadedMetadataCapture }];
}
var hasInstalledGlobalEventListeners = false;
function useIsMouseMoving() {
(0, import_react2.useEffect)(() => {
if (hasInstalledGlobalEventListeners) return;
addGlobalEventListener("mousemove", setMouseMoving, true);
addGlobalEventListener("mousedown", resetMouseMoving, true);
addGlobalEventListener("mouseup", resetMouseMoving, true);
addGlobalEventListener("keydown", resetMouseMoving, true);
addGlobalEventListener("scroll", resetMouseMoving, true);
hasInstalledGlobalEventListeners = true;
}, []);
const isMouseMoving = useEvent(() => mouseMoving);
return isMouseMoving;
}
var mouseMoving = false;
var previousScreenX = 0;
var previousScreenY = 0;
function hasMouseMovement(event) {
const movementX = event.movementX || event.screenX - previousScreenX;
const movementY = event.movementY || event.screenY - previousScreenY;
previousScreenX = event.screenX;
previousScreenY = event.screenY;
return movementX || movementY || false;
}
function setMouseMoving(event) {
if (!hasMouseMovement(event)) return;
mouseMoving = true;
}
function resetMouseMoving() {
mouseMoving = false;
}
// node_modules/@ariakit/react-core/esm/__chunks/GWSL6KNJ.js
var React2 = __toESM(require_react(), 1);
var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
function forwardRef2(render) {
const Role3 = React2.forwardRef(
// @ts-ignore Incompatible with React 19 types. Ignore for now.
(props, ref) => render({ ...props, ref })
);
Role3.displayName = render.displayName || render.name;
return Role3;
}
function memo2(Component9, propsAreEqual) {
return React2.memo(Component9, propsAreEqual);
}
function createElement(Type, props) {
const { wrapElement, render, ...rest } = props;
const mergedRef = useMergeRefs(props.ref, getRefProperty(render));
let element;
if (React2.isValidElement(render)) {
const renderProps = {
// @ts-ignore Incompatible with React 19 types. Ignore for now.
...render.props,
ref: mergedRef
};
element = React2.cloneElement(render, mergeProps(rest, renderProps));
} else if (render) {
element = render(rest);
} else {
element = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Type, { ...rest });
}
if (wrapElement) {
return wrapElement(element);
}
return element;
}
function createHook(useProps) {
const useRole3 = (props = {}) => {
return useProps(props);
};
useRole3.displayName = useProps.name;
return useRole3;
}
function createStoreContext(providers = [], scopedProviders = []) {
const context = React2.createContext(void 0);
const scopedContext = React2.createContext(void 0);
const useContext210 = () => React2.useContext(context);
const useScopedContext = (onlyScoped = false) => {
const scoped = React2.useContext(scopedContext);
const store = useContext210();
if (onlyScoped) return scoped;
return scoped || store;
};
const useProviderContext = () => {
const scoped = React2.useContext(scopedContext);
const store = useContext210();
if (scoped && scoped === store) return;
return store;
};
const ContextProvider = (props) => {
return providers.reduceRight(
(children, Provider4) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Provider4, { ...props, children }),
/* @__PURE__ */ (0, import_jsx_runtime.jsx)(context.Provider, { ...props })
);
};
const ScopedContextProvider = (props) => {
return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ContextProvider, { ...props, children: scopedProviders.reduceRight(
(children, Provider4) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Provider4, { ...props, children }),
/* @__PURE__ */ (0, import_jsx_runtime.jsx)(scopedContext.Provider, { ...props })
) });
};
return {
context,
scopedContext,
useContext: useContext210,
useScopedContext,
useProviderContext,
ContextProvider,
ScopedContextProvider
};
}
// node_modules/@ariakit/react-core/esm/__chunks/SMPCIMZM.js
var ctx = createStoreContext();
var useCollectionContext = ctx.useContext;
var useCollectionScopedContext = ctx.useScopedContext;
var useCollectionProviderContext = ctx.useProviderContext;
var CollectionContextProvider = ctx.ContextProvider;
var CollectionScopedContextProvider = ctx.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/AVVXDJMZ.js
var import_react3 = __toESM(require_react(), 1);
var ctx2 = createStoreContext(
[CollectionContextProvider],
[CollectionScopedContextProvider]
);
var useCompositeContext = ctx2.useContext;
var useCompositeScopedContext = ctx2.useScopedContext;
var useCompositeProviderContext = ctx2.useProviderContext;
var CompositeContextProvider = ctx2.ContextProvider;
var CompositeScopedContextProvider = ctx2.ScopedContextProvider;
var CompositeItemContext = (0, import_react3.createContext)(
void 0
);
var CompositeRowContext = (0, import_react3.createContext)(
void 0
);
// node_modules/@ariakit/react-core/esm/__chunks/NF43FNG5.js
var ctx3 = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var useTabContext = ctx3.useContext;
var useTabScopedContext = ctx3.useScopedContext;
var useTabProviderContext = ctx3.useProviderContext;
var TabContextProvider = ctx3.ContextProvider;
var TabScopedContextProvider = ctx3.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/5VQZOHHZ.js
var NULL_ITEM = { id: null };
function flipItems(items, activeId, shouldInsertNullItem = false) {
const index2 = items.findIndex((item2) => item2.id === activeId);
return [
...items.slice(index2 + 1),
...shouldInsertNullItem ? [NULL_ITEM] : [],
...items.slice(0, index2)
];
}
function findFirstEnabledItem(items, excludeId) {
return items.find((item2) => {
if (excludeId) {
return !item2.disabled && item2.id !== excludeId;
}
return !item2.disabled;
});
}
function getEnabledItem(store, id3) {
if (!id3) return null;
return store.item(id3) || null;
}
function groupItemsByRows(items) {
const rows = [];
for (const item2 of items) {
const row = rows.find((currentRow) => {
var _a;
return ((_a = currentRow[0]) == null ? void 0 : _a.rowId) === item2.rowId;
});
if (row) {
row.push(item2);
} else {
rows.push([item2]);
}
}
return rows;
}
function selectTextField(element, collapseToEnd = false) {
if (isTextField(element)) {
element.setSelectionRange(
collapseToEnd ? element.value.length : 0,
element.value.length
);
} else if (element.isContentEditable) {
const selection = getDocument(element).getSelection();
selection == null ? void 0 : selection.selectAllChildren(element);
if (collapseToEnd) {
selection == null ? void 0 : selection.collapseToEnd();
}
}
}
var FOCUS_SILENTLY = /* @__PURE__ */ Symbol("FOCUS_SILENTLY");
function focusSilently(element) {
element[FOCUS_SILENTLY] = true;
element.focus({ preventScroll: true });
}
function silentlyFocused(element) {
const isSilentlyFocused = element[FOCUS_SILENTLY];
delete element[FOCUS_SILENTLY];
return isSilentlyFocused;
}
function isItem(store, element, exclude) {
if (!element) return false;
if (element === exclude) return false;
const item2 = store.item(element.id);
if (!item2) return false;
if (exclude && item2.element === exclude) return false;
return true;
}
// node_modules/@ariakit/react-core/esm/__chunks/Z2O3VLAQ.js
var import_react4 = __toESM(require_react(), 1);
var TagName = "div";
var useCollectionItem = createHook(
function useCollectionItem2({
store,
shouldRegisterItem = true,
getItem = identity,
// @ts-expect-error This prop may come from a collection renderer.
element,
...props
}) {
const context = useCollectionContext();
store = store || context;
const id3 = useId(props.id);
const ref = (0, import_react4.useRef)(element);
(0, import_react4.useEffect)(() => {
const element2 = ref.current;
if (!id3) return;
if (!element2) return;
if (!shouldRegisterItem) return;
const item2 = getItem({ id: id3, element: element2 });
return store == null ? void 0 : store.renderItem(item2);
}, [id3, shouldRegisterItem, getItem, store]);
props = {
...props,
ref: useMergeRefs(ref, props.ref)
};
return removeUndefinedValues(props);
}
);
var CollectionItem = forwardRef2(function CollectionItem2(props) {
const htmlProps = useCollectionItem(props);
return createElement(TagName, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/SWN3JYXT.js
var import_react5 = __toESM(require_react(), 1);
var FocusableContext = (0, import_react5.createContext)(true);
// node_modules/@ariakit/core/esm/utils/focus.js
var selector = "input:not([type='hidden']):not([disabled]), select:not([disabled]), textarea:not([disabled]), a[href], button:not([disabled]), [tabindex], summary, iframe, object, embed, area[href], audio[controls], video[controls], [contenteditable]:not([contenteditable='false'])";
function hasNegativeTabIndex(element) {
const tabIndex = Number.parseInt(element.getAttribute("tabindex") || "0", 10);
return tabIndex < 0;
}
function isFocusable(element) {
if (!element.matches(selector)) return false;
if (!isVisible(element)) return false;
if (element.closest("[inert]")) return false;
return true;
}
function isTabbable(element) {
if (!isFocusable(element)) return false;
if (hasNegativeTabIndex(element)) return false;
if (!("form" in element)) return true;
if (!element.form) return true;
if (element.checked) return true;
if (element.type !== "radio") return true;
const radioGroup = element.form.elements.namedItem(element.name);
if (!radioGroup) return true;
if (!("length" in radioGroup)) return true;
const activeElement = getActiveElement(element);
if (!activeElement) return true;
if (activeElement === element) return true;
if (!("form" in activeElement)) return true;
if (activeElement.form !== element.form) return true;
if (activeElement.name !== element.name) return true;
return false;
}
function getAllFocusableIn(container, includeContainer) {
const elements2 = Array.from(
container.querySelectorAll(selector)
);
if (includeContainer) {
elements2.unshift(container);
}
const focusableElements2 = elements2.filter(isFocusable);
focusableElements2.forEach((element, i3) => {
var _a;
if (!isFrame(element)) return;
const frameBody = (_a = element.contentDocument) == null ? void 0 : _a.body;
if (!frameBody) return;
focusableElements2.splice(i3, 1, ...getAllFocusableIn(frameBody));
});
return focusableElements2;
}
function getAllTabbableIn(container, includeContainer, fallbackToFocusable) {
const elements2 = Array.from(
container.querySelectorAll(selector)
);
const tabbableElements = elements2.filter(isTabbable);
if (includeContainer && isTabbable(container)) {
tabbableElements.unshift(container);
}
tabbableElements.forEach((element, i3) => {
var _a;
if (!isFrame(element)) return;
const frameBody = (_a = element.contentDocument) == null ? void 0 : _a.body;
if (!frameBody) return;
const allFrameTabbable = getAllTabbableIn(
frameBody,
false,
fallbackToFocusable
);
tabbableElements.splice(i3, 1, ...allFrameTabbable);
});
if (!tabbableElements.length && fallbackToFocusable) {
return elements2;
}
return tabbableElements;
}
function getFirstTabbableIn(container, includeContainer, fallbackToFocusable) {
const [first] = getAllTabbableIn(
container,
includeContainer,
fallbackToFocusable
);
return first || null;
}
function getNextTabbableIn(container, includeContainer, fallbackToFirst, fallbackToFocusable) {
const activeElement = getActiveElement(container);
const allFocusable = getAllFocusableIn(container, includeContainer);
const activeIndex = allFocusable.indexOf(activeElement);
const nextFocusableElements = allFocusable.slice(activeIndex + 1);
return nextFocusableElements.find(isTabbable) || (fallbackToFirst ? allFocusable.find(isTabbable) : null) || (fallbackToFocusable ? nextFocusableElements[0] : null) || null;
}
function getNextTabbable(fallbackToFirst, fallbackToFocusable) {
return getNextTabbableIn(
document.body,
false,
fallbackToFirst,
fallbackToFocusable
);
}
function getPreviousTabbableIn(container, includeContainer, fallbackToLast, fallbackToFocusable) {
const activeElement = getActiveElement(container);
const allFocusable = getAllFocusableIn(container, includeContainer).reverse();
const activeIndex = allFocusable.indexOf(activeElement);
const previousFocusableElements = allFocusable.slice(activeIndex + 1);
return previousFocusableElements.find(isTabbable) || (fallbackToLast ? allFocusable.find(isTabbable) : null) || (fallbackToFocusable ? previousFocusableElements[0] : null) || null;
}
function getPreviousTabbable(fallbackToFirst, fallbackToFocusable) {
return getPreviousTabbableIn(
document.body,
false,
fallbackToFirst,
fallbackToFocusable
);
}
function getClosestFocusable(element) {
while (element && !isFocusable(element)) {
element = element.closest(selector);
}
return element || null;
}
function hasFocus(element) {
const activeElement = getActiveElement(element);
if (!activeElement) return false;
if (activeElement === element) return true;
const activeDescendant = activeElement.getAttribute("aria-activedescendant");
if (!activeDescendant) return false;
return activeDescendant === element.id;
}
function hasFocusWithin(element) {
const activeElement = getActiveElement(element);
if (!activeElement) return false;
if (contains(element, activeElement)) return true;
const activeDescendant = activeElement.getAttribute("aria-activedescendant");
if (!activeDescendant) return false;
if (!("id" in element)) return false;
if (activeDescendant === element.id) return true;
return !!element.querySelector(`#${CSS.escape(activeDescendant)}`);
}
function focusIfNeeded(element) {
if (!hasFocusWithin(element) && isFocusable(element)) {
element.focus();
}
}
function disableFocus(element) {
var _a;
const currentTabindex = (_a = element.getAttribute("tabindex")) != null ? _a : "";
element.setAttribute("data-tabindex", currentTabindex);
element.setAttribute("tabindex", "-1");
}
function disableFocusIn(container, includeContainer) {
const tabbableElements = getAllTabbableIn(container, includeContainer);
for (const element of tabbableElements) {
disableFocus(element);
}
}
function restoreFocusIn(container) {
const elements2 = container.querySelectorAll("[data-tabindex]");
const restoreTabIndex = (element) => {
const tabindex = element.getAttribute("data-tabindex");
element.removeAttribute("data-tabindex");
if (tabindex) {
element.setAttribute("tabindex", tabindex);
} else {
element.removeAttribute("tabindex");
}
};
if (container.hasAttribute("data-tabindex")) {
restoreTabIndex(container);
}
for (const element of elements2) {
restoreTabIndex(element);
}
}
function focusIntoView(element, options2) {
if (!("scrollIntoView" in element)) {
element.focus();
} else {
element.focus({ preventScroll: true });
element.scrollIntoView({ block: "nearest", inline: "nearest", ...options2 });
}
}
// node_modules/@ariakit/react-core/esm/__chunks/U6HHPQDW.js
var import_react6 = __toESM(require_react(), 1);
var TagName2 = "div";
var isSafariBrowser = isSafari();
var alwaysFocusVisibleInputTypes = [
"text",
"search",
"url",
"tel",
"email",
"password",
"number",
"date",
"month",
"week",
"time",
"datetime",
"datetime-local"
];
var safariFocusAncestorSymbol = /* @__PURE__ */ Symbol("safariFocusAncestor");
function isSafariFocusAncestor(element) {
if (!element) return false;
return !!element[safariFocusAncestorSymbol];
}
function markSafariFocusAncestor(element, value) {
if (!element) return;
element[safariFocusAncestorSymbol] = value;
}
function isAlwaysFocusVisible(element) {
const { tagName, readOnly, type } = element;
if (tagName === "TEXTAREA" && !readOnly) return true;
if (tagName === "SELECT" && !readOnly) return true;
if (tagName === "INPUT" && !readOnly) {
return alwaysFocusVisibleInputTypes.includes(type);
}
if (element.isContentEditable) return true;
const role = element.getAttribute("role");
if (role === "combobox" && element.dataset.name) {
return true;
}
return false;
}
function getLabels(element) {
if ("labels" in element) {
return element.labels;
}
return null;
}
function isNativeCheckboxOrRadio(element) {
const tagName = element.tagName.toLowerCase();
if (tagName === "input" && element.type) {
return element.type === "radio" || element.type === "checkbox";
}
return false;
}
function isNativeTabbable(tagName) {
if (!tagName) return true;
return tagName === "button" || tagName === "summary" || tagName === "input" || tagName === "select" || tagName === "textarea" || tagName === "a";
}
function supportsDisabledAttribute(tagName) {
if (!tagName) return true;
return tagName === "button" || tagName === "input" || tagName === "select" || tagName === "textarea";
}
function getTabIndex(focusable, trulyDisabled, nativeTabbable, supportsDisabled, tabIndexProp) {
if (!focusable) {
return tabIndexProp;
}
if (trulyDisabled) {
if (nativeTabbable && !supportsDisabled) {
return -1;
}
return;
}
if (nativeTabbable) {
return tabIndexProp;
}
return tabIndexProp || 0;
}
function useDisableEvent(onEvent, disabled) {
return useEvent((event) => {
onEvent == null ? void 0 : onEvent(event);
if (event.defaultPrevented) return;
if (disabled) {
event.stopPropagation();
event.preventDefault();
}
});
}
var hasInstalledGlobalEventListeners2 = false;
var isKeyboardModality = true;
function onGlobalMouseDown(event) {
const target = event.target;
if (target && "hasAttribute" in target) {
if (!target.hasAttribute("data-focus-visible")) {
isKeyboardModality = false;
}
}
}
function onGlobalKeyDown(event) {
if (event.metaKey) return;
if (event.ctrlKey) return;
if (event.altKey) return;
isKeyboardModality = true;
}
var useFocusable = createHook(
function useFocusable2({
focusable = true,
accessibleWhenDisabled,
autoFocus,
onFocusVisible,
...props
}) {
const ref = (0, import_react6.useRef)(null);
(0, import_react6.useEffect)(() => {
if (!focusable) return;
if (hasInstalledGlobalEventListeners2) return;
addGlobalEventListener("mousedown", onGlobalMouseDown, true);
addGlobalEventListener("keydown", onGlobalKeyDown, true);
hasInstalledGlobalEventListeners2 = true;
}, [focusable]);
if (isSafariBrowser) {
(0, import_react6.useEffect)(() => {
if (!focusable) return;
const element = ref.current;
if (!element) return;
if (!isNativeCheckboxOrRadio(element)) return;
const labels = getLabels(element);
if (!labels) return;
const onMouseUp = () => queueMicrotask(() => element.focus());
for (const label of labels) {
label.addEventListener("mouseup", onMouseUp);
}
return () => {
for (const label of labels) {
label.removeEventListener("mouseup", onMouseUp);
}
};
}, [focusable]);
}
const disabled = focusable && disabledFromProps(props);
const trulyDisabled = !!disabled && !accessibleWhenDisabled;
const [focusVisible, setFocusVisible] = (0, import_react6.useState)(false);
(0, import_react6.useEffect)(() => {
if (!focusable) return;
if (trulyDisabled && focusVisible) {
setFocusVisible(false);
}
}, [focusable, trulyDisabled, focusVisible]);
(0, import_react6.useEffect)(() => {
if (!focusable) return;
if (!focusVisible) return;
const element = ref.current;
if (!element) return;
if (typeof IntersectionObserver === "undefined") return;
const observer = new IntersectionObserver(() => {
if (!isFocusable(element)) {
setFocusVisible(false);
}
});
observer.observe(element);
return () => observer.disconnect();
}, [focusable, focusVisible]);
const onKeyPressCapture = useDisableEvent(
props.onKeyPressCapture,
disabled
);
const onMouseDownCapture = useDisableEvent(
props.onMouseDownCapture,
disabled
);
const onClickCapture = useDisableEvent(props.onClickCapture, disabled);
const onMouseDownProp = props.onMouseDown;
const onMouseDown = useEvent((event) => {
onMouseDownProp == null ? void 0 : onMouseDownProp(event);
if (event.defaultPrevented) return;
if (!focusable) return;
const element = event.currentTarget;
if (!isSafariBrowser) return;
if (isPortalEvent(event)) return;
if (!isButton(element) && !isNativeCheckboxOrRadio(element)) return;
let receivedFocus = false;
const onFocus = () => {
receivedFocus = true;
};
const options2 = { capture: true, once: true };
element.addEventListener("focusin", onFocus, options2);
const focusableContainer = getClosestFocusable(element.parentElement);
markSafariFocusAncestor(focusableContainer, true);
queueBeforeEvent(element, "mouseup", () => {
element.removeEventListener("focusin", onFocus, true);
markSafariFocusAncestor(focusableContainer, false);
if (receivedFocus) return;
focusIfNeeded(element);
});
});
const handleFocusVisible = (event, currentTarget) => {
if (currentTarget) {
event.currentTarget = currentTarget;
}
if (!focusable) return;
const element = event.currentTarget;
if (!element) return;
if (!hasFocus(element)) return;
onFocusVisible == null ? void 0 : onFocusVisible(event);
if (event.defaultPrevented) return;
element.dataset.focusVisible = "true";
setFocusVisible(true);
};
const onKeyDownCaptureProp = props.onKeyDownCapture;
const onKeyDownCapture = useEvent((event) => {
onKeyDownCaptureProp == null ? void 0 : onKeyDownCaptureProp(event);
if (event.defaultPrevented) return;
if (!focusable) return;
if (focusVisible) return;
if (event.metaKey) return;
if (event.altKey) return;
if (event.ctrlKey) return;
if (!isSelfTarget(event)) return;
const element = event.currentTarget;
const applyFocusVisible = () => handleFocusVisible(event, element);
queueBeforeEvent(element, "focusout", applyFocusVisible);
});
const onFocusCaptureProp = props.onFocusCapture;
const onFocusCapture = useEvent((event) => {
onFocusCaptureProp == null ? void 0 : onFocusCaptureProp(event);
if (event.defaultPrevented) return;
if (!focusable) return;
if (!isSelfTarget(event)) {
setFocusVisible(false);
return;
}
const element = event.currentTarget;
const applyFocusVisible = () => handleFocusVisible(event, element);
if (isKeyboardModality || isAlwaysFocusVisible(event.target)) {
queueBeforeEvent(event.target, "focusout", applyFocusVisible);
} else {
setFocusVisible(false);
}
});
const onBlurProp = props.onBlur;
const onBlur = useEvent((event) => {
onBlurProp == null ? void 0 : onBlurProp(event);
if (!focusable) return;
if (!isFocusEventOutside(event)) return;
event.currentTarget.removeAttribute("data-focus-visible");
setFocusVisible(false);
});
const autoFocusOnShow = (0, import_react6.useContext)(FocusableContext);
const autoFocusRef = useEvent((element) => {
if (!focusable) return;
if (!autoFocus) return;
if (!element) return;
if (!autoFocusOnShow) return;
queueMicrotask(() => {
if (hasFocus(element)) return;
if (!isFocusable(element)) return;
element.focus();
});
});
const tagName = useTagName(ref);
const nativeTabbable = focusable && isNativeTabbable(tagName);
const supportsDisabled = focusable && supportsDisabledAttribute(tagName);
const styleProp = props.style;
const style2 = (0, import_react6.useMemo)(() => {
if (trulyDisabled) {
return { pointerEvents: "none", ...styleProp };
}
return styleProp;
}, [trulyDisabled, styleProp]);
props = {
"data-focus-visible": focusable && focusVisible || void 0,
"data-autofocus": autoFocus || void 0,
"aria-disabled": disabled || void 0,
...props,
ref: useMergeRefs(ref, autoFocusRef, props.ref),
style: style2,
tabIndex: getTabIndex(
focusable,
trulyDisabled,
nativeTabbable,
supportsDisabled,
props.tabIndex
),
disabled: supportsDisabled && trulyDisabled ? true : void 0,
// TODO: Test Focusable contentEditable.
contentEditable: disabled ? void 0 : props.contentEditable,
onKeyPressCapture,
onClickCapture,
onMouseDownCapture,
onMouseDown,
onKeyDownCapture,
onFocusCapture,
onBlur
};
return removeUndefinedValues(props);
}
);
var Focusable = forwardRef2(function Focusable2(props) {
const htmlProps = useFocusable(props);
return createElement(TagName2, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/PZ3OL7I2.js
var import_react7 = __toESM(require_react(), 1);
var TagName3 = "button";
function isNativeClick(event) {
if (!event.isTrusted) return false;
const element = event.currentTarget;
if (event.key === "Enter") {
return isButton(element) || element.tagName === "SUMMARY" || element.tagName === "A";
}
if (event.key === " ") {
return isButton(element) || element.tagName === "SUMMARY" || element.tagName === "INPUT" || element.tagName === "SELECT";
}
return false;
}
var symbol = /* @__PURE__ */ Symbol("command");
var useCommand = createHook(
function useCommand2({ clickOnEnter = true, clickOnSpace = true, ...props }) {
const ref = (0, import_react7.useRef)(null);
const [isNativeButton, setIsNativeButton] = (0, import_react7.useState)(false);
(0, import_react7.useEffect)(() => {
if (!ref.current) return;
setIsNativeButton(isButton(ref.current));
}, []);
const [active, setActive] = (0, import_react7.useState)(false);
const activeRef = (0, import_react7.useRef)(false);
const disabled = disabledFromProps(props);
const [isDuplicate, metadataProps] = useMetadataProps(props, symbol, true);
const onKeyDownProp = props.onKeyDown;
const onKeyDown = useEvent((event) => {
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
const element = event.currentTarget;
if (event.defaultPrevented) return;
if (isDuplicate) return;
if (disabled) return;
if (!isSelfTarget(event)) return;
if (isTextField(element)) return;
if (element.isContentEditable) return;
const isEnter = clickOnEnter && event.key === "Enter";
const isSpace = clickOnSpace && event.key === " ";
const shouldPreventEnter = event.key === "Enter" && !clickOnEnter;
const shouldPreventSpace = event.key === " " && !clickOnSpace;
if (shouldPreventEnter || shouldPreventSpace) {
event.preventDefault();
return;
}
if (isEnter || isSpace) {
const nativeClick = isNativeClick(event);
if (isEnter) {
if (!nativeClick) {
event.preventDefault();
const { view, ...eventInit } = event;
const click = () => fireClickEvent(element, eventInit);
if (isFirefox()) {
queueBeforeEvent(element, "keyup", click);
} else {
queueMicrotask(click);
}
}
} else if (isSpace) {
activeRef.current = true;
if (!nativeClick) {
event.preventDefault();
setActive(true);
}
}
}
});
const onKeyUpProp = props.onKeyUp;
const onKeyUp = useEvent((event) => {
onKeyUpProp == null ? void 0 : onKeyUpProp(event);
if (event.defaultPrevented) return;
if (isDuplicate) return;
if (disabled) return;
if (event.metaKey) return;
const isSpace = clickOnSpace && event.key === " ";
if (activeRef.current && isSpace) {
activeRef.current = false;
if (!isNativeClick(event)) {
event.preventDefault();
setActive(false);
const element = event.currentTarget;
const { view, ...eventInit } = event;
queueMicrotask(() => fireClickEvent(element, eventInit));
}
}
});
props = {
"data-active": active || void 0,
type: isNativeButton ? "button" : void 0,
...metadataProps,
...props,
ref: useMergeRefs(ref, props.ref),
onKeyDown,
onKeyUp
};
props = useFocusable(props);
return props;
}
);
var Command = forwardRef2(function Command2(props) {
const htmlProps = useCommand(props);
return createElement(TagName3, htmlProps);
});
// node_modules/@ariakit/core/esm/__chunks/SXKM4CGU.js
function getInternal(store, key) {
const internals = store.__unstableInternals;
invariant(internals, "Invalid store");
return internals[key];
}
function createStore(initialState, ...stores) {
let state = initialState;
let prevStateBatch = state;
let lastUpdate = /* @__PURE__ */ Symbol();
let destroy = noop;
const instances = /* @__PURE__ */ new Set();
const updatedKeys = /* @__PURE__ */ new Set();
const setups = /* @__PURE__ */ new Set();
const listeners = /* @__PURE__ */ new Set();
const batchListeners = /* @__PURE__ */ new Set();
const disposables = /* @__PURE__ */ new WeakMap();
const listenerKeys = /* @__PURE__ */ new WeakMap();
const storeSetup = (callback) => {
setups.add(callback);
return () => setups.delete(callback);
};
const storeInit = () => {
const initialized = instances.size;
const instance = /* @__PURE__ */ Symbol();
instances.add(instance);
const maybeDestroy = () => {
instances.delete(instance);
if (instances.size) return;
destroy();
};
if (initialized) return maybeDestroy;
const desyncs = getKeys(state).map(
(key) => chain(
...stores.map((store) => {
var _a;
const storeState = (_a = store == null ? void 0 : store.getState) == null ? void 0 : _a.call(store);
if (!storeState) return;
if (!hasOwnProperty(storeState, key)) return;
return sync(store, [key], (state2) => {
setState(
key,
state2[key],
// @ts-expect-error - Not public API. This is just to prevent
// infinite loops.
true
);
});
})
)
);
const teardowns = [];
for (const setup2 of setups) {
teardowns.push(setup2());
}
const cleanups2 = stores.map(init);
destroy = chain(...desyncs, ...teardowns, ...cleanups2);
return maybeDestroy;
};
const sub = (keys, listener, set2 = listeners) => {
set2.add(listener);
listenerKeys.set(listener, keys);
return () => {
var _a;
(_a = disposables.get(listener)) == null ? void 0 : _a();
disposables.delete(listener);
listenerKeys.delete(listener);
set2.delete(listener);
};
};
const storeSubscribe = (keys, listener) => sub(keys, listener);
const storeSync = (keys, listener) => {
disposables.set(listener, listener(state, state));
return sub(keys, listener);
};
const storeBatch = (keys, listener) => {
disposables.set(listener, listener(state, prevStateBatch));
return sub(keys, listener, batchListeners);
};
const storePick = (keys) => createStore(pick(state, keys), finalStore);
const storeOmit = (keys) => createStore(omit(state, keys), finalStore);
const getState = () => state;
const setState = (key, value, fromStores = false) => {
var _a;
if (!hasOwnProperty(state, key)) return;
const nextValue = applyState(value, state[key]);
if (nextValue === state[key]) return;
if (!fromStores) {
for (const store of stores) {
(_a = store == null ? void 0 : store.setState) == null ? void 0 : _a.call(store, key, nextValue);
}
}
const prevState = state;
state = { ...state, [key]: nextValue };
const thisUpdate = /* @__PURE__ */ Symbol();
lastUpdate = thisUpdate;
updatedKeys.add(key);
const run = (listener, prev2, uKeys) => {
var _a2;
const keys = listenerKeys.get(listener);
const updated = (k3) => uKeys ? uKeys.has(k3) : k3 === key;
if (!keys || keys.some(updated)) {
(_a2 = disposables.get(listener)) == null ? void 0 : _a2();
disposables.set(listener, listener(state, prev2));
}
};
for (const listener of listeners) {
run(listener, prevState);
}
queueMicrotask(() => {
if (lastUpdate !== thisUpdate) return;
const snapshot = state;
for (const listener of batchListeners) {
run(listener, prevStateBatch, updatedKeys);
}
prevStateBatch = snapshot;
updatedKeys.clear();
});
};
const finalStore = {
getState,
setState,
__unstableInternals: {
setup: storeSetup,
init: storeInit,
subscribe: storeSubscribe,
sync: storeSync,
batch: storeBatch,
pick: storePick,
omit: storeOmit
}
};
return finalStore;
}
function setup(store, ...args) {
if (!store) return;
return getInternal(store, "setup")(...args);
}
function init(store, ...args) {
if (!store) return;
return getInternal(store, "init")(...args);
}
function subscribe(store, ...args) {
if (!store) return;
return getInternal(store, "subscribe")(...args);
}
function sync(store, ...args) {
if (!store) return;
return getInternal(store, "sync")(...args);
}
function batch(store, ...args) {
if (!store) return;
return getInternal(store, "batch")(...args);
}
function omit2(store, ...args) {
if (!store) return;
return getInternal(store, "omit")(...args);
}
function pick2(store, ...args) {
if (!store) return;
return getInternal(store, "pick")(...args);
}
function mergeStore(...stores) {
var _a;
const initialState = {};
for (const store2 of stores) {
const nextState = (_a = store2 == null ? void 0 : store2.getState) == null ? void 0 : _a.call(store2);
if (nextState) {
Object.assign(initialState, nextState);
}
}
const store = createStore(initialState, ...stores);
return Object.assign({}, ...stores, store);
}
function throwOnConflictingProps(props, store) {
if (false) return;
if (!store) return;
const defaultKeys = Object.entries(props).filter(([key, value]) => key.startsWith("default") && value !== void 0).map(([key]) => {
var _a;
const stateKey = key.replace("default", "");
return `${((_a = stateKey[0]) == null ? void 0 : _a.toLowerCase()) || ""}${stateKey.slice(1)}`;
});
if (!defaultKeys.length) return;
const storeState = store.getState();
const conflictingProps = defaultKeys.filter(
(key) => hasOwnProperty(storeState, key)
);
if (!conflictingProps.length) return;
throw new Error(
`Passing a store prop in conjunction with a default state is not supported.
const store = useSelectStore();
^ ^
Instead, pass the default state to the topmost store:
const store = useSelectStore({ defaultValue: "Apple" });
See https://github.com/ariakit/ariakit/pull/2745 for more details.
If there's a particular need for this, please submit a feature request at https://github.com/ariakit/ariakit
`
);
}
// node_modules/@ariakit/react-core/esm/__chunks/Q5W46E73.js
var React3 = __toESM(require_react(), 1);
var import_shim = __toESM(require_shim(), 1);
var { useSyncExternalStore } = import_shim.default;
var noopSubscribe = () => () => {
};
function useStoreState(store, keyOrSelector = identity) {
const storeSubscribe = React3.useCallback(
(callback) => {
if (!store) return noopSubscribe();
return subscribe(store, null, callback);
},
[store]
);
const getSnapshot = () => {
const key = typeof keyOrSelector === "string" ? keyOrSelector : null;
const selector2 = typeof keyOrSelector === "function" ? keyOrSelector : null;
const state = store == null ? void 0 : store.getState();
if (selector2) return selector2(state);
if (!state) return;
if (!key) return;
if (!hasOwnProperty(state, key)) return;
return state[key];
};
return useSyncExternalStore(storeSubscribe, getSnapshot, getSnapshot);
}
function useStoreStateObject(store, object) {
const objRef = React3.useRef(
{}
);
const storeSubscribe = React3.useCallback(
(callback) => {
if (!store) return noopSubscribe();
return subscribe(store, null, callback);
},
[store]
);
const getSnapshot = () => {
const state = store == null ? void 0 : store.getState();
let updated = false;
const obj = objRef.current;
for (const prop in object) {
const keyOrSelector = object[prop];
if (typeof keyOrSelector === "function") {
const value = keyOrSelector(state);
if (value !== obj[prop]) {
obj[prop] = value;
updated = true;
}
}
if (typeof keyOrSelector === "string") {
if (!state) continue;
if (!hasOwnProperty(state, keyOrSelector)) continue;
const value = state[keyOrSelector];
if (value !== obj[prop]) {
obj[prop] = value;
updated = true;
}
}
}
if (updated) {
objRef.current = { ...obj };
}
return objRef.current;
};
return useSyncExternalStore(storeSubscribe, getSnapshot, getSnapshot);
}
function useStoreProps(store, props, key, setKey) {
const value = hasOwnProperty(props, key) ? props[key] : void 0;
const setValue = setKey ? props[setKey] : void 0;
const propsRef = useLiveRef({ value, setValue });
useSafeLayoutEffect(() => {
return sync(store, [key], (state, prev2) => {
const { value: value2, setValue: setValue2 } = propsRef.current;
if (!setValue2) return;
if (state[key] === prev2[key]) return;
if (state[key] === value2) return;
setValue2(state[key]);
});
}, [store, key]);
useSafeLayoutEffect(() => {
if (value === void 0) return;
store.setState(key, value);
return batch(store, [key], () => {
if (value === void 0) return;
store.setState(key, value);
});
});
}
function useStore(createStore2, props) {
const [store, setStore] = React3.useState(() => createStore2(props));
useSafeLayoutEffect(() => init(store), [store]);
const useState210 = React3.useCallback(
(keyOrSelector) => useStoreState(store, keyOrSelector),
[store]
);
const memoizedStore = React3.useMemo(
() => ({ ...store, useState: useState210 }),
[store, useState210]
);
const updateStore = useEvent(() => {
setStore((store2) => createStore2({ ...props, ...store2.getState() }));
});
return [memoizedStore, updateStore];
}
// node_modules/@ariakit/react-core/esm/__chunks/WZWDIE3S.js
var import_react8 = __toESM(require_react(), 1);
var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
var TagName4 = "button";
function isEditableElement(element) {
if (isTextbox(element)) return true;
return element.tagName === "INPUT" && !isButton(element);
}
function getNextPageOffset(scrollingElement, pageUp = false) {
const height = scrollingElement.clientHeight;
const { top } = scrollingElement.getBoundingClientRect();
const pageSize = Math.max(height * 0.875, height - 40) * 1.5;
const pageOffset = pageUp ? height - pageSize + top : pageSize + top;
if (scrollingElement.tagName === "HTML") {
return pageOffset + scrollingElement.scrollTop;
}
return pageOffset;
}
function getItemOffset(itemElement, pageUp = false) {
const { top } = itemElement.getBoundingClientRect();
if (pageUp) {
return top + itemElement.clientHeight;
}
return top;
}
function findNextPageItemId(element, store, next2, pageUp = false) {
var _a;
if (!store) return;
if (!next2) return;
const { renderedItems } = store.getState();
const scrollingElement = getScrollingElement(element);
if (!scrollingElement) return;
const nextPageOffset = getNextPageOffset(scrollingElement, pageUp);
let id3;
let prevDifference;
for (let i3 = 0; i3 < renderedItems.length; i3 += 1) {
const previousId = id3;
id3 = next2(i3);
if (!id3) break;
if (id3 === previousId) continue;
const itemElement = (_a = getEnabledItem(store, id3)) == null ? void 0 : _a.element;
if (!itemElement) continue;
const itemOffset = getItemOffset(itemElement, pageUp);
const difference = itemOffset - nextPageOffset;
const absDifference = Math.abs(difference);
if (pageUp && difference <= 0 || !pageUp && difference >= 0) {
if (prevDifference !== void 0 && prevDifference < absDifference) {
id3 = previousId;
}
break;
}
prevDifference = absDifference;
}
return id3;
}
function targetIsAnotherItem(event, store) {
if (isSelfTarget(event)) return false;
return isItem(store, event.target);
}
var useCompositeItem = createHook(
function useCompositeItem2({
store,
rowId: rowIdProp,
preventScrollOnKeyDown = false,
moveOnKeyPress = true,
tabbable = false,
getItem: getItemProp,
"aria-setsize": ariaSetSizeProp,
"aria-posinset": ariaPosInSetProp,
...props
}) {
const context = useCompositeContext();
store = store || context;
const id3 = useId(props.id);
const ref = (0, import_react8.useRef)(null);
const row = (0, import_react8.useContext)(CompositeRowContext);
const disabled = disabledFromProps(props);
const trulyDisabled = disabled && !props.accessibleWhenDisabled;
const {
rowId,
baseElement,
isActiveItem,
ariaSetSize,
ariaPosInSet,
isTabbable: isTabbable2
} = useStoreStateObject(store, {
rowId(state) {
if (rowIdProp) return rowIdProp;
if (!state) return;
if (!(row == null ? void 0 : row.baseElement)) return;
if (row.baseElement !== state.baseElement) return;
return row.id;
},
baseElement(state) {
return (state == null ? void 0 : state.baseElement) || void 0;
},
isActiveItem(state) {
return !!state && state.activeId === id3;
},
ariaSetSize(state) {
if (ariaSetSizeProp != null) return ariaSetSizeProp;
if (!state) return;
if (!(row == null ? void 0 : row.ariaSetSize)) return;
if (row.baseElement !== state.baseElement) return;
return row.ariaSetSize;
},
ariaPosInSet(state) {
if (ariaPosInSetProp != null) return ariaPosInSetProp;
if (!state) return;
if (!(row == null ? void 0 : row.ariaPosInSet)) return;
if (row.baseElement !== state.baseElement) return;
const itemsInRow = state.renderedItems.filter(
(item2) => item2.rowId === rowId
);
return row.ariaPosInSet + itemsInRow.findIndex((item2) => item2.id === id3);
},
isTabbable(state) {
if (!(state == null ? void 0 : state.renderedItems.length)) return true;
if (state.virtualFocus) return false;
if (tabbable) return true;
if (state.activeId === null) return false;
const item2 = store == null ? void 0 : store.item(state.activeId);
if (item2 == null ? void 0 : item2.disabled) return true;
if (!(item2 == null ? void 0 : item2.element)) return true;
return state.activeId === id3;
}
});
const getItem = (0, import_react8.useCallback)(
(item2) => {
var _a;
const nextItem = {
...item2,
id: id3 || item2.id,
rowId,
disabled: !!trulyDisabled,
children: (_a = item2.element) == null ? void 0 : _a.textContent
};
if (getItemProp) {
return getItemProp(nextItem);
}
return nextItem;
},
[id3, rowId, trulyDisabled, getItemProp]
);
const onFocusProp = props.onFocus;
const hasFocusedComposite = (0, import_react8.useRef)(false);
const onFocus = useEvent((event) => {
onFocusProp == null ? void 0 : onFocusProp(event);
if (event.defaultPrevented) return;
if (isPortalEvent(event)) return;
if (!id3) return;
if (!store) return;
if (targetIsAnotherItem(event, store)) return;
const { virtualFocus, baseElement: baseElement2 } = store.getState();
store.setActiveId(id3);
if (isTextbox(event.currentTarget)) {
selectTextField(event.currentTarget);
}
if (!virtualFocus) return;
if (!isSelfTarget(event)) return;
if (isEditableElement(event.currentTarget)) return;
if (!(baseElement2 == null ? void 0 : baseElement2.isConnected)) return;
if (isSafari() && event.currentTarget.hasAttribute("data-autofocus")) {
event.currentTarget.scrollIntoView({
block: "nearest",
inline: "nearest"
});
}
hasFocusedComposite.current = true;
const fromComposite = event.relatedTarget === baseElement2 || isItem(store, event.relatedTarget);
if (fromComposite) {
focusSilently(baseElement2);
} else {
baseElement2.focus();
}
});
const onBlurCaptureProp = props.onBlurCapture;
const onBlurCapture = useEvent((event) => {
onBlurCaptureProp == null ? void 0 : onBlurCaptureProp(event);
if (event.defaultPrevented) return;
const state = store == null ? void 0 : store.getState();
if ((state == null ? void 0 : state.virtualFocus) && hasFocusedComposite.current) {
hasFocusedComposite.current = false;
event.preventDefault();
event.stopPropagation();
}
});
const onKeyDownProp = props.onKeyDown;
const preventScrollOnKeyDownProp = useBooleanEvent(preventScrollOnKeyDown);
const moveOnKeyPressProp = useBooleanEvent(moveOnKeyPress);
const onKeyDown = useEvent((event) => {
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (event.defaultPrevented) return;
if (!isSelfTarget(event)) return;
if (!store) return;
const { currentTarget } = event;
const state = store.getState();
const item2 = store.item(id3);
const isGrid2 = !!(item2 == null ? void 0 : item2.rowId);
const isVertical = state.orientation !== "horizontal";
const isHorizontal = state.orientation !== "vertical";
const canHomeEnd = () => {
if (isGrid2) return true;
if (isHorizontal) return true;
if (!state.baseElement) return true;
if (!isTextField(state.baseElement)) return true;
return false;
};
const keyMap = {
ArrowUp: (isGrid2 || isVertical) && store.up,
ArrowRight: (isGrid2 || isHorizontal) && store.next,
ArrowDown: (isGrid2 || isVertical) && store.down,
ArrowLeft: (isGrid2 || isHorizontal) && store.previous,
Home: () => {
if (!canHomeEnd()) return;
if (!isGrid2 || event.ctrlKey) {
return store == null ? void 0 : store.first();
}
return store == null ? void 0 : store.previous(-1);
},
End: () => {
if (!canHomeEnd()) return;
if (!isGrid2 || event.ctrlKey) {
return store == null ? void 0 : store.last();
}
return store == null ? void 0 : store.next(-1);
},
PageUp: () => {
return findNextPageItemId(currentTarget, store, store == null ? void 0 : store.up, true);
},
PageDown: () => {
return findNextPageItemId(currentTarget, store, store == null ? void 0 : store.down);
}
};
const action = keyMap[event.key];
if (action) {
if (isTextbox(currentTarget)) {
const selection = getTextboxSelection(currentTarget);
const isLeft = isHorizontal && event.key === "ArrowLeft";
const isRight = isHorizontal && event.key === "ArrowRight";
const isUp = isVertical && event.key === "ArrowUp";
const isDown = isVertical && event.key === "ArrowDown";
if (isRight || isDown) {
const { length: valueLength } = getTextboxValue(currentTarget);
if (selection.end !== valueLength) return;
} else if ((isLeft || isUp) && selection.start !== 0) return;
}
const nextId = action();
if (preventScrollOnKeyDownProp(event) || nextId !== void 0) {
if (!moveOnKeyPressProp(event)) return;
event.preventDefault();
store.move(nextId);
}
}
});
const providerValue = (0, import_react8.useMemo)(
() => ({ id: id3, baseElement }),
[id3, baseElement]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CompositeItemContext.Provider, { value: providerValue, children: element }),
[providerValue]
);
props = {
id: id3,
"data-active-item": isActiveItem || void 0,
...props,
ref: useMergeRefs(ref, props.ref),
tabIndex: isTabbable2 ? props.tabIndex : -1,
onFocus,
onBlurCapture,
onKeyDown
};
props = useCommand(props);
props = useCollectionItem({
store,
...props,
getItem,
shouldRegisterItem: id3 ? props.shouldRegisterItem : false
});
return removeUndefinedValues({
...props,
"aria-setsize": ariaSetSize,
"aria-posinset": ariaPosInSet
});
}
);
var CompositeItem = memo2(
forwardRef2(function CompositeItem2(props) {
const htmlProps = useCompositeItem(props);
return createElement(TagName4, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/tab/tab.js
var import_react9 = __toESM(require_react(), 1);
var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1);
var TagName5 = "button";
var useTab = createHook(function useTab2({
store,
getItem: getItemProp,
...props
}) {
var _a;
const context = useTabScopedContext();
store = store || context;
invariant(
store,
"Tab must be wrapped in a TabList component."
);
const defaultId = useId();
const id3 = props.id || defaultId;
const dimmed = disabledFromProps(props);
const getItem = (0, import_react9.useCallback)(
(item2) => {
const nextItem = { ...item2, dimmed };
if (getItemProp) {
return getItemProp(nextItem);
}
return nextItem;
},
[dimmed, getItemProp]
);
const onClickProp = props.onClick;
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
store == null ? void 0 : store.setSelectedId(id3);
});
const panelId = store.panels.useState(
(state) => {
var _a2;
return (_a2 = state.items.find((item2) => item2.tabId === id3)) == null ? void 0 : _a2.id;
}
);
const shouldRegisterItem = defaultId ? props.shouldRegisterItem : false;
const isActive = store.useState((state) => !!id3 && state.activeId === id3);
const selected = store.useState((state) => !!id3 && state.selectedId === id3);
const hasActiveItem2 = store.useState((state) => !!store.item(state.activeId));
const canRegisterComposedItem = isActive || selected && !hasActiveItem2;
const accessibleWhenDisabled = selected || ((_a = props.accessibleWhenDisabled) != null ? _a : true);
const isWithinVirtualFocusComposite = useStoreState(
store.combobox || store.composite,
"virtualFocus"
);
if (isWithinVirtualFocusComposite) {
props = {
...props,
tabIndex: -1
};
}
props = {
id: id3,
role: "tab",
"aria-selected": selected,
"aria-controls": panelId || void 0,
...props,
onClick
};
if (store.composite) {
const defaultProps = {
id: id3,
accessibleWhenDisabled,
store: store.composite,
shouldRegisterItem: canRegisterComposedItem && shouldRegisterItem,
rowId: props.rowId,
render: props.render
};
props = {
...props,
render: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
CompositeItem,
{
...defaultProps,
render: store.combobox && store.composite !== store.combobox ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(CompositeItem, { ...defaultProps, store: store.combobox }) : defaultProps.render
}
)
};
}
props = useCompositeItem({
store,
...props,
accessibleWhenDisabled,
getItem,
shouldRegisterItem
});
return props;
});
var Tab = memo2(
forwardRef2(function Tab2(props) {
const htmlProps = useTab(props);
return createElement(TagName5, htmlProps);
})
);
// node_modules/@ariakit/core/esm/__chunks/7PRQYBBV.js
function toArray(arg) {
if (Array.isArray(arg)) {
return arg;
}
return typeof arg !== "undefined" ? [arg] : [];
}
function flatten2DArray(array) {
const flattened = [];
for (const row of array) {
flattened.push(...row);
}
return flattened;
}
function reverseArray(array) {
return array.slice().reverse();
}
// node_modules/@ariakit/react-core/esm/__chunks/ZMWF7ASR.js
var import_react10 = __toESM(require_react(), 1);
var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1);
var TagName6 = "div";
function isGrid(items) {
return items.some((item2) => !!item2.rowId);
}
function isPrintableKey(event) {
const target = event.target;
if (target && !isTextField(target)) return false;
return event.key.length === 1 && !event.ctrlKey && !event.metaKey;
}
function isModifierKey(event) {
return event.key === "Shift" || event.key === "Control" || event.key === "Alt" || event.key === "Meta";
}
function useKeyboardEventProxy(store, onKeyboardEvent, previousElementRef) {
return useEvent((event) => {
var _a;
onKeyboardEvent == null ? void 0 : onKeyboardEvent(event);
if (event.defaultPrevented) return;
if (event.isPropagationStopped()) return;
if (!isSelfTarget(event)) return;
if (isModifierKey(event)) return;
if (isPrintableKey(event)) return;
const state = store.getState();
const activeElement = (_a = getEnabledItem(store, state.activeId)) == null ? void 0 : _a.element;
if (!activeElement) return;
const { view, ...eventInit } = event;
const previousElement = previousElementRef == null ? void 0 : previousElementRef.current;
if (activeElement !== previousElement) {
activeElement.focus();
}
if (!fireKeyboardEvent(activeElement, event.type, eventInit)) {
event.preventDefault();
}
if (event.currentTarget.contains(activeElement)) {
event.stopPropagation();
}
});
}
function findFirstEnabledItemInTheLastRow(items) {
return findFirstEnabledItem(
flatten2DArray(reverseArray(groupItemsByRows(items)))
);
}
function useScheduleFocus(store) {
const [scheduled, setScheduled] = (0, import_react10.useState)(false);
const schedule = (0, import_react10.useCallback)(() => setScheduled(true), []);
const activeItem = store.useState(
(state) => getEnabledItem(store, state.activeId)
);
(0, import_react10.useEffect)(() => {
const activeElement = activeItem == null ? void 0 : activeItem.element;
if (!scheduled) return;
if (!activeElement) return;
setScheduled(false);
activeElement.focus({ preventScroll: true });
}, [activeItem, scheduled]);
return schedule;
}
var useComposite = createHook(
function useComposite2({
store,
composite = true,
focusOnMove = composite,
moveOnKeyPress = true,
...props
}) {
const context = useCompositeProviderContext();
store = store || context;
invariant(
store,
"Composite must receive a `store` prop or be wrapped in a CompositeProvider component."
);
const ref = (0, import_react10.useRef)(null);
const previousElementRef = (0, import_react10.useRef)(null);
const scheduleFocus = useScheduleFocus(store);
const moves = store.useState("moves");
const [, setBaseElement] = useTransactionState(
composite ? store.setBaseElement : null
);
(0, import_react10.useEffect)(() => {
var _a;
if (!store) return;
if (!moves) return;
if (!composite) return;
if (!focusOnMove) return;
const { activeId: activeId2 } = store.getState();
const itemElement = (_a = getEnabledItem(store, activeId2)) == null ? void 0 : _a.element;
if (!itemElement) return;
focusIntoView(itemElement);
}, [store, moves, composite, focusOnMove]);
useSafeLayoutEffect(() => {
if (!store) return;
if (!moves) return;
if (!composite) return;
const { baseElement, activeId: activeId2 } = store.getState();
const isSelfAcive = activeId2 === null;
if (!isSelfAcive) return;
if (!baseElement) return;
const previousElement = previousElementRef.current;
previousElementRef.current = null;
if (previousElement) {
fireBlurEvent(previousElement, { relatedTarget: baseElement });
}
if (!hasFocus(baseElement)) {
baseElement.focus();
}
}, [store, moves, composite]);
const activeId = store.useState("activeId");
const virtualFocus = store.useState("virtualFocus");
useSafeLayoutEffect(() => {
var _a;
if (!store) return;
if (!composite) return;
if (!virtualFocus) return;
const previousElement = previousElementRef.current;
previousElementRef.current = null;
if (!previousElement) return;
const activeElement = (_a = getEnabledItem(store, activeId)) == null ? void 0 : _a.element;
const relatedTarget = activeElement || getActiveElement(previousElement);
if (relatedTarget === previousElement) return;
fireBlurEvent(previousElement, { relatedTarget });
}, [store, activeId, virtualFocus, composite]);
const onKeyDownCapture = useKeyboardEventProxy(
store,
props.onKeyDownCapture,
previousElementRef
);
const onKeyUpCapture = useKeyboardEventProxy(
store,
props.onKeyUpCapture,
previousElementRef
);
const onFocusCaptureProp = props.onFocusCapture;
const onFocusCapture = useEvent((event) => {
onFocusCaptureProp == null ? void 0 : onFocusCaptureProp(event);
if (event.defaultPrevented) return;
if (!store) return;
const { virtualFocus: virtualFocus2 } = store.getState();
if (!virtualFocus2) return;
const previousActiveElement = event.relatedTarget;
const isSilentlyFocused = silentlyFocused(event.currentTarget);
if (isSelfTarget(event) && isSilentlyFocused) {
event.stopPropagation();
previousElementRef.current = previousActiveElement;
}
});
const onFocusProp = props.onFocus;
const onFocus = useEvent((event) => {
onFocusProp == null ? void 0 : onFocusProp(event);
if (event.defaultPrevented) return;
if (!composite) return;
if (!store) return;
const { relatedTarget } = event;
const { virtualFocus: virtualFocus2 } = store.getState();
if (virtualFocus2) {
if (isSelfTarget(event) && !isItem(store, relatedTarget)) {
queueMicrotask(scheduleFocus);
}
} else if (isSelfTarget(event)) {
store.setActiveId(null);
}
});
const onBlurCaptureProp = props.onBlurCapture;
const onBlurCapture = useEvent((event) => {
var _a;
onBlurCaptureProp == null ? void 0 : onBlurCaptureProp(event);
if (event.defaultPrevented) return;
if (!store) return;
const { virtualFocus: virtualFocus2, activeId: activeId2 } = store.getState();
if (!virtualFocus2) return;
const activeElement = (_a = getEnabledItem(store, activeId2)) == null ? void 0 : _a.element;
const nextActiveElement = event.relatedTarget;
const nextActiveElementIsItem = isItem(store, nextActiveElement);
const previousElement = previousElementRef.current;
previousElementRef.current = null;
if (isSelfTarget(event) && nextActiveElementIsItem) {
if (nextActiveElement === activeElement) {
if (previousElement && previousElement !== nextActiveElement) {
fireBlurEvent(previousElement, event);
}
} else if (activeElement) {
fireBlurEvent(activeElement, event);
} else if (previousElement) {
fireBlurEvent(previousElement, event);
}
event.stopPropagation();
} else {
const targetIsItem = isItem(store, event.target);
if (!targetIsItem && activeElement) {
fireBlurEvent(activeElement, event);
}
}
});
const onKeyDownProp = props.onKeyDown;
const moveOnKeyPressProp = useBooleanEvent(moveOnKeyPress);
const onKeyDown = useEvent((event) => {
var _a;
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (event.nativeEvent.isComposing) return;
if (event.defaultPrevented) return;
if (!store) return;
if (!isSelfTarget(event)) return;
const { orientation, renderedItems, activeId: activeId2 } = store.getState();
const activeItem = getEnabledItem(store, activeId2);
if ((_a = activeItem == null ? void 0 : activeItem.element) == null ? void 0 : _a.isConnected) return;
const isVertical = orientation !== "horizontal";
const isHorizontal = orientation !== "vertical";
const grid = isGrid(renderedItems);
const isHorizontalKey = event.key === "ArrowLeft" || event.key === "ArrowRight" || event.key === "Home" || event.key === "End";
if (isHorizontalKey && isTextField(event.currentTarget)) return;
const up = () => {
if (grid) {
const item2 = findFirstEnabledItemInTheLastRow(renderedItems);
return item2 == null ? void 0 : item2.id;
}
return store == null ? void 0 : store.last();
};
const keyMap = {
ArrowUp: (grid || isVertical) && up,
ArrowRight: (grid || isHorizontal) && store.first,
ArrowDown: (grid || isVertical) && store.first,
ArrowLeft: (grid || isHorizontal) && store.last,
Home: store.first,
End: store.last,
PageUp: store.first,
PageDown: store.last
};
const action = keyMap[event.key];
if (action) {
const id3 = action();
if (id3 !== void 0) {
if (!moveOnKeyPressProp(event)) return;
event.preventDefault();
store.move(id3);
}
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(CompositeContextProvider, { value: store, children: element }),
[store]
);
const activeDescendant = store.useState((state) => {
var _a;
if (!store) return;
if (!composite) return;
if (!state.virtualFocus) return;
return (_a = getEnabledItem(store, state.activeId)) == null ? void 0 : _a.id;
});
props = {
"aria-activedescendant": activeDescendant,
...props,
ref: useMergeRefs(ref, setBaseElement, props.ref),
onKeyDownCapture,
onKeyUpCapture,
onFocusCapture,
onFocus,
onBlurCapture,
onKeyDown
};
const focusable = store.useState(
(state) => composite && (state.virtualFocus || state.activeId === null)
);
props = useFocusable({ focusable, ...props });
return props;
}
);
var Composite = forwardRef2(function Composite2(props) {
const htmlProps = useComposite(props);
return createElement(TagName6, htmlProps);
});
// node_modules/@ariakit/react-core/esm/tab/tab-list.js
var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
var TagName7 = "div";
var useTabList = createHook(
function useTabList2({ store, ...props }) {
const context = useTabProviderContext();
store = store || context;
invariant(
store,
"TabList must receive a `store` prop or be wrapped in a TabProvider component."
);
const orientation = store.useState(
(state) => state.orientation === "both" ? void 0 : state.orientation
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TabScopedContextProvider, { value: store, children: element }),
[store]
);
if (store.composite) {
props = {
focusable: false,
...props
};
}
props = {
role: "tablist",
"aria-orientation": orientation,
...props
};
props = useComposite({ store, ...props });
return props;
}
);
var TabList = forwardRef2(function TabList2(props) {
const htmlProps = useTabList(props);
return createElement(TagName7, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/LVDQFHCH.js
var ctx4 = createStoreContext();
var useDisclosureContext = ctx4.useContext;
var useDisclosureScopedContext = ctx4.useScopedContext;
var useDisclosureProviderContext = ctx4.useProviderContext;
var DisclosureContextProvider = ctx4.ContextProvider;
var DisclosureScopedContextProvider = ctx4.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/A62MDFCW.js
var import_react11 = __toESM(require_react(), 1);
var ctx5 = createStoreContext(
[DisclosureContextProvider],
[DisclosureScopedContextProvider]
);
var useDialogContext = ctx5.useContext;
var useDialogScopedContext = ctx5.useScopedContext;
var useDialogProviderContext = ctx5.useProviderContext;
var DialogContextProvider = ctx5.ContextProvider;
var DialogScopedContextProvider = ctx5.ScopedContextProvider;
var DialogHeadingContext = (0, import_react11.createContext)(void 0);
var DialogDescriptionContext = (0, import_react11.createContext)(void 0);
// node_modules/@ariakit/react-core/esm/__chunks/6B3RXHKP.js
var import_react12 = __toESM(require_react(), 1);
var import_react_dom = __toESM(require_react_dom(), 1);
var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1);
var TagName8 = "div";
function afterTimeout(timeoutMs, cb) {
const timeoutId = setTimeout(cb, timeoutMs);
return () => clearTimeout(timeoutId);
}
function afterPaint2(cb) {
let raf = requestAnimationFrame(() => {
raf = requestAnimationFrame(cb);
});
return () => cancelAnimationFrame(raf);
}
function parseCSSTime(...times) {
return times.join(", ").split(", ").reduce((longestTime, currentTimeString) => {
const multiplier = currentTimeString.endsWith("ms") ? 1 : 1e3;
const currentTime = Number.parseFloat(currentTimeString || "0s") * multiplier;
if (currentTime > longestTime) return currentTime;
return longestTime;
}, 0);
}
function isHidden(mounted, hidden, alwaysVisible) {
return !alwaysVisible && hidden !== false && (!mounted || !!hidden);
}
var useDisclosureContent = createHook(function useDisclosureContent2({ store, alwaysVisible, ...props }) {
const context = useDisclosureProviderContext();
store = store || context;
invariant(
store,
"DisclosureContent must receive a `store` prop or be wrapped in a DisclosureProvider component."
);
const ref = (0, import_react12.useRef)(null);
const id3 = useId(props.id);
const [transition, setTransition] = (0, import_react12.useState)(null);
const open = store.useState("open");
const mounted = store.useState("mounted");
const animated = store.useState("animated");
const contentElement = store.useState("contentElement");
const otherElement = useStoreState(store.disclosure, "contentElement");
useSafeLayoutEffect(() => {
if (!ref.current) return;
store == null ? void 0 : store.setContentElement(ref.current);
}, [store]);
useSafeLayoutEffect(() => {
let previousAnimated;
store == null ? void 0 : store.setState("animated", (animated2) => {
previousAnimated = animated2;
return true;
});
return () => {
if (previousAnimated === void 0) return;
store == null ? void 0 : store.setState("animated", previousAnimated);
};
}, [store]);
useSafeLayoutEffect(() => {
if (!animated) return;
if (!(contentElement == null ? void 0 : contentElement.isConnected)) {
setTransition(null);
return;
}
return afterPaint2(() => {
setTransition(open ? "enter" : mounted ? "leave" : null);
});
}, [animated, contentElement, open, mounted]);
useSafeLayoutEffect(() => {
if (!store) return;
if (!animated) return;
if (!transition) return;
if (!contentElement) return;
const stopAnimation = () => store == null ? void 0 : store.setState("animating", false);
const stopAnimationSync = () => (0, import_react_dom.flushSync)(stopAnimation);
if (transition === "leave" && open) return;
if (transition === "enter" && !open) return;
if (typeof animated === "number") {
const timeout2 = animated;
return afterTimeout(timeout2, stopAnimationSync);
}
const {
transitionDuration,
animationDuration,
transitionDelay,
animationDelay
} = getComputedStyle(contentElement);
const {
transitionDuration: transitionDuration2 = "0",
animationDuration: animationDuration2 = "0",
transitionDelay: transitionDelay2 = "0",
animationDelay: animationDelay2 = "0"
} = otherElement ? getComputedStyle(otherElement) : {};
const delay2 = parseCSSTime(
transitionDelay,
animationDelay,
transitionDelay2,
animationDelay2
);
const duration = parseCSSTime(
transitionDuration,
animationDuration,
transitionDuration2,
animationDuration2
);
const timeout = delay2 + duration;
if (!timeout) {
if (transition === "enter") {
store.setState("animated", false);
}
stopAnimation();
return;
}
const frameRate = 1e3 / 60;
const maxTimeout = Math.max(timeout - frameRate, 0);
return afterTimeout(maxTimeout, stopAnimationSync);
}, [store, animated, contentElement, otherElement, open, transition]);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DialogScopedContextProvider, { value: store, children: element }),
[store]
);
const hidden = isHidden(mounted, props.hidden, alwaysVisible);
const styleProp = props.style;
const style2 = (0, import_react12.useMemo)(() => {
if (hidden) {
return { ...styleProp, display: "none" };
}
return styleProp;
}, [hidden, styleProp]);
props = {
id: id3,
"data-open": open || void 0,
"data-enter": transition === "enter" || void 0,
"data-leave": transition === "leave" || void 0,
hidden,
...props,
ref: useMergeRefs(id3 ? store.setContentElement : null, ref, props.ref),
style: style2
};
return removeUndefinedValues(props);
});
var DisclosureContentImpl = forwardRef2(function DisclosureContentImpl2(props) {
const htmlProps = useDisclosureContent(props);
return createElement(TagName8, htmlProps);
});
var DisclosureContent = forwardRef2(function DisclosureContent2({
unmountOnHide,
...props
}) {
const context = useDisclosureProviderContext();
const store = props.store || context;
const mounted = useStoreState(
store,
(state) => !unmountOnHide || (state == null ? void 0 : state.mounted)
);
if (mounted === false) return null;
return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(DisclosureContentImpl, { ...props });
});
// node_modules/@ariakit/core/esm/__chunks/75BJEVSH.js
function createDisclosureStore(props = {}) {
const store = mergeStore(
props.store,
omit2(props.disclosure, ["contentElement", "disclosureElement"])
);
throwOnConflictingProps(props, store);
const syncState = store == null ? void 0 : store.getState();
const open = defaultValue(
props.open,
syncState == null ? void 0 : syncState.open,
props.defaultOpen,
false
);
const animated = defaultValue(props.animated, syncState == null ? void 0 : syncState.animated, false);
const initialState = {
open,
animated,
animating: !!animated && open,
mounted: open,
contentElement: defaultValue(syncState == null ? void 0 : syncState.contentElement, null),
disclosureElement: defaultValue(syncState == null ? void 0 : syncState.disclosureElement, null)
};
const disclosure = createStore(initialState, store);
setup(
disclosure,
() => sync(disclosure, ["animated", "animating"], (state) => {
if (state.animated) return;
disclosure.setState("animating", false);
})
);
setup(
disclosure,
() => subscribe(disclosure, ["open"], () => {
if (!disclosure.getState().animated) return;
disclosure.setState("animating", true);
})
);
setup(
disclosure,
() => sync(disclosure, ["open", "animating"], (state) => {
disclosure.setState("mounted", state.open || state.animating);
})
);
return {
...disclosure,
disclosure: props.disclosure,
setOpen: (value) => disclosure.setState("open", value),
show: () => disclosure.setState("open", true),
hide: () => disclosure.setState("open", false),
toggle: () => disclosure.setState("open", (open2) => !open2),
stopAnimation: () => disclosure.setState("animating", false),
setContentElement: (value) => disclosure.setState("contentElement", value),
setDisclosureElement: (value) => disclosure.setState("disclosureElement", value)
};
}
// node_modules/@ariakit/react-core/esm/__chunks/WLZ6H5FH.js
function useDisclosureStoreProps(store, update, props) {
useUpdateEffect(update, [props.store, props.disclosure]);
useStoreProps(store, props, "open", "setOpen");
useStoreProps(store, props, "mounted", "setMounted");
useStoreProps(store, props, "animated");
return Object.assign(store, { disclosure: props.disclosure });
}
function useDisclosureStore(props = {}) {
const [store, update] = useStore(createDisclosureStore, props);
return useDisclosureStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/tab/tab-panel.js
var import_react13 = __toESM(require_react(), 1);
var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1);
var TagName9 = "div";
var useTabPanel = createHook(
function useTabPanel2({
store,
unmountOnHide,
tabId: tabIdProp,
getItem: getItemProp,
scrollRestoration,
scrollElement,
...props
}) {
const context = useTabProviderContext();
store = store || context;
invariant(
store,
"TabPanel must receive a `store` prop or be wrapped in a TabProvider component."
);
const ref = (0, import_react13.useRef)(null);
const id3 = useId(props.id);
const tabId = useStoreState(
store.panels,
() => {
var _a;
return tabIdProp || ((_a = store == null ? void 0 : store.panels.item(id3)) == null ? void 0 : _a.tabId);
}
);
const open = useStoreState(
store,
(state) => !!tabId && state.selectedId === tabId
);
const disclosure = useDisclosureStore({ open });
const mounted = useStoreState(disclosure, "mounted");
const scrollPositionRef = (0, import_react13.useRef)(
/* @__PURE__ */ new Map()
);
const getScrollElement = useEvent(() => {
const panelElement = ref.current;
if (!panelElement) return null;
if (!scrollElement) return panelElement;
if (typeof scrollElement === "function") {
return scrollElement(panelElement);
}
if ("current" in scrollElement) {
return scrollElement.current;
}
return scrollElement;
});
(0, import_react13.useEffect)(() => {
var _a, _b;
if (!scrollRestoration) return;
if (!mounted) return;
const element = getScrollElement();
if (!element) return;
if (scrollRestoration === "reset") {
element.scroll(0, 0);
return;
}
if (!tabId) return;
const position2 = scrollPositionRef.current.get(tabId);
element.scroll((_a = position2 == null ? void 0 : position2.x) != null ? _a : 0, (_b = position2 == null ? void 0 : position2.y) != null ? _b : 0);
const onScroll = () => {
scrollPositionRef.current.set(tabId, {
x: element.scrollLeft,
y: element.scrollTop
});
};
element.addEventListener("scroll", onScroll);
return () => {
element.removeEventListener("scroll", onScroll);
};
}, [scrollRestoration, mounted, tabId, getScrollElement, store]);
const [hasTabbableChildren, setHasTabbableChildren] = (0, import_react13.useState)(false);
(0, import_react13.useEffect)(() => {
const element = ref.current;
if (!element) return;
const tabbable = getAllTabbableIn(element);
setHasTabbableChildren(!!tabbable.length);
}, []);
const getItem = (0, import_react13.useCallback)(
(item2) => {
const nextItem = { ...item2, id: id3 || item2.id, tabId: tabIdProp };
if (getItemProp) {
return getItemProp(nextItem);
}
return nextItem;
},
[id3, tabIdProp, getItemProp]
);
const onKeyDownProp = props.onKeyDown;
const onKeyDown = useEvent((event) => {
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (event.defaultPrevented) return;
if (!(store == null ? void 0 : store.composite)) return;
const keyMap = {
ArrowLeft: store.previous,
ArrowRight: store.next,
Home: store.first,
End: store.last
};
const action = keyMap[event.key];
if (!action) return;
const { selectedId } = store.getState();
const nextId = action({ activeId: selectedId });
if (!nextId) return;
event.preventDefault();
store.move(nextId);
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(TabScopedContextProvider, { value: store, children: element }),
[store]
);
props = {
id: id3,
role: "tabpanel",
"aria-labelledby": tabId || void 0,
...props,
children: unmountOnHide && !mounted ? null : props.children,
ref: useMergeRefs(ref, props.ref),
onKeyDown
};
props = useFocusable({
// If the tab panel is rendered as part of another composite widget such
// as combobox, it should not be focusable.
focusable: !store.composite && !hasTabbableChildren,
...props
});
props = useDisclosureContent({ store: disclosure, ...props });
props = useCollectionItem({ store: store.panels, ...props, getItem });
return props;
}
);
var TabPanel = forwardRef2(function TabPanel2(props) {
const htmlProps = useTabPanel(props);
return createElement(TagName9, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/JMU4N4M5.js
var ctx6 = createStoreContext(
[DialogContextProvider],
[DialogScopedContextProvider]
);
var usePopoverContext = ctx6.useContext;
var usePopoverScopedContext = ctx6.useScopedContext;
var usePopoverProviderContext = ctx6.useProviderContext;
var PopoverContextProvider = ctx6.ContextProvider;
var PopoverScopedContextProvider = ctx6.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/AEGCXJZV.js
var import_react14 = __toESM(require_react(), 1);
var ctx7 = createStoreContext(
[PopoverContextProvider, CompositeContextProvider],
[PopoverScopedContextProvider, CompositeScopedContextProvider]
);
var useSelectContext = ctx7.useContext;
var useSelectScopedContext = ctx7.useScopedContext;
var useSelectProviderContext = ctx7.useProviderContext;
var SelectContextProvider = ctx7.ContextProvider;
var SelectScopedContextProvider = ctx7.ScopedContextProvider;
var SelectItemCheckedContext = (0, import_react14.createContext)(false);
var SelectHeadingContext = (0, import_react14.createContext)(null);
// node_modules/@ariakit/core/esm/__chunks/N5XGANPW.js
function getCommonParent(items) {
var _a;
const firstItem = items.find((item2) => !!item2.element);
const lastItem = [...items].reverse().find((item2) => !!item2.element);
let parentElement = (_a = firstItem == null ? void 0 : firstItem.element) == null ? void 0 : _a.parentElement;
while (parentElement && (lastItem == null ? void 0 : lastItem.element)) {
const parent = parentElement;
if (lastItem && parent.contains(lastItem.element)) {
return parentElement;
}
parentElement = parentElement.parentElement;
}
return getDocument(parentElement).body;
}
function getPrivateStore(store) {
return store == null ? void 0 : store.__unstablePrivateStore;
}
function createCollectionStore(props = {}) {
var _a;
throwOnConflictingProps(props, props.store);
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const items = defaultValue(
props.items,
syncState == null ? void 0 : syncState.items,
props.defaultItems,
[]
);
const itemsMap = new Map(items.map((item2) => [item2.id, item2]));
const initialState = {
items,
renderedItems: defaultValue(syncState == null ? void 0 : syncState.renderedItems, [])
};
const syncPrivateStore = getPrivateStore(props.store);
const privateStore = createStore(
{ items, renderedItems: initialState.renderedItems },
syncPrivateStore
);
const collection = createStore(initialState, props.store);
const sortItems = (renderedItems) => {
const sortedItems = sortBasedOnDOMPosition(renderedItems, (i3) => i3.element);
privateStore.setState("renderedItems", sortedItems);
collection.setState("renderedItems", sortedItems);
};
setup(collection, () => init(privateStore));
setup(privateStore, () => {
return batch(privateStore, ["items"], (state) => {
collection.setState("items", state.items);
});
});
setup(privateStore, () => {
return batch(privateStore, ["renderedItems"], (state) => {
let firstRun = true;
let raf = requestAnimationFrame(() => {
const { renderedItems } = collection.getState();
if (state.renderedItems === renderedItems) return;
sortItems(state.renderedItems);
});
if (typeof IntersectionObserver !== "function") {
return () => cancelAnimationFrame(raf);
}
const ioCallback = () => {
if (firstRun) {
firstRun = false;
return;
}
cancelAnimationFrame(raf);
raf = requestAnimationFrame(() => sortItems(state.renderedItems));
};
const root = getCommonParent(state.renderedItems);
const observer = new IntersectionObserver(ioCallback, { root });
for (const item2 of state.renderedItems) {
if (!item2.element) continue;
observer.observe(item2.element);
}
return () => {
cancelAnimationFrame(raf);
observer.disconnect();
};
});
});
const mergeItem = (item2, setItems, canDeleteFromMap = false) => {
let prevItem;
setItems((items2) => {
const index2 = items2.findIndex(({ id: id3 }) => id3 === item2.id);
const nextItems = items2.slice();
if (index2 !== -1) {
prevItem = items2[index2];
const nextItem = { ...prevItem, ...item2 };
nextItems[index2] = nextItem;
itemsMap.set(item2.id, nextItem);
} else {
nextItems.push(item2);
itemsMap.set(item2.id, item2);
}
return nextItems;
});
const unmergeItem = () => {
setItems((items2) => {
if (!prevItem) {
if (canDeleteFromMap) {
itemsMap.delete(item2.id);
}
return items2.filter(({ id: id3 }) => id3 !== item2.id);
}
const index2 = items2.findIndex(({ id: id3 }) => id3 === item2.id);
if (index2 === -1) return items2;
const nextItems = items2.slice();
nextItems[index2] = prevItem;
itemsMap.set(item2.id, prevItem);
return nextItems;
});
};
return unmergeItem;
};
const registerItem = (item2) => mergeItem(
item2,
(getItems) => privateStore.setState("items", getItems),
true
);
return {
...collection,
registerItem,
renderItem: (item2) => chain(
registerItem(item2),
mergeItem(
item2,
(getItems) => privateStore.setState("renderedItems", getItems)
)
),
item: (id3) => {
if (!id3) return null;
let item2 = itemsMap.get(id3);
if (!item2) {
const { items: items2 } = privateStore.getState();
item2 = items2.find((item22) => item22.id === id3);
if (item2) {
itemsMap.set(id3, item2);
}
}
return item2 || null;
},
// @ts-expect-error Internal
__unstablePrivateStore: privateStore
};
}
// node_modules/@ariakit/react-core/esm/__chunks/GVAFFF2B.js
function useCollectionStoreProps(store, update, props) {
useUpdateEffect(update, [props.store]);
useStoreProps(store, props, "items", "setItems");
return store;
}
// node_modules/@ariakit/core/esm/__chunks/RVTIKFRL.js
var NULL_ITEM2 = { id: null };
function findFirstEnabledItem2(items, excludeId) {
return items.find((item2) => {
if (excludeId) {
return !item2.disabled && item2.id !== excludeId;
}
return !item2.disabled;
});
}
function getEnabledItems(items, excludeId) {
return items.filter((item2) => {
if (excludeId) {
return !item2.disabled && item2.id !== excludeId;
}
return !item2.disabled;
});
}
function getItemsInRow(items, rowId) {
return items.filter((item2) => item2.rowId === rowId);
}
function flipItems2(items, activeId, shouldInsertNullItem = false) {
const index2 = items.findIndex((item2) => item2.id === activeId);
return [
...items.slice(index2 + 1),
...shouldInsertNullItem ? [NULL_ITEM2] : [],
...items.slice(0, index2)
];
}
function groupItemsByRows2(items) {
const rows = [];
for (const item2 of items) {
const row = rows.find((currentRow) => {
var _a;
return ((_a = currentRow[0]) == null ? void 0 : _a.rowId) === item2.rowId;
});
if (row) {
row.push(item2);
} else {
rows.push([item2]);
}
}
return rows;
}
function getMaxRowLength(array) {
let maxLength = 0;
for (const { length: length2 } of array) {
if (length2 > maxLength) {
maxLength = length2;
}
}
return maxLength;
}
function createEmptyItem(rowId) {
return {
id: "__EMPTY_ITEM__",
disabled: true,
rowId
};
}
function normalizeRows(rows, activeId, focusShift) {
const maxLength = getMaxRowLength(rows);
for (const row of rows) {
for (let i3 = 0; i3 < maxLength; i3 += 1) {
const item2 = row[i3];
if (!item2 || focusShift && item2.disabled) {
const isFirst = i3 === 0;
const previousItem = isFirst && focusShift ? findFirstEnabledItem2(row) : row[i3 - 1];
row[i3] = previousItem && activeId !== previousItem.id && focusShift ? previousItem : createEmptyItem(previousItem == null ? void 0 : previousItem.rowId);
}
}
}
return rows;
}
function verticalizeItems(items) {
const rows = groupItemsByRows2(items);
const maxLength = getMaxRowLength(rows);
const verticalized = [];
for (let i3 = 0; i3 < maxLength; i3 += 1) {
for (const row of rows) {
const item2 = row[i3];
if (item2) {
verticalized.push({
...item2,
// If there's no rowId, it means that it's not a grid composite, but
// a single row instead. So, instead of verticalizing it, that is,
// assigning a different rowId based on the column index, we keep it
// undefined so they will be part of the same row. This is useful
// when using up/down on one-dimensional composites.
rowId: item2.rowId ? `${i3}` : void 0
});
}
}
}
return verticalized;
}
function createCompositeStore(props = {}) {
var _a;
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const collection = createCollectionStore(props);
const activeId = defaultValue(
props.activeId,
syncState == null ? void 0 : syncState.activeId,
props.defaultActiveId
);
const initialState = {
...collection.getState(),
id: defaultValue(
props.id,
syncState == null ? void 0 : syncState.id,
`id-${Math.random().toString(36).slice(2, 8)}`
),
activeId,
baseElement: defaultValue(syncState == null ? void 0 : syncState.baseElement, null),
includesBaseElement: defaultValue(
props.includesBaseElement,
syncState == null ? void 0 : syncState.includesBaseElement,
activeId === null
),
moves: defaultValue(syncState == null ? void 0 : syncState.moves, 0),
orientation: defaultValue(
props.orientation,
syncState == null ? void 0 : syncState.orientation,
"both"
),
rtl: defaultValue(props.rtl, syncState == null ? void 0 : syncState.rtl, false),
virtualFocus: defaultValue(
props.virtualFocus,
syncState == null ? void 0 : syncState.virtualFocus,
false
),
focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, false),
focusWrap: defaultValue(props.focusWrap, syncState == null ? void 0 : syncState.focusWrap, false),
focusShift: defaultValue(props.focusShift, syncState == null ? void 0 : syncState.focusShift, false)
};
const composite = createStore(initialState, collection, props.store);
setup(
composite,
() => sync(composite, ["renderedItems", "activeId"], (state) => {
composite.setState("activeId", (activeId2) => {
var _a2;
if (activeId2 !== void 0) return activeId2;
return (_a2 = findFirstEnabledItem2(state.renderedItems)) == null ? void 0 : _a2.id;
});
})
);
const getNextId = (direction = "next", options2 = {}) => {
var _a2, _b;
const defaultState = composite.getState();
const {
skip = 0,
activeId: activeId2 = defaultState.activeId,
focusShift = defaultState.focusShift,
focusLoop = defaultState.focusLoop,
focusWrap = defaultState.focusWrap,
includesBaseElement = defaultState.includesBaseElement,
renderedItems = defaultState.renderedItems,
rtl: rtl2 = defaultState.rtl
} = options2;
const isVerticalDirection = direction === "up" || direction === "down";
const isNextDirection = direction === "next" || direction === "down";
const canReverse = isNextDirection ? rtl2 && !isVerticalDirection : !rtl2 || isVerticalDirection;
const canShift = focusShift && !skip;
let items = !isVerticalDirection ? renderedItems : flatten2DArray(
normalizeRows(groupItemsByRows2(renderedItems), activeId2, canShift)
);
items = canReverse ? reverseArray(items) : items;
items = isVerticalDirection ? verticalizeItems(items) : items;
if (activeId2 == null) {
return (_a2 = findFirstEnabledItem2(items)) == null ? void 0 : _a2.id;
}
const activeItem = items.find((item2) => item2.id === activeId2);
if (!activeItem) {
return (_b = findFirstEnabledItem2(items)) == null ? void 0 : _b.id;
}
const isGrid2 = items.some((item2) => item2.rowId);
const activeIndex = items.indexOf(activeItem);
const nextItems = items.slice(activeIndex + 1);
const nextItemsInRow = getItemsInRow(nextItems, activeItem.rowId);
if (skip) {
const nextEnabledItemsInRow = getEnabledItems(nextItemsInRow, activeId2);
const nextItem2 = nextEnabledItemsInRow.slice(skip)[0] || // If we can't find an item, just return the last one.
nextEnabledItemsInRow[nextEnabledItemsInRow.length - 1];
return nextItem2 == null ? void 0 : nextItem2.id;
}
const canLoop = focusLoop && (isVerticalDirection ? focusLoop !== "horizontal" : focusLoop !== "vertical");
const canWrap = isGrid2 && focusWrap && (isVerticalDirection ? focusWrap !== "horizontal" : focusWrap !== "vertical");
const hasNullItem = isNextDirection ? (!isGrid2 || isVerticalDirection) && canLoop && includesBaseElement : isVerticalDirection ? includesBaseElement : false;
if (canLoop) {
const loopItems = canWrap && !hasNullItem ? items : getItemsInRow(items, activeItem.rowId);
const sortedItems = flipItems2(loopItems, activeId2, hasNullItem);
const nextItem2 = findFirstEnabledItem2(sortedItems, activeId2);
return nextItem2 == null ? void 0 : nextItem2.id;
}
if (canWrap) {
const nextItem2 = findFirstEnabledItem2(
// We can use nextItems, which contains all the next items, including
// items from other rows, to wrap between rows. However, if there is a
// null item (the composite container), we'll only use the next items in
// the row. So moving next from the last item will focus on the
// composite container. On grid composites, horizontal navigation never
// focuses on the composite container, only vertical.
hasNullItem ? nextItemsInRow : nextItems,
activeId2
);
const nextId = hasNullItem ? (nextItem2 == null ? void 0 : nextItem2.id) || null : nextItem2 == null ? void 0 : nextItem2.id;
return nextId;
}
const nextItem = findFirstEnabledItem2(nextItemsInRow, activeId2);
if (!nextItem && hasNullItem) {
return null;
}
return nextItem == null ? void 0 : nextItem.id;
};
return {
...collection,
...composite,
setBaseElement: (element) => composite.setState("baseElement", element),
setActiveId: (id3) => composite.setState("activeId", id3),
move: (id3) => {
if (id3 === void 0) return;
composite.setState("activeId", id3);
composite.setState("moves", (moves) => moves + 1);
},
first: () => {
var _a2;
return (_a2 = findFirstEnabledItem2(composite.getState().renderedItems)) == null ? void 0 : _a2.id;
},
last: () => {
var _a2;
return (_a2 = findFirstEnabledItem2(reverseArray(composite.getState().renderedItems))) == null ? void 0 : _a2.id;
},
next: (options2) => {
if (options2 !== void 0 && typeof options2 === "number") {
options2 = { skip: options2 };
}
return getNextId("next", options2);
},
previous: (options2) => {
if (options2 !== void 0 && typeof options2 === "number") {
options2 = { skip: options2 };
}
return getNextId("previous", options2);
},
down: (options2) => {
if (options2 !== void 0 && typeof options2 === "number") {
options2 = { skip: options2 };
}
return getNextId("down", options2);
},
up: (options2) => {
if (options2 !== void 0 && typeof options2 === "number") {
options2 = { skip: options2 };
}
return getNextId("up", options2);
}
};
}
// node_modules/@ariakit/react-core/esm/__chunks/IQYAUKXT.js
function useCompositeStoreOptions(props) {
const id3 = useId(props.id);
return { id: id3, ...props };
}
function useCompositeStoreProps(store, update, props) {
store = useCollectionStoreProps(store, update, props);
useStoreProps(store, props, "activeId", "setActiveId");
useStoreProps(store, props, "includesBaseElement");
useStoreProps(store, props, "virtualFocus");
useStoreProps(store, props, "orientation");
useStoreProps(store, props, "rtl");
useStoreProps(store, props, "focusLoop");
useStoreProps(store, props, "focusWrap");
useStoreProps(store, props, "focusShift");
return store;
}
function useCompositeStore(props = {}) {
props = useCompositeStoreOptions(props);
const [store, update] = useStore(createCompositeStore, props);
return useCompositeStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/__chunks/CVCFNOHX.js
var import_react15 = __toESM(require_react(), 1);
var ComboboxListRoleContext = (0, import_react15.createContext)(
void 0
);
var ctx8 = createStoreContext(
[PopoverContextProvider, CompositeContextProvider],
[PopoverScopedContextProvider, CompositeScopedContextProvider]
);
var useComboboxContext = ctx8.useContext;
var useComboboxScopedContext = ctx8.useScopedContext;
var useComboboxProviderContext = ctx8.useProviderContext;
var ComboboxContextProvider = ctx8.ContextProvider;
var ComboboxScopedContextProvider = ctx8.ScopedContextProvider;
var ComboboxItemValueContext = (0, import_react15.createContext)(
void 0
);
var ComboboxItemCheckedContext = (0, import_react15.createContext)(false);
// node_modules/@ariakit/core/esm/tab/tab-store.js
function createTabStore({
composite: parentComposite,
combobox,
...props
} = {}) {
const independentKeys = [
"items",
"renderedItems",
"moves",
"orientation",
"virtualFocus",
"includesBaseElement",
"baseElement",
"focusLoop",
"focusShift",
"focusWrap"
];
const store = mergeStore(
props.store,
omit2(parentComposite, independentKeys),
omit2(combobox, independentKeys)
);
const syncState = store == null ? void 0 : store.getState();
const composite = createCompositeStore({
...props,
store,
// We need to explicitly set the default value of `includesBaseElement` to
// `false` since we don't want the composite store to default it to `true`
// when the activeId state is null, which could be the case when rendering
// combobox with tab.
includesBaseElement: defaultValue(
props.includesBaseElement,
syncState == null ? void 0 : syncState.includesBaseElement,
false
),
orientation: defaultValue(
props.orientation,
syncState == null ? void 0 : syncState.orientation,
"horizontal"
),
focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, true)
});
const panels = createCollectionStore();
const initialState = {
...composite.getState(),
selectedId: defaultValue(
props.selectedId,
syncState == null ? void 0 : syncState.selectedId,
props.defaultSelectedId
),
selectOnMove: defaultValue(
props.selectOnMove,
syncState == null ? void 0 : syncState.selectOnMove,
true
)
};
const tab = createStore(initialState, composite, store);
setup(
tab,
() => sync(tab, ["moves"], () => {
const { activeId, selectOnMove } = tab.getState();
if (!selectOnMove) return;
if (!activeId) return;
const tabItem = composite.item(activeId);
if (!tabItem) return;
if (tabItem.dimmed) return;
if (tabItem.disabled) return;
tab.setState("selectedId", tabItem.id);
})
);
let syncActiveId = true;
setup(
tab,
() => batch(tab, ["selectedId"], (state, prev2) => {
if (!syncActiveId) {
syncActiveId = true;
return;
}
if (parentComposite && state.selectedId === prev2.selectedId) return;
tab.setState("activeId", state.selectedId);
})
);
setup(
tab,
() => sync(tab, ["selectedId", "renderedItems"], (state) => {
if (state.selectedId !== void 0) return;
const { activeId, renderedItems } = tab.getState();
const tabItem = composite.item(activeId);
if (tabItem && !tabItem.disabled && !tabItem.dimmed) {
tab.setState("selectedId", tabItem.id);
} else {
const tabItem2 = renderedItems.find(
(item2) => !item2.disabled && !item2.dimmed
);
tab.setState("selectedId", tabItem2 == null ? void 0 : tabItem2.id);
}
})
);
setup(
tab,
() => sync(tab, ["renderedItems"], (state) => {
const tabs = state.renderedItems;
if (!tabs.length) return;
return sync(panels, ["renderedItems"], (state2) => {
const items = state2.renderedItems;
const hasOrphanPanels = items.some((panel) => !panel.tabId);
if (!hasOrphanPanels) return;
items.forEach((panel, i3) => {
if (panel.tabId) return;
const tabItem = tabs[i3];
if (!tabItem) return;
panels.renderItem({ ...panel, tabId: tabItem.id });
});
});
})
);
let selectedIdFromSelectedValue = null;
setup(tab, () => {
const backupSelectedId = () => {
selectedIdFromSelectedValue = tab.getState().selectedId;
};
const restoreSelectedId = () => {
syncActiveId = false;
tab.setState("selectedId", selectedIdFromSelectedValue);
};
if (parentComposite && "setSelectElement" in parentComposite) {
return chain(
sync(parentComposite, ["value"], backupSelectedId),
sync(parentComposite, ["mounted"], restoreSelectedId)
);
}
if (!combobox) return;
return chain(
sync(combobox, ["selectedValue"], backupSelectedId),
sync(combobox, ["mounted"], restoreSelectedId)
);
});
return {
...composite,
...tab,
panels,
setSelectedId: (id3) => tab.setState("selectedId", id3),
select: (id3) => {
tab.setState("selectedId", id3);
composite.move(id3);
}
};
}
// node_modules/@ariakit/react-core/esm/__chunks/OJYI6SUJ.js
var import_react16 = __toESM(require_react(), 1);
function useTabStoreProps(store, update, props) {
useUpdateEffect(update, [props.composite, props.combobox]);
store = useCompositeStoreProps(store, update, props);
useStoreProps(store, props, "selectedId", "setSelectedId");
useStoreProps(store, props, "selectOnMove");
const [panels, updatePanels] = useStore(() => store.panels, {});
useUpdateEffect(updatePanels, [store, updatePanels]);
return Object.assign(
(0, import_react16.useMemo)(() => ({ ...store, panels }), [store, panels]),
{ composite: props.composite, combobox: props.combobox }
);
}
function useTabStore(props = {}) {
const combobox = useComboboxContext();
const composite = useSelectContext() || combobox;
props = {
...props,
composite: props.composite !== void 0 ? props.composite : composite,
combobox: props.combobox !== void 0 ? props.combobox : combobox
};
const [store, update] = useStore(createTabStore, props);
return useTabStoreProps(store, update, props);
}
// node_modules/@ariakit/core/esm/toolbar/toolbar-store.js
function createToolbarStore(props = {}) {
var _a;
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
return createCompositeStore({
...props,
orientation: defaultValue(
props.orientation,
syncState == null ? void 0 : syncState.orientation,
"horizontal"
),
focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, true)
});
}
// node_modules/@ariakit/react-core/esm/__chunks/5WUV565P.js
function useToolbarStoreProps(store, update, props) {
return useCompositeStoreProps(store, update, props);
}
function useToolbarStore(props = {}) {
const [store, update] = useStore(createToolbarStore, props);
return useToolbarStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/__chunks/WZDDDI4V.js
var ctx9 = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var useToolbarContext = ctx9.useContext;
var useToolbarScopedContext = ctx9.useScopedContext;
var useToolbarProviderContext = ctx9.useProviderContext;
var ToolbarContextProvider = ctx9.ContextProvider;
var ToolbarScopedContextProvider = ctx9.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/toolbar/toolbar.js
var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1);
var TagName10 = "div";
var useToolbar = createHook(
function useToolbar2({
store: storeProp,
orientation: orientationProp,
virtualFocus,
focusLoop,
rtl: rtl2,
...props
}) {
const context = useToolbarProviderContext();
storeProp = storeProp || context;
const store = useToolbarStore({
store: storeProp,
orientation: orientationProp,
virtualFocus,
focusLoop,
rtl: rtl2
});
const orientation = store.useState(
(state) => state.orientation === "both" ? void 0 : state.orientation
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(ToolbarScopedContextProvider, { value: store, children: element }),
[store]
);
props = {
role: "toolbar",
"aria-orientation": orientation,
...props
};
props = useComposite({ store, ...props });
return props;
}
);
var Toolbar = forwardRef2(function Toolbar2(props) {
const htmlProps = useToolbar(props);
return createElement(TagName10, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/HSU7H6PW.js
var TagName11 = "button";
var useToolbarItem = createHook(
function useToolbarItem2({ store, ...props }) {
const context = useToolbarContext();
store = store || context;
props = useCompositeItem({ store, ...props });
return props;
}
);
var ToolbarItem = memo2(
forwardRef2(function ToolbarItem2(props) {
const htmlProps = useToolbarItem(props);
return createElement(TagName11, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/__chunks/P7VC6T3R.js
var TagName12 = "hr";
var useSeparator = createHook(
function useSeparator2({ orientation = "horizontal", ...props }) {
props = {
role: "separator",
"aria-orientation": orientation,
...props
};
return props;
}
);
var Separator = forwardRef2(function Separator2(props) {
const htmlProps = useSeparator(props);
return createElement(TagName12, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/YBRT277Q.js
var TagName13 = "hr";
var useCompositeSeparator = createHook(function useCompositeSeparator2({ store, ...props }) {
const context = useCompositeContext();
store = store || context;
invariant(
store,
"CompositeSeparator must be wrapped in a Composite component."
);
const orientation = store.useState(
(state) => state.orientation === "horizontal" ? "vertical" : "horizontal"
);
props = useSeparator({ ...props, orientation });
return props;
});
var CompositeSeparator = forwardRef2(function CompositeSeparator2(props) {
const htmlProps = useCompositeSeparator(props);
return createElement(TagName13, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/PTRWAQFT.js
var ctx10 = createStoreContext(
[PopoverContextProvider],
[PopoverScopedContextProvider]
);
var useHovercardContext = ctx10.useContext;
var useHovercardScopedContext = ctx10.useScopedContext;
var useHovercardProviderContext = ctx10.useProviderContext;
var HovercardContextProvider = ctx10.ContextProvider;
var HovercardScopedContextProvider = ctx10.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/UZXQ5DX3.js
var ctx11 = createStoreContext(
[HovercardContextProvider],
[HovercardScopedContextProvider]
);
var useTooltipContext = ctx11.useContext;
var useTooltipScopedContext = ctx11.useScopedContext;
var useTooltipProviderContext = ctx11.useProviderContext;
var TooltipContextProvider = ctx11.ContextProvider;
var TooltipScopedContextProvider = ctx11.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/X7QOZUD3.js
function getEventPoint(event) {
return [event.clientX, event.clientY];
}
function isPointInPolygon(point, polygon) {
const [x2, y3] = point;
let inside = false;
const length2 = polygon.length;
for (let l3 = length2, i3 = 0, j2 = l3 - 1; i3 < l3; j2 = i3++) {
const [xi, yi] = polygon[i3];
const [xj, yj] = polygon[j2];
const [, vy] = polygon[j2 === 0 ? l3 - 1 : j2 - 1] || [0, 0];
const where = (yi - yj) * (x2 - xi) - (xi - xj) * (y3 - yi);
if (yj < yi) {
if (y3 >= yj && y3 < yi) {
if (where === 0) return true;
if (where > 0) {
if (y3 === yj) {
if (y3 > vy) {
inside = !inside;
}
} else {
inside = !inside;
}
}
}
} else if (yi < yj) {
if (y3 > yi && y3 <= yj) {
if (where === 0) return true;
if (where < 0) {
if (y3 === yj) {
if (y3 < vy) {
inside = !inside;
}
} else {
inside = !inside;
}
}
}
} else if (y3 === yi && (x2 >= xj && x2 <= xi || x2 >= xi && x2 <= xj)) {
return true;
}
}
return inside;
}
function getEnterPointPlacement(enterPoint, rect) {
const { top, right, bottom, left } = rect;
const [x2, y3] = enterPoint;
const placementX = x2 < left ? "left" : x2 > right ? "right" : null;
const placementY = y3 < top ? "top" : y3 > bottom ? "bottom" : null;
return [placementX, placementY];
}
function getElementPolygon(element, enterPoint) {
const rect = element.getBoundingClientRect();
const { top, right, bottom, left } = rect;
const [x2, y3] = getEnterPointPlacement(enterPoint, rect);
const polygon = [enterPoint];
if (x2) {
if (y3 !== "top") {
polygon.push([x2 === "left" ? left : right, top]);
}
polygon.push([x2 === "left" ? right : left, top]);
polygon.push([x2 === "left" ? right : left, bottom]);
if (y3 !== "bottom") {
polygon.push([x2 === "left" ? left : right, bottom]);
}
} else if (y3 === "top") {
polygon.push([left, top]);
polygon.push([left, bottom]);
polygon.push([right, bottom]);
polygon.push([right, top]);
} else {
polygon.push([left, bottom]);
polygon.push([left, top]);
polygon.push([right, top]);
polygon.push([right, bottom]);
}
return polygon;
}
// node_modules/@ariakit/react-core/esm/__chunks/AOQQTIBO.js
var import_react17 = __toESM(require_react(), 1);
var PortalContext = (0, import_react17.createContext)(null);
// node_modules/@ariakit/react-core/esm/__chunks/2F57YTN4.js
var TagName14 = "span";
var useVisuallyHidden = createHook(
function useVisuallyHidden2(props) {
props = {
...props,
style: {
border: 0,
clip: "rect(0 0 0 0)",
height: "1px",
margin: "-1px",
overflow: "hidden",
padding: 0,
position: "absolute",
whiteSpace: "nowrap",
width: "1px",
...props.style
}
};
return props;
}
);
var VisuallyHidden = forwardRef2(function VisuallyHidden2(props) {
const htmlProps = useVisuallyHidden(props);
return createElement(TagName14, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/BFOIJXK2.js
var TagName15 = "span";
var useFocusTrap = createHook(
function useFocusTrap2(props) {
props = {
"data-focus-trap": "",
tabIndex: 0,
"aria-hidden": true,
...props,
style: {
// Prevents unintended scroll jumps.
position: "fixed",
top: 0,
left: 0,
...props.style
}
};
props = useVisuallyHidden(props);
return props;
}
);
var FocusTrap = forwardRef2(function FocusTrap2(props) {
const htmlProps = useFocusTrap(props);
return createElement(TagName15, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/VJH3F6TN.js
var import_react18 = __toESM(require_react(), 1);
var import_react_dom2 = __toESM(require_react_dom(), 1);
var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1);
var TagName16 = "div";
function getRootElement(element) {
return getDocument(element).body;
}
function getPortalElement(element, portalElement) {
if (!portalElement) {
return getDocument(element).createElement("div");
}
if (typeof portalElement === "function") {
return portalElement(element);
}
return portalElement;
}
function getRandomId(prefix2 = "id") {
return `${prefix2 ? `${prefix2}-` : ""}${Math.random().toString(36).slice(2, 8)}`;
}
function queueFocus(element) {
queueMicrotask(() => {
element == null ? void 0 : element.focus();
});
}
var usePortal = createHook(function usePortal2({
preserveTabOrder,
preserveTabOrderAnchor,
portalElement,
portalRef,
portal = true,
...props
}) {
const ref = (0, import_react18.useRef)(null);
const refProp = useMergeRefs(ref, props.ref);
const context = (0, import_react18.useContext)(PortalContext);
const [portalNode, setPortalNode] = (0, import_react18.useState)(null);
const [anchorPortalNode, setAnchorPortalNode] = (0, import_react18.useState)(
null
);
const outerBeforeRef = (0, import_react18.useRef)(null);
const innerBeforeRef = (0, import_react18.useRef)(null);
const innerAfterRef = (0, import_react18.useRef)(null);
const outerAfterRef = (0, import_react18.useRef)(null);
useSafeLayoutEffect(() => {
const element = ref.current;
if (!element || !portal) {
setPortalNode(null);
return;
}
const portalEl = getPortalElement(element, portalElement);
if (!portalEl) {
setPortalNode(null);
return;
}
const isPortalInDocument = portalEl.isConnected;
if (!isPortalInDocument) {
const rootElement = context || getRootElement(element);
rootElement.appendChild(portalEl);
}
if (!portalEl.id) {
portalEl.id = element.id ? `portal/${element.id}` : getRandomId();
}
setPortalNode(portalEl);
setRef(portalRef, portalEl);
if (isPortalInDocument) return;
return () => {
portalEl.remove();
setRef(portalRef, null);
};
}, [portal, portalElement, context, portalRef]);
useSafeLayoutEffect(() => {
if (!portal) return;
if (!preserveTabOrder) return;
if (!preserveTabOrderAnchor) return;
const doc = getDocument(preserveTabOrderAnchor);
const element = doc.createElement("span");
element.style.position = "fixed";
preserveTabOrderAnchor.insertAdjacentElement("afterend", element);
setAnchorPortalNode(element);
return () => {
element.remove();
setAnchorPortalNode(null);
};
}, [portal, preserveTabOrder, preserveTabOrderAnchor]);
(0, import_react18.useEffect)(() => {
if (!portalNode) return;
if (!preserveTabOrder) return;
let raf = 0;
const onFocus = (event) => {
if (!isFocusEventOutside(event)) return;
const focusing = event.type === "focusin";
cancelAnimationFrame(raf);
if (focusing) {
return restoreFocusIn(portalNode);
}
raf = requestAnimationFrame(() => {
disableFocusIn(portalNode, true);
});
};
portalNode.addEventListener("focusin", onFocus, true);
portalNode.addEventListener("focusout", onFocus, true);
return () => {
cancelAnimationFrame(raf);
portalNode.removeEventListener("focusin", onFocus, true);
portalNode.removeEventListener("focusout", onFocus, true);
};
}, [portalNode, preserveTabOrder]);
props = useWrapElement(
props,
(element) => {
element = // While the portal node is not in the DOM, we need to pass the
// current context to the portal context, otherwise it's going to
// reset to the body element on nested portals.
/* @__PURE__ */ (0, import_jsx_runtime9.jsx)(PortalContext.Provider, { value: portalNode || context, children: element });
if (!portal) return element;
if (!portalNode) {
return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
"span",
{
ref: refProp,
id: props.id,
style: { position: "fixed" },
hidden: true
}
);
}
element = /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
preserveTabOrder && portalNode && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
FocusTrap,
{
ref: innerBeforeRef,
"data-focus-trap": props.id,
className: "__focus-trap-inner-before",
onFocus: (event) => {
if (isFocusEventOutside(event, portalNode)) {
queueFocus(getNextTabbable());
} else {
queueFocus(outerBeforeRef.current);
}
}
}
),
element,
preserveTabOrder && portalNode && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
FocusTrap,
{
ref: innerAfterRef,
"data-focus-trap": props.id,
className: "__focus-trap-inner-after",
onFocus: (event) => {
if (isFocusEventOutside(event, portalNode)) {
queueFocus(getPreviousTabbable());
} else {
queueFocus(outerAfterRef.current);
}
}
}
)
] });
if (portalNode) {
element = (0, import_react_dom2.createPortal)(element, portalNode);
}
let preserveTabOrderElement = /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
preserveTabOrder && portalNode && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
FocusTrap,
{
ref: outerBeforeRef,
"data-focus-trap": props.id,
className: "__focus-trap-outer-before",
onFocus: (event) => {
const fromOuter = event.relatedTarget === outerAfterRef.current;
if (!fromOuter && isFocusEventOutside(event, portalNode)) {
queueFocus(innerBeforeRef.current);
} else {
queueFocus(getPreviousTabbable());
}
}
}
),
preserveTabOrder && // We're using position: fixed here so that the browser doesn't
// add margin to the element when setting gap on a parent element.
/* @__PURE__ */ (0, import_jsx_runtime9.jsx)("span", { "aria-owns": portalNode == null ? void 0 : portalNode.id, style: { position: "fixed" } }),
preserveTabOrder && portalNode && /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
FocusTrap,
{
ref: outerAfterRef,
"data-focus-trap": props.id,
className: "__focus-trap-outer-after",
onFocus: (event) => {
if (isFocusEventOutside(event, portalNode)) {
queueFocus(innerAfterRef.current);
} else {
const nextTabbable = getNextTabbable();
if (nextTabbable === innerBeforeRef.current) {
requestAnimationFrame(() => {
var _a;
return (_a = getNextTabbable()) == null ? void 0 : _a.focus();
});
return;
}
queueFocus(nextTabbable);
}
}
}
)
] });
if (anchorPortalNode && preserveTabOrder) {
preserveTabOrderElement = (0, import_react_dom2.createPortal)(
preserveTabOrderElement,
anchorPortalNode
);
}
return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_jsx_runtime9.Fragment, { children: [
preserveTabOrderElement,
element
] });
},
[portalNode, context, portal, props.id, preserveTabOrder, anchorPortalNode]
);
props = {
...props,
ref: refProp
};
return props;
});
var Portal = forwardRef2(function Portal2(props) {
const htmlProps = usePortal(props);
return createElement(TagName16, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/CZ4GFWYL.js
var import_react19 = __toESM(require_react(), 1);
var HeadingContext = (0, import_react19.createContext)(0);
// node_modules/@ariakit/react-core/esm/__chunks/5M6RIVE2.js
var import_react20 = __toESM(require_react(), 1);
var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1);
function HeadingLevel({ level, children }) {
const contextLevel = (0, import_react20.useContext)(HeadingContext);
const nextLevel = Math.max(
Math.min(level || contextLevel + 1, 6),
1
);
return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(HeadingContext.Provider, { value: nextLevel, children });
}
// node_modules/@ariakit/react-core/esm/__chunks/3HM4TGWW.js
var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1);
var TagName17 = "div";
var useFocusableContainer = createHook(function useFocusableContainer2({ autoFocusOnShow = true, ...props }) {
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(FocusableContext.Provider, { value: autoFocusOnShow, children: element }),
[autoFocusOnShow]
);
return props;
});
var FocusableContainer = forwardRef2(function FocusableContainer2(props) {
const htmlProps = useFocusableContainer(props);
return createElement(TagName17, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/6GXEOXGT.js
function prependHiddenDismiss(container, onClick) {
const document2 = getDocument(container);
const button = document2.createElement("button");
button.type = "button";
button.tabIndex = -1;
button.textContent = "Dismiss popup";
Object.assign(button.style, {
border: "0px",
clip: "rect(0 0 0 0)",
height: "1px",
margin: "-1px",
overflow: "hidden",
padding: "0px",
position: "absolute",
whiteSpace: "nowrap",
width: "1px"
});
button.addEventListener("click", onClick);
container.prepend(button);
const removeHiddenDismiss = () => {
button.removeEventListener("click", onClick);
button.remove();
};
return removeHiddenDismiss;
}
// node_modules/@ariakit/react-core/esm/__chunks/U3R3WHDK.js
var import_react21 = __toESM(require_react(), 1);
function usePreviousMouseDownRef(enabled) {
const previousMouseDownRef = (0, import_react21.useRef)(null);
(0, import_react21.useEffect)(() => {
if (!enabled) {
previousMouseDownRef.current = null;
return;
}
const onMouseDown = (event) => {
previousMouseDownRef.current = event.target;
};
return addGlobalEventListener("mousedown", onMouseDown, true);
}, [enabled]);
return previousMouseDownRef;
}
// node_modules/@ariakit/react-core/esm/__chunks/K2ZF5NU7.js
var cleanups = /* @__PURE__ */ new WeakMap();
function orchestrate(element, key, setup2) {
if (!cleanups.has(element)) {
cleanups.set(element, /* @__PURE__ */ new Map());
}
const elementCleanups = cleanups.get(element);
const prevCleanup = elementCleanups.get(key);
if (!prevCleanup) {
elementCleanups.set(key, setup2());
return () => {
var _a;
(_a = elementCleanups.get(key)) == null ? void 0 : _a();
elementCleanups.delete(key);
};
}
const cleanup = setup2();
const nextCleanup = () => {
cleanup();
prevCleanup();
elementCleanups.delete(key);
};
elementCleanups.set(key, nextCleanup);
return () => {
const isCurrent = elementCleanups.get(key) === nextCleanup;
if (!isCurrent) return;
cleanup();
elementCleanups.set(key, prevCleanup);
};
}
function setAttribute(element, attr, value) {
const setup2 = () => {
const previousValue = element.getAttribute(attr);
element.setAttribute(attr, value);
return () => {
if (previousValue == null) {
element.removeAttribute(attr);
} else {
element.setAttribute(attr, previousValue);
}
};
};
return orchestrate(element, attr, setup2);
}
function setProperty(element, property, value) {
const setup2 = () => {
const exists = property in element;
const previousValue = element[property];
element[property] = value;
return () => {
if (!exists) {
delete element[property];
} else {
element[property] = previousValue;
}
};
};
return orchestrate(element, property, setup2);
}
function assignStyle(element, style2) {
if (!element) return () => {
};
const setup2 = () => {
const prevStyle = element.style.cssText;
Object.assign(element.style, style2);
return () => {
element.style.cssText = prevStyle;
};
};
return orchestrate(element, "style", setup2);
}
function setCSSProperty(element, property, value) {
if (!element) return () => {
};
const setup2 = () => {
const previousValue = element.style.getPropertyValue(property);
element.style.setProperty(property, value);
return () => {
if (previousValue) {
element.style.setProperty(property, previousValue);
} else {
element.style.removeProperty(property);
}
};
};
return orchestrate(element, property, setup2);
}
// node_modules/@ariakit/react-core/esm/__chunks/AOUGVQZ3.js
var ignoreTags = ["SCRIPT", "STYLE"];
function getSnapshotPropertyName(id3) {
return `__ariakit-dialog-snapshot-${id3}`;
}
function inSnapshot(id3, element) {
const doc = getDocument(element);
const propertyName = getSnapshotPropertyName(id3);
if (!doc.body[propertyName]) return true;
do {
if (element === doc.body) return false;
if (element[propertyName]) return true;
if (!element.parentElement) return false;
element = element.parentElement;
} while (true);
}
function isValidElement3(id3, element, ignoredElements) {
if (ignoreTags.includes(element.tagName)) return false;
if (!inSnapshot(id3, element)) return false;
return !ignoredElements.some(
(enabledElement) => enabledElement && contains(element, enabledElement)
);
}
function walkTreeOutside(id3, elements2, callback, ancestorCallback) {
for (let element of elements2) {
if (!(element == null ? void 0 : element.isConnected)) continue;
const hasAncestorAlready = elements2.some((maybeAncestor) => {
if (!maybeAncestor) return false;
if (maybeAncestor === element) return false;
return maybeAncestor.contains(element);
});
const doc = getDocument(element);
const originalElement = element;
while (element.parentElement && element !== doc.body) {
ancestorCallback == null ? void 0 : ancestorCallback(element.parentElement, originalElement);
if (!hasAncestorAlready) {
for (const child of element.parentElement.children) {
if (isValidElement3(id3, child, elements2)) {
callback(child, originalElement);
}
}
}
element = element.parentElement;
}
}
}
function createWalkTreeSnapshot(id3, elements2) {
const { body } = getDocument(elements2[0]);
const cleanups2 = [];
const markElement2 = (element) => {
cleanups2.push(setProperty(element, getSnapshotPropertyName(id3), true));
};
walkTreeOutside(id3, elements2, markElement2);
return chain(setProperty(body, getSnapshotPropertyName(id3), true), () => {
for (const cleanup of cleanups2) {
cleanup();
}
});
}
// node_modules/@ariakit/react-core/esm/__chunks/63XF7ACK.js
function isBackdrop(element, ...ids) {
if (!element) return false;
const backdrop = element.getAttribute("data-backdrop");
if (backdrop == null) return false;
if (backdrop === "") return true;
if (backdrop === "true") return true;
if (!ids.length) return true;
return ids.some((id3) => backdrop === id3);
}
// node_modules/@ariakit/react-core/esm/__chunks/3NDVDEB4.js
function getPropertyName(id3 = "", ancestor = false) {
return `__ariakit-dialog-${ancestor ? "ancestor" : "outside"}${id3 ? `-${id3}` : ""}`;
}
function markElement(element, id3 = "") {
return chain(
setProperty(element, getPropertyName(), true),
setProperty(element, getPropertyName(id3), true)
);
}
function markAncestor(element, id3 = "") {
return chain(
setProperty(element, getPropertyName("", true), true),
setProperty(element, getPropertyName(id3, true), true)
);
}
function isElementMarked(element, id3) {
const ancestorProperty = getPropertyName(id3, true);
if (element[ancestorProperty]) return true;
const elementProperty = getPropertyName(id3);
do {
if (element[elementProperty]) return true;
if (!element.parentElement) return false;
element = element.parentElement;
} while (true);
}
function markTreeOutside(id3, elements2) {
const cleanups2 = [];
const ids = elements2.map((el) => el == null ? void 0 : el.id);
walkTreeOutside(
id3,
elements2,
(element) => {
if (isBackdrop(element, ...ids)) return;
cleanups2.unshift(markElement(element, id3));
},
(ancestor, element) => {
const isAnotherDialogAncestor = element.hasAttribute("data-dialog") && element.id !== id3;
if (isAnotherDialogAncestor) return;
cleanups2.unshift(markAncestor(ancestor, id3));
}
);
const restoreAccessibilityTree = () => {
for (const cleanup of cleanups2) {
cleanup();
}
};
return restoreAccessibilityTree;
}
// node_modules/@ariakit/react-core/esm/__chunks/KKITJVHA.js
var import_react22 = __toESM(require_react(), 1);
function isInDocument(target) {
if (target.tagName === "HTML") return true;
return contains(getDocument(target).body, target);
}
function isDisclosure(disclosure, target) {
if (!disclosure) return false;
if (contains(disclosure, target)) return true;
const activeId = target.getAttribute("aria-activedescendant");
if (activeId) {
const activeElement = getDocument(disclosure).getElementById(activeId);
if (activeElement) {
return contains(disclosure, activeElement);
}
}
return false;
}
function isMouseEventOnDialog(event, dialog) {
if (!("clientY" in event)) return false;
const rect = dialog.getBoundingClientRect();
if (rect.width === 0 || rect.height === 0) return false;
return rect.top <= event.clientY && event.clientY <= rect.top + rect.height && rect.left <= event.clientX && event.clientX <= rect.left + rect.width;
}
function useEventOutside({
store,
type,
listener,
capture,
domReady
}) {
const callListener = useEvent(listener);
const open = useStoreState(store, "open");
const focusedRef = (0, import_react22.useRef)(false);
useSafeLayoutEffect(() => {
if (!open) return;
if (!domReady) return;
const { contentElement } = store.getState();
if (!contentElement) return;
const onFocus = () => {
focusedRef.current = true;
};
contentElement.addEventListener("focusin", onFocus, true);
return () => contentElement.removeEventListener("focusin", onFocus, true);
}, [store, open, domReady]);
(0, import_react22.useEffect)(() => {
if (!open) return;
const onEvent = (event) => {
const { contentElement, disclosureElement } = store.getState();
const target = event.target;
if (!contentElement) return;
if (!target) return;
if (!isInDocument(target)) return;
if (contains(contentElement, target)) return;
if (isDisclosure(disclosureElement, target)) return;
if (target.hasAttribute("data-focus-trap")) return;
if (isMouseEventOnDialog(event, contentElement)) return;
const focused = focusedRef.current;
if (focused && !isElementMarked(target, contentElement.id)) return;
if (isSafariFocusAncestor(target)) return;
callListener(event);
};
return addGlobalEventListener(type, onEvent, capture);
}, [open, capture]);
}
function shouldHideOnInteractOutside(hideOnInteractOutside, event) {
if (typeof hideOnInteractOutside === "function") {
return hideOnInteractOutside(event);
}
return !!hideOnInteractOutside;
}
function useHideOnInteractOutside(store, hideOnInteractOutside, domReady) {
const open = useStoreState(store, "open");
const previousMouseDownRef = usePreviousMouseDownRef(open);
const props = { store, domReady, capture: true };
useEventOutside({
...props,
type: "click",
listener: (event) => {
const { contentElement } = store.getState();
const previousMouseDown = previousMouseDownRef.current;
if (!previousMouseDown) return;
if (!isVisible(previousMouseDown)) return;
if (!isElementMarked(previousMouseDown, contentElement == null ? void 0 : contentElement.id)) return;
if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
store.hide();
}
});
useEventOutside({
...props,
type: "focusin",
listener: (event) => {
const { contentElement } = store.getState();
if (!contentElement) return;
if (event.target === getDocument(contentElement)) return;
if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
store.hide();
}
});
useEventOutside({
...props,
type: "contextmenu",
listener: (event) => {
if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
store.hide();
}
});
}
// node_modules/@ariakit/react-core/esm/__chunks/JSI7U3EA.js
var import_react23 = __toESM(require_react(), 1);
var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1);
var NestedDialogsContext = (0, import_react23.createContext)({});
function useNestedDialogs(store) {
const context = (0, import_react23.useContext)(NestedDialogsContext);
const [dialogs, setDialogs] = (0, import_react23.useState)([]);
const add2 = (0, import_react23.useCallback)(
(dialog) => {
var _a;
setDialogs((dialogs2) => [...dialogs2, dialog]);
return chain((_a = context.add) == null ? void 0 : _a.call(context, dialog), () => {
setDialogs((dialogs2) => dialogs2.filter((d3) => d3 !== dialog));
});
},
[context]
);
useSafeLayoutEffect(() => {
return sync(store, ["open", "contentElement"], (state) => {
var _a;
if (!state.open) return;
if (!state.contentElement) return;
return (_a = context.add) == null ? void 0 : _a.call(context, store);
});
}, [store, context]);
const providerValue = (0, import_react23.useMemo)(() => ({ store, add: add2 }), [store, add2]);
const wrapElement = (0, import_react23.useCallback)(
(element) => /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(NestedDialogsContext.Provider, { value: providerValue, children: element }),
[providerValue]
);
return { wrapElement, nestedDialogs: dialogs };
}
// node_modules/@ariakit/react-core/esm/__chunks/OT5RJDXG.js
var import_react24 = __toESM(require_react(), 1);
var import_react_dom3 = __toESM(require_react_dom(), 1);
function useRootDialog({
attribute,
contentId,
contentElement,
enabled
}) {
const [updated, retry] = useForceUpdate();
const isRootDialog = (0, import_react24.useCallback)(() => {
if (!enabled) return false;
if (!contentElement) return false;
const { body } = getDocument(contentElement);
const id3 = body.getAttribute(attribute);
return !id3 || id3 === contentId;
}, [updated, enabled, contentElement, attribute, contentId]);
(0, import_react24.useEffect)(() => {
if (!enabled) return;
if (!contentId) return;
if (!contentElement) return;
const { body } = getDocument(contentElement);
if (isRootDialog()) {
body.setAttribute(attribute, contentId);
return () => body.removeAttribute(attribute);
}
const observer = new MutationObserver(() => (0, import_react_dom3.flushSync)(retry));
observer.observe(body, { attributeFilter: [attribute] });
return () => observer.disconnect();
}, [updated, enabled, contentId, contentElement, isRootDialog, attribute]);
return isRootDialog;
}
// node_modules/@ariakit/react-core/esm/__chunks/B6W4QFKS.js
var import_react25 = __toESM(require_react(), 1);
function getPaddingProperty(documentElement) {
const documentLeft = documentElement.getBoundingClientRect().left;
const scrollbarX = Math.round(documentLeft) + documentElement.scrollLeft;
return scrollbarX ? "paddingLeft" : "paddingRight";
}
function usePreventBodyScroll(contentElement, contentId, enabled) {
const isRootDialog = useRootDialog({
attribute: "data-dialog-prevent-body-scroll",
contentElement,
contentId,
enabled
});
(0, import_react25.useEffect)(() => {
if (!isRootDialog()) return;
if (!contentElement) return;
const doc = getDocument(contentElement);
const win = getWindow(contentElement);
const { documentElement, body } = doc;
const cssScrollbarWidth = documentElement.style.getPropertyValue("--scrollbar-width");
const scrollbarWidth = cssScrollbarWidth ? Number.parseInt(cssScrollbarWidth, 10) : win.innerWidth - documentElement.clientWidth;
const setScrollbarWidthProperty = () => setCSSProperty(
documentElement,
"--scrollbar-width",
`${scrollbarWidth}px`
);
const paddingProperty = getPaddingProperty(documentElement);
const setStyle = () => assignStyle(body, {
overflow: "hidden",
[paddingProperty]: `${scrollbarWidth}px`
});
const setIOSStyle = () => {
var _a, _b;
const { scrollX: scrollX2, scrollY: scrollY2, visualViewport } = win;
const offsetLeft = (_a = visualViewport == null ? void 0 : visualViewport.offsetLeft) != null ? _a : 0;
const offsetTop = (_b = visualViewport == null ? void 0 : visualViewport.offsetTop) != null ? _b : 0;
const restoreStyle = assignStyle(body, {
position: "fixed",
overflow: "hidden",
top: `${-(scrollY2 - Math.floor(offsetTop))}px`,
left: `${-(scrollX2 - Math.floor(offsetLeft))}px`,
right: "0",
[paddingProperty]: `${scrollbarWidth}px`
});
return () => {
restoreStyle();
if (true) {
win.scrollTo({ left: scrollX2, top: scrollY2, behavior: "instant" });
}
};
};
const isIOS = isApple() && !isMac();
return chain(
setScrollbarWidthProperty(),
isIOS ? setIOSStyle() : setStyle()
);
}, [isRootDialog, contentElement]);
}
// node_modules/@ariakit/react-core/esm/__chunks/IGR4SXG2.js
function isFocusTrap(element, ...ids) {
if (!element) return false;
const attr = element.getAttribute("data-focus-trap");
if (attr == null) return false;
if (!ids.length) return true;
if (attr === "") return false;
return ids.some((id3) => attr === id3);
}
// node_modules/@ariakit/react-core/esm/__chunks/677M2CI3.js
function supportsInert() {
return "inert" in HTMLElement.prototype;
}
// node_modules/@ariakit/react-core/esm/__chunks/S7U6BLGA.js
function hideElementFromAccessibilityTree(element) {
return setAttribute(element, "aria-hidden", "true");
}
// node_modules/@ariakit/react-core/esm/__chunks/Z5GCVBAY.js
function disableTree(element, ignoredElements) {
if (!("style" in element)) return noop;
if (supportsInert()) {
return setProperty(element, "inert", true);
}
const tabbableElements = getAllTabbableIn(element, true);
const enableElements = tabbableElements.map((element2) => {
if (ignoredElements == null ? void 0 : ignoredElements.some((el) => el && contains(el, element2))) return noop;
const restoreFocusMethod = orchestrate(element2, "focus", () => {
element2.focus = noop;
return () => {
delete element2.focus;
};
});
return chain(setAttribute(element2, "tabindex", "-1"), restoreFocusMethod);
});
return chain(
...enableElements,
hideElementFromAccessibilityTree(element),
assignStyle(element, {
pointerEvents: "none",
userSelect: "none",
cursor: "default"
})
);
}
function disableTreeOutside(id3, elements2) {
const cleanups2 = [];
const ids = elements2.map((el) => el == null ? void 0 : el.id);
walkTreeOutside(
id3,
elements2,
(element) => {
if (isBackdrop(element, ...ids)) return;
if (isFocusTrap(element, ...ids)) return;
cleanups2.unshift(disableTree(element, elements2));
},
(element) => {
if (!element.hasAttribute("role")) return;
if (elements2.some((el) => el && contains(el, element))) return;
cleanups2.unshift(setAttribute(element, "role", "none"));
}
);
const restoreTreeOutside = () => {
for (const cleanup of cleanups2) {
cleanup();
}
};
return restoreTreeOutside;
}
// node_modules/@ariakit/react-core/esm/__chunks/JG4VNI52.js
var TagName18 = "div";
var elements = [
"a",
"button",
"details",
"dialog",
"div",
"form",
"h1",
"h2",
"h3",
"h4",
"h5",
"h6",
"header",
"img",
"input",
"label",
"li",
"nav",
"ol",
"p",
"section",
"select",
"span",
"summary",
"textarea",
"ul",
"svg"
];
var useRole = createHook(
function useRole2(props) {
return props;
}
);
var Role = forwardRef2(
// @ts-expect-error
function Role2(props) {
return createElement(TagName18, props);
}
);
Object.assign(
Role,
elements.reduce((acc, element) => {
acc[element] = forwardRef2(function Role3(props) {
return createElement(element, props);
});
return acc;
}, {})
);
// node_modules/@ariakit/react-core/esm/__chunks/P45QRJLH.js
var import_react26 = __toESM(require_react(), 1);
var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1);
function DialogBackdrop({
store,
backdrop,
alwaysVisible,
hidden
}) {
const ref = (0, import_react26.useRef)(null);
const disclosure = useDisclosureStore({ disclosure: store });
const contentElement = useStoreState(store, "contentElement");
(0, import_react26.useEffect)(() => {
const backdrop2 = ref.current;
const dialog = contentElement;
if (!backdrop2) return;
if (!dialog) return;
backdrop2.style.zIndex = getComputedStyle(dialog).zIndex;
}, [contentElement]);
useSafeLayoutEffect(() => {
const id3 = contentElement == null ? void 0 : contentElement.id;
if (!id3) return;
const backdrop2 = ref.current;
if (!backdrop2) return;
return markAncestor(backdrop2, id3);
}, [contentElement]);
const props = useDisclosureContent({
ref,
store: disclosure,
role: "presentation",
"data-backdrop": (contentElement == null ? void 0 : contentElement.id) || "",
alwaysVisible,
hidden: hidden != null ? hidden : void 0,
style: {
position: "fixed",
top: 0,
right: 0,
bottom: 0,
left: 0
}
});
if (!backdrop) return null;
if ((0, import_react26.isValidElement)(backdrop)) {
return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Role, { ...props, render: backdrop });
}
const Component9 = typeof backdrop !== "boolean" ? backdrop : "div";
return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Role, { ...props, render: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Component9, {}) });
}
// node_modules/@ariakit/core/esm/__chunks/KMAUV3TY.js
function createDialogStore(props = {}) {
return createDisclosureStore(props);
}
// node_modules/@ariakit/react-core/esm/__chunks/4NYSH4UO.js
function useDialogStoreProps(store, update, props) {
return useDisclosureStoreProps(store, update, props);
}
function useDialogStore(props = {}) {
const [store, update] = useStore(createDialogStore, props);
return useDialogStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/__chunks/Z32PU2LQ.js
var import_react27 = __toESM(require_react(), 1);
var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1);
var TagName19 = "div";
var isSafariBrowser2 = isSafari();
function isAlreadyFocusingAnotherElement(dialog) {
const activeElement = getActiveElement();
if (!activeElement) return false;
if (dialog && contains(dialog, activeElement)) return false;
if (isFocusable(activeElement)) return true;
return false;
}
function getElementFromProp(prop, focusable = false) {
if (!prop) return null;
const element = "current" in prop ? prop.current : prop;
if (!element) return null;
if (focusable) return isFocusable(element) ? element : null;
return element;
}
var useDialog = createHook(function useDialog2({
store: storeProp,
open: openProp,
onClose,
focusable = true,
modal = true,
portal = !!modal,
backdrop = !!modal,
hideOnEscape = true,
hideOnInteractOutside = true,
getPersistentElements,
preventBodyScroll = !!modal,
autoFocusOnShow = true,
autoFocusOnHide = true,
initialFocus,
finalFocus,
unmountOnHide,
unstable_treeSnapshotKey,
...props
}) {
const context = useDialogProviderContext();
const ref = (0, import_react27.useRef)(null);
const store = useDialogStore({
store: storeProp || context,
open: openProp,
setOpen(open2) {
if (open2) return;
const dialog = ref.current;
if (!dialog) return;
const event = new Event("close", { bubbles: false, cancelable: true });
if (onClose) {
dialog.addEventListener("close", onClose, { once: true });
}
dialog.dispatchEvent(event);
if (!event.defaultPrevented) return;
store.setOpen(true);
}
});
const { portalRef, domReady } = usePortalRef(portal, props.portalRef);
const preserveTabOrderProp = props.preserveTabOrder;
const preserveTabOrder = useStoreState(
store,
(state) => preserveTabOrderProp && !modal && state.mounted
);
const id3 = useId(props.id);
const open = useStoreState(store, "open");
const mounted = useStoreState(store, "mounted");
const contentElement = useStoreState(store, "contentElement");
const hidden = isHidden(mounted, props.hidden, props.alwaysVisible);
usePreventBodyScroll(contentElement, id3, preventBodyScroll && !hidden);
useHideOnInteractOutside(store, hideOnInteractOutside, domReady);
const { wrapElement, nestedDialogs } = useNestedDialogs(store);
props = useWrapElement(props, wrapElement, [wrapElement]);
useSafeLayoutEffect(() => {
if (!open) return;
const dialog = ref.current;
const activeElement = getActiveElement(dialog, true);
if (!activeElement) return;
if (activeElement.tagName === "BODY") return;
if (dialog && contains(dialog, activeElement)) return;
store.setDisclosureElement(activeElement);
}, [store, open]);
if (isSafariBrowser2) {
(0, import_react27.useEffect)(() => {
if (!mounted) return;
const { disclosureElement } = store.getState();
if (!disclosureElement) return;
if (!isButton(disclosureElement)) return;
const onMouseDown = () => {
let receivedFocus = false;
const onFocus = () => {
receivedFocus = true;
};
const options2 = { capture: true, once: true };
disclosureElement.addEventListener("focusin", onFocus, options2);
queueBeforeEvent(disclosureElement, "mouseup", () => {
disclosureElement.removeEventListener("focusin", onFocus, true);
if (receivedFocus) return;
focusIfNeeded(disclosureElement);
});
};
disclosureElement.addEventListener("mousedown", onMouseDown);
return () => {
disclosureElement.removeEventListener("mousedown", onMouseDown);
};
}, [store, mounted]);
}
(0, import_react27.useEffect)(() => {
if (!mounted) return;
if (!domReady) return;
const dialog = ref.current;
if (!dialog) return;
const win = getWindow(dialog);
const viewport = win.visualViewport || win;
const setViewportHeight = () => {
var _a, _b;
const height = (_b = (_a = win.visualViewport) == null ? void 0 : _a.height) != null ? _b : win.innerHeight;
dialog.style.setProperty("--dialog-viewport-height", `${height}px`);
};
setViewportHeight();
viewport.addEventListener("resize", setViewportHeight);
return () => {
viewport.removeEventListener("resize", setViewportHeight);
};
}, [mounted, domReady]);
(0, import_react27.useEffect)(() => {
if (!modal) return;
if (!mounted) return;
if (!domReady) return;
const dialog = ref.current;
if (!dialog) return;
const existingDismiss = dialog.querySelector("[data-dialog-dismiss]");
if (existingDismiss) return;
return prependHiddenDismiss(dialog, store.hide);
}, [store, modal, mounted, domReady]);
useSafeLayoutEffect(() => {
if (!supportsInert()) return;
if (open) return;
if (!mounted) return;
if (!domReady) return;
const dialog = ref.current;
if (!dialog) return;
return disableTree(dialog);
}, [open, mounted, domReady]);
const canTakeTreeSnapshot = open && domReady;
useSafeLayoutEffect(() => {
if (!id3) return;
if (!canTakeTreeSnapshot) return;
const dialog = ref.current;
return createWalkTreeSnapshot(id3, [dialog]);
}, [id3, canTakeTreeSnapshot, unstable_treeSnapshotKey]);
const getPersistentElementsProp = useEvent(getPersistentElements);
useSafeLayoutEffect(() => {
if (!id3) return;
if (!canTakeTreeSnapshot) return;
const { disclosureElement } = store.getState();
const dialog = ref.current;
const persistentElements = getPersistentElementsProp() || [];
const allElements = [
dialog,
...persistentElements,
...nestedDialogs.map((dialog2) => dialog2.getState().contentElement)
];
if (modal) {
return chain(
markTreeOutside(id3, allElements),
disableTreeOutside(id3, allElements)
);
}
return markTreeOutside(id3, [disclosureElement, ...allElements]);
}, [
id3,
store,
canTakeTreeSnapshot,
getPersistentElementsProp,
nestedDialogs,
modal,
unstable_treeSnapshotKey
]);
const mayAutoFocusOnShow = !!autoFocusOnShow;
const autoFocusOnShowProp = useBooleanEvent(autoFocusOnShow);
const [autoFocusEnabled, setAutoFocusEnabled] = (0, import_react27.useState)(false);
(0, import_react27.useEffect)(() => {
if (!open) return;
if (!mayAutoFocusOnShow) return;
if (!domReady) return;
if (!(contentElement == null ? void 0 : contentElement.isConnected)) return;
const element = getElementFromProp(initialFocus, true) || // If no initial focus is specified, we try to focus the first element
// with the autofocus attribute. If it's an Ariakit component, the
// Focusable component will consume the autoFocus prop and add the
// data-autofocus attribute to the element instead.
contentElement.querySelector(
"[data-autofocus=true],[autofocus]"
) || // We have to fallback to the first focusable element otherwise portaled
// dialogs with preserveTabOrder set to true will not receive focus
// properly because the elements aren't tabbable until the dialog receives
// focus.
getFirstTabbableIn(contentElement, true, portal && preserveTabOrder) || // Finally, we fallback to the dialog element itself.
contentElement;
const isElementFocusable = isFocusable(element);
if (!autoFocusOnShowProp(isElementFocusable ? element : null)) return;
setAutoFocusEnabled(true);
queueMicrotask(() => {
element.focus();
if (!isSafariBrowser2) return;
if (!isElementFocusable) return;
element.scrollIntoView({ block: "nearest", inline: "nearest" });
});
}, [
open,
mayAutoFocusOnShow,
domReady,
contentElement,
initialFocus,
portal,
preserveTabOrder,
autoFocusOnShowProp
]);
const mayAutoFocusOnHide = !!autoFocusOnHide;
const autoFocusOnHideProp = useBooleanEvent(autoFocusOnHide);
const [hasOpened, setHasOpened] = (0, import_react27.useState)(false);
(0, import_react27.useEffect)(() => {
if (!open) return;
setHasOpened(true);
return () => setHasOpened(false);
}, [open]);
const focusOnHide = (0, import_react27.useCallback)(
(dialog, retry = true) => {
const { disclosureElement } = store.getState();
if (isAlreadyFocusingAnotherElement(dialog)) return;
let element = getElementFromProp(finalFocus) || disclosureElement;
if (element == null ? void 0 : element.id) {
const doc = getDocument(element);
const selector2 = `[aria-activedescendant="${element.id}"]`;
const composite = doc.querySelector(selector2);
if (composite) {
element = composite;
}
}
if (element && !isFocusable(element)) {
const maybeParentDialog = element.closest("[data-dialog]");
if (maybeParentDialog == null ? void 0 : maybeParentDialog.id) {
const doc = getDocument(maybeParentDialog);
const selector2 = `[aria-controls~="${maybeParentDialog.id}"]`;
const control = doc.querySelector(selector2);
if (control) {
element = control;
}
}
}
const isElementFocusable = element && isFocusable(element);
if (!isElementFocusable && retry) {
requestAnimationFrame(() => focusOnHide(dialog, false));
return;
}
if (!autoFocusOnHideProp(isElementFocusable ? element : null)) return;
if (!isElementFocusable) return;
element == null ? void 0 : element.focus({ preventScroll: true });
},
[store, finalFocus, autoFocusOnHideProp]
);
const focusedOnHideRef = (0, import_react27.useRef)(false);
useSafeLayoutEffect(() => {
if (open) return;
if (!hasOpened) return;
if (!mayAutoFocusOnHide) return;
const dialog = ref.current;
focusedOnHideRef.current = true;
focusOnHide(dialog);
}, [open, hasOpened, domReady, mayAutoFocusOnHide, focusOnHide]);
(0, import_react27.useEffect)(() => {
if (!hasOpened) return;
if (!mayAutoFocusOnHide) return;
const dialog = ref.current;
return () => {
if (focusedOnHideRef.current) {
focusedOnHideRef.current = false;
return;
}
focusOnHide(dialog);
};
}, [hasOpened, mayAutoFocusOnHide, focusOnHide]);
const hideOnEscapeProp = useBooleanEvent(hideOnEscape);
(0, import_react27.useEffect)(() => {
if (!domReady) return;
if (!mounted) return;
const onKeyDown = (event) => {
if (event.key !== "Escape") return;
if (event.defaultPrevented) return;
const dialog = ref.current;
if (!dialog) return;
if (isElementMarked(dialog)) return;
const target = event.target;
if (!target) return;
const { disclosureElement } = store.getState();
const isValidTarget = () => {
if (target.tagName === "BODY") return true;
if (contains(dialog, target)) return true;
if (!disclosureElement) return true;
if (contains(disclosureElement, target)) return true;
return false;
};
if (!isValidTarget()) return;
if (!hideOnEscapeProp(event)) return;
store.hide();
};
return addGlobalEventListener("keydown", onKeyDown, true);
}, [store, domReady, mounted, hideOnEscapeProp]);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(HeadingLevel, { level: modal ? 1 : void 0, children: element }),
[modal]
);
const hiddenProp = props.hidden;
const alwaysVisible = props.alwaysVisible;
props = useWrapElement(
props,
(element) => {
if (!backdrop) return element;
return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [
/* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
DialogBackdrop,
{
store,
backdrop,
hidden: hiddenProp,
alwaysVisible
}
),
element
] });
},
[store, backdrop, hiddenProp, alwaysVisible]
);
const [headingId, setHeadingId] = (0, import_react27.useState)();
const [descriptionId, setDescriptionId] = (0, import_react27.useState)();
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogScopedContextProvider, { value: store, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogHeadingContext.Provider, { value: setHeadingId, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(DialogDescriptionContext.Provider, { value: setDescriptionId, children: element }) }) }),
[store]
);
props = {
id: id3,
"data-dialog": "",
role: "dialog",
tabIndex: focusable ? -1 : void 0,
"aria-labelledby": headingId,
"aria-describedby": descriptionId,
...props,
ref: useMergeRefs(ref, props.ref)
};
props = useFocusableContainer({
...props,
autoFocusOnShow: autoFocusEnabled
});
props = useDisclosureContent({ store, ...props });
props = useFocusable({ ...props, focusable });
props = usePortal({ portal, ...props, portalRef, preserveTabOrder });
return props;
});
function createDialogComponent(Component9, useProviderContext = useDialogProviderContext) {
return forwardRef2(function DialogComponent(props) {
const context = useProviderContext();
const store = props.store || context;
const mounted = useStoreState(
store,
(state) => !props.unmountOnHide || (state == null ? void 0 : state.mounted) || !!props.open
);
if (!mounted) return null;
return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Component9, { ...props });
});
}
var Dialog = createDialogComponent(
forwardRef2(function Dialog2(props) {
const htmlProps = useDialog(props);
return createElement(TagName19, htmlProps);
}),
useDialogProviderContext
);
// node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
var min = Math.min;
var max = Math.max;
var round = Math.round;
var floor = Math.floor;
var createCoords = (v3) => ({
x: v3,
y: v3
});
var oppositeSideMap = {
left: "right",
right: "left",
bottom: "top",
top: "bottom"
};
var oppositeAlignmentMap = {
start: "end",
end: "start"
};
function clamp(start, value, end) {
return max(start, min(value, end));
}
function evaluate(value, param) {
return typeof value === "function" ? value(param) : value;
}
function getSide(placement) {
return placement.split("-")[0];
}
function getAlignment(placement) {
return placement.split("-")[1];
}
function getOppositeAxis(axis) {
return axis === "x" ? "y" : "x";
}
function getAxisLength(axis) {
return axis === "y" ? "height" : "width";
}
var yAxisSides = /* @__PURE__ */ new Set(["top", "bottom"]);
function getSideAxis(placement) {
return yAxisSides.has(getSide(placement)) ? "y" : "x";
}
function getAlignmentAxis(placement) {
return getOppositeAxis(getSideAxis(placement));
}
function getAlignmentSides(placement, rects, rtl2) {
if (rtl2 === void 0) {
rtl2 = false;
}
const alignment = getAlignment(placement);
const alignmentAxis = getAlignmentAxis(placement);
const length2 = getAxisLength(alignmentAxis);
let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl2 ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
if (rects.reference[length2] > rects.floating[length2]) {
mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
}
return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
}
function getExpandedPlacements(placement) {
const oppositePlacement = getOppositePlacement(placement);
return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
}
function getOppositeAlignmentPlacement(placement) {
return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
}
var lrPlacement = ["left", "right"];
var rlPlacement = ["right", "left"];
var tbPlacement = ["top", "bottom"];
var btPlacement = ["bottom", "top"];
function getSideList(side, isStart, rtl2) {
switch (side) {
case "top":
case "bottom":
if (rtl2) return isStart ? rlPlacement : lrPlacement;
return isStart ? lrPlacement : rlPlacement;
case "left":
case "right":
return isStart ? tbPlacement : btPlacement;
default:
return [];
}
}
function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl2) {
const alignment = getAlignment(placement);
let list = getSideList(getSide(placement), direction === "start", rtl2);
if (alignment) {
list = list.map((side) => side + "-" + alignment);
if (flipAlignment) {
list = list.concat(list.map(getOppositeAlignmentPlacement));
}
}
return list;
}
function getOppositePlacement(placement) {
return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
}
function expandPaddingObject(padding2) {
return {
top: 0,
right: 0,
bottom: 0,
left: 0,
...padding2
};
}
function getPaddingObject(padding2) {
return typeof padding2 !== "number" ? expandPaddingObject(padding2) : {
top: padding2,
right: padding2,
bottom: padding2,
left: padding2
};
}
function rectToClientRect(rect) {
const {
x: x2,
y: y3,
width,
height
} = rect;
return {
width,
height,
top: y3,
left: x2,
right: x2 + width,
bottom: y3 + height,
x: x2,
y: y3
};
}
// node_modules/@floating-ui/core/dist/floating-ui.core.mjs
function computeCoordsFromPlacement(_ref11, placement, rtl2) {
let {
reference,
floating
} = _ref11;
const sideAxis = getSideAxis(placement);
const alignmentAxis = getAlignmentAxis(placement);
const alignLength = getAxisLength(alignmentAxis);
const side = getSide(placement);
const isVertical = sideAxis === "y";
const commonX = reference.x + reference.width / 2 - floating.width / 2;
const commonY = reference.y + reference.height / 2 - floating.height / 2;
const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
let coords;
switch (side) {
case "top":
coords = {
x: commonX,
y: reference.y - floating.height
};
break;
case "bottom":
coords = {
x: commonX,
y: reference.y + reference.height
};
break;
case "right":
coords = {
x: reference.x + reference.width,
y: commonY
};
break;
case "left":
coords = {
x: reference.x - floating.width,
y: commonY
};
break;
default:
coords = {
x: reference.x,
y: reference.y
};
}
switch (getAlignment(placement)) {
case "start":
coords[alignmentAxis] -= commonAlign * (rtl2 && isVertical ? -1 : 1);
break;
case "end":
coords[alignmentAxis] += commonAlign * (rtl2 && isVertical ? -1 : 1);
break;
}
return coords;
}
var computePosition = async (reference, floating, config) => {
const {
placement = "bottom",
strategy = "absolute",
middleware: middleware2 = [],
platform: platform2
} = config;
const validMiddleware = middleware2.filter(Boolean);
const rtl2 = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
let rects = await platform2.getElementRects({
reference,
floating,
strategy
});
let {
x: x2,
y: y3
} = computeCoordsFromPlacement(rects, placement, rtl2);
let statefulPlacement = placement;
let middlewareData = {};
let resetCount = 0;
for (let i3 = 0; i3 < validMiddleware.length; i3++) {
const {
name,
fn
} = validMiddleware[i3];
const {
x: nextX,
y: nextY,
data,
reset
} = await fn({
x: x2,
y: y3,
initialPlacement: placement,
placement: statefulPlacement,
strategy,
middlewareData,
rects,
platform: platform2,
elements: {
reference,
floating
}
});
x2 = nextX != null ? nextX : x2;
y3 = nextY != null ? nextY : y3;
middlewareData = {
...middlewareData,
[name]: {
...middlewareData[name],
...data
}
};
if (reset && resetCount <= 50) {
resetCount++;
if (typeof reset === "object") {
if (reset.placement) {
statefulPlacement = reset.placement;
}
if (reset.rects) {
rects = reset.rects === true ? await platform2.getElementRects({
reference,
floating,
strategy
}) : reset.rects;
}
({
x: x2,
y: y3
} = computeCoordsFromPlacement(rects, statefulPlacement, rtl2));
}
i3 = -1;
}
}
return {
x: x2,
y: y3,
placement: statefulPlacement,
strategy,
middlewareData
};
};
async function detectOverflow(state, options2) {
var _await$platform$isEle;
if (options2 === void 0) {
options2 = {};
}
const {
x: x2,
y: y3,
platform: platform2,
rects,
elements: elements2,
strategy
} = state;
const {
boundary = "clippingAncestors",
rootBoundary = "viewport",
elementContext = "floating",
altBoundary = false,
padding: padding2 = 0
} = evaluate(options2, state);
const paddingObject = getPaddingObject(padding2);
const altContext = elementContext === "floating" ? "reference" : "floating";
const element = elements2[altBoundary ? altContext : elementContext];
const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements2.floating)),
boundary,
rootBoundary,
strategy
}));
const rect = elementContext === "floating" ? {
x: x2,
y: y3,
width: rects.floating.width,
height: rects.floating.height
} : rects.reference;
const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements2.floating));
const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
x: 1,
y: 1
} : {
x: 1,
y: 1
};
const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
elements: elements2,
rect,
offsetParent,
strategy
}) : rect);
return {
top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
};
}
var arrow = (options2) => ({
name: "arrow",
options: options2,
async fn(state) {
const {
x: x2,
y: y3,
placement,
rects,
platform: platform2,
elements: elements2,
middlewareData
} = state;
const {
element,
padding: padding2 = 0
} = evaluate(options2, state) || {};
if (element == null) {
return {};
}
const paddingObject = getPaddingObject(padding2);
const coords = {
x: x2,
y: y3
};
const axis = getAlignmentAxis(placement);
const length2 = getAxisLength(axis);
const arrowDimensions = await platform2.getDimensions(element);
const isYAxis = axis === "y";
const minProp = isYAxis ? "top" : "left";
const maxProp = isYAxis ? "bottom" : "right";
const clientProp = isYAxis ? "clientHeight" : "clientWidth";
const endDiff = rects.reference[length2] + rects.reference[axis] - coords[axis] - rects.floating[length2];
const startDiff = coords[axis] - rects.reference[axis];
const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element));
let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
clientSize = elements2.floating[clientProp] || rects.floating[length2];
}
const centerToReference = endDiff / 2 - startDiff / 2;
const largestPossiblePadding = clientSize / 2 - arrowDimensions[length2] / 2 - 1;
const minPadding = min(paddingObject[minProp], largestPossiblePadding);
const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
const min$1 = minPadding;
const max3 = clientSize - arrowDimensions[length2] - maxPadding;
const center = clientSize / 2 - arrowDimensions[length2] / 2 + centerToReference;
const offset3 = clamp(min$1, center, max3);
const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset3 && rects.reference[length2] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length2] / 2 < 0;
const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max3 : 0;
return {
[axis]: coords[axis] + alignmentOffset,
data: {
[axis]: offset3,
centerOffset: center - offset3 - alignmentOffset,
...shouldAddOffset && {
alignmentOffset
}
},
reset: shouldAddOffset
};
}
});
var flip = function(options2) {
if (options2 === void 0) {
options2 = {};
}
return {
name: "flip",
options: options2,
async fn(state) {
var _middlewareData$arrow, _middlewareData$flip;
const {
placement,
middlewareData,
rects,
initialPlacement,
platform: platform2,
elements: elements2
} = state;
const {
mainAxis: checkMainAxis = true,
crossAxis: checkCrossAxis = true,
fallbackPlacements: specifiedFallbackPlacements,
fallbackStrategy = "bestFit",
fallbackAxisSideDirection = "none",
flipAlignment = true,
...detectOverflowOptions
} = evaluate(options2, state);
if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
return {};
}
const side = getSide(placement);
const initialSideAxis = getSideAxis(initialPlacement);
const isBasePlacement = getSide(initialPlacement) === initialPlacement;
const rtl2 = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements2.floating));
const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none";
if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl2));
}
const placements2 = [initialPlacement, ...fallbackPlacements];
const overflow = await detectOverflow(state, detectOverflowOptions);
const overflows = [];
let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
if (checkMainAxis) {
overflows.push(overflow[side]);
}
if (checkCrossAxis) {
const sides3 = getAlignmentSides(placement, rects, rtl2);
overflows.push(overflow[sides3[0]], overflow[sides3[1]]);
}
overflowsData = [...overflowsData, {
placement,
overflows
}];
if (!overflows.every((side2) => side2 <= 0)) {
var _middlewareData$flip2, _overflowsData$filter;
const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
const nextPlacement = placements2[nextIndex];
if (nextPlacement) {
const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false;
if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis
// overflows the main axis.
overflowsData.every((d3) => getSideAxis(d3.placement) === initialSideAxis ? d3.overflows[0] > 0 : true)) {
return {
data: {
index: nextIndex,
overflows: overflowsData
},
reset: {
placement: nextPlacement
}
};
}
}
let resetPlacement = (_overflowsData$filter = overflowsData.filter((d3) => d3.overflows[0] <= 0).sort((a3, b3) => a3.overflows[1] - b3.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
if (!resetPlacement) {
switch (fallbackStrategy) {
case "bestFit": {
var _overflowsData$filter2;
const placement2 = (_overflowsData$filter2 = overflowsData.filter((d3) => {
if (hasFallbackAxisSideDirection) {
const currentSideAxis = getSideAxis(d3.placement);
return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal
// reading directions favoring greater width.
currentSideAxis === "y";
}
return true;
}).map((d3) => [d3.placement, d3.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a3, b3) => a3[1] - b3[1])[0]) == null ? void 0 : _overflowsData$filter2[0];
if (placement2) {
resetPlacement = placement2;
}
break;
}
case "initialPlacement":
resetPlacement = initialPlacement;
break;
}
}
if (placement !== resetPlacement) {
return {
reset: {
placement: resetPlacement
}
};
}
}
return {};
}
};
};
var originSides = /* @__PURE__ */ new Set(["left", "top"]);
async function convertValueToCoords(state, options2) {
const {
placement,
platform: platform2,
elements: elements2
} = state;
const rtl2 = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements2.floating));
const side = getSide(placement);
const alignment = getAlignment(placement);
const isVertical = getSideAxis(placement) === "y";
const mainAxisMulti = originSides.has(side) ? -1 : 1;
const crossAxisMulti = rtl2 && isVertical ? -1 : 1;
const rawValue = evaluate(options2, state);
let {
mainAxis,
crossAxis,
alignmentAxis
} = typeof rawValue === "number" ? {
mainAxis: rawValue,
crossAxis: 0,
alignmentAxis: null
} : {
mainAxis: rawValue.mainAxis || 0,
crossAxis: rawValue.crossAxis || 0,
alignmentAxis: rawValue.alignmentAxis
};
if (alignment && typeof alignmentAxis === "number") {
crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
}
return isVertical ? {
x: crossAxis * crossAxisMulti,
y: mainAxis * mainAxisMulti
} : {
x: mainAxis * mainAxisMulti,
y: crossAxis * crossAxisMulti
};
}
var offset = function(options2) {
if (options2 === void 0) {
options2 = 0;
}
return {
name: "offset",
options: options2,
async fn(state) {
var _middlewareData$offse, _middlewareData$arrow;
const {
x: x2,
y: y3,
placement,
middlewareData
} = state;
const diffCoords = await convertValueToCoords(state, options2);
if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
return {};
}
return {
x: x2 + diffCoords.x,
y: y3 + diffCoords.y,
data: {
...diffCoords,
placement
}
};
}
};
};
var shift = function(options2) {
if (options2 === void 0) {
options2 = {};
}
return {
name: "shift",
options: options2,
async fn(state) {
const {
x: x2,
y: y3,
placement
} = state;
const {
mainAxis: checkMainAxis = true,
crossAxis: checkCrossAxis = false,
limiter = {
fn: (_ref11) => {
let {
x: x3,
y: y4
} = _ref11;
return {
x: x3,
y: y4
};
}
},
...detectOverflowOptions
} = evaluate(options2, state);
const coords = {
x: x2,
y: y3
};
const overflow = await detectOverflow(state, detectOverflowOptions);
const crossAxis = getSideAxis(getSide(placement));
const mainAxis = getOppositeAxis(crossAxis);
let mainAxisCoord = coords[mainAxis];
let crossAxisCoord = coords[crossAxis];
if (checkMainAxis) {
const minSide = mainAxis === "y" ? "top" : "left";
const maxSide = mainAxis === "y" ? "bottom" : "right";
const min3 = mainAxisCoord + overflow[minSide];
const max3 = mainAxisCoord - overflow[maxSide];
mainAxisCoord = clamp(min3, mainAxisCoord, max3);
}
if (checkCrossAxis) {
const minSide = crossAxis === "y" ? "top" : "left";
const maxSide = crossAxis === "y" ? "bottom" : "right";
const min3 = crossAxisCoord + overflow[minSide];
const max3 = crossAxisCoord - overflow[maxSide];
crossAxisCoord = clamp(min3, crossAxisCoord, max3);
}
const limitedCoords = limiter.fn({
...state,
[mainAxis]: mainAxisCoord,
[crossAxis]: crossAxisCoord
});
return {
...limitedCoords,
data: {
x: limitedCoords.x - x2,
y: limitedCoords.y - y3,
enabled: {
[mainAxis]: checkMainAxis,
[crossAxis]: checkCrossAxis
}
}
};
}
};
};
var limitShift = function(options2) {
if (options2 === void 0) {
options2 = {};
}
return {
options: options2,
fn(state) {
const {
x: x2,
y: y3,
placement,
rects,
middlewareData
} = state;
const {
offset: offset3 = 0,
mainAxis: checkMainAxis = true,
crossAxis: checkCrossAxis = true
} = evaluate(options2, state);
const coords = {
x: x2,
y: y3
};
const crossAxis = getSideAxis(placement);
const mainAxis = getOppositeAxis(crossAxis);
let mainAxisCoord = coords[mainAxis];
let crossAxisCoord = coords[crossAxis];
const rawOffset = evaluate(offset3, state);
const computedOffset = typeof rawOffset === "number" ? {
mainAxis: rawOffset,
crossAxis: 0
} : {
mainAxis: 0,
crossAxis: 0,
...rawOffset
};
if (checkMainAxis) {
const len = mainAxis === "y" ? "height" : "width";
const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;
const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;
if (mainAxisCoord < limitMin) {
mainAxisCoord = limitMin;
} else if (mainAxisCoord > limitMax) {
mainAxisCoord = limitMax;
}
}
if (checkCrossAxis) {
var _middlewareData$offse, _middlewareData$offse2;
const len = mainAxis === "y" ? "width" : "height";
const isOriginSide = originSides.has(getSide(placement));
const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);
const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);
if (crossAxisCoord < limitMin) {
crossAxisCoord = limitMin;
} else if (crossAxisCoord > limitMax) {
crossAxisCoord = limitMax;
}
}
return {
[mainAxis]: mainAxisCoord,
[crossAxis]: crossAxisCoord
};
}
};
};
var size = function(options2) {
if (options2 === void 0) {
options2 = {};
}
return {
name: "size",
options: options2,
async fn(state) {
var _state$middlewareData, _state$middlewareData2;
const {
placement,
rects,
platform: platform2,
elements: elements2
} = state;
const {
apply = () => {
},
...detectOverflowOptions
} = evaluate(options2, state);
const overflow = await detectOverflow(state, detectOverflowOptions);
const side = getSide(placement);
const alignment = getAlignment(placement);
const isYAxis = getSideAxis(placement) === "y";
const {
width,
height
} = rects.floating;
let heightSide;
let widthSide;
if (side === "top" || side === "bottom") {
heightSide = side;
widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements2.floating)) ? "start" : "end") ? "left" : "right";
} else {
widthSide = side;
heightSide = alignment === "end" ? "top" : "bottom";
}
const maximumClippingHeight = height - overflow.top - overflow.bottom;
const maximumClippingWidth = width - overflow.left - overflow.right;
const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);
const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);
const noShift = !state.middlewareData.shift;
let availableHeight = overflowAvailableHeight;
let availableWidth = overflowAvailableWidth;
if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {
availableWidth = maximumClippingWidth;
}
if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {
availableHeight = maximumClippingHeight;
}
if (noShift && !alignment) {
const xMin = max(overflow.left, 0);
const xMax = max(overflow.right, 0);
const yMin = max(overflow.top, 0);
const yMax = max(overflow.bottom, 0);
if (isYAxis) {
availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
} else {
availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
}
}
await apply({
...state,
availableWidth,
availableHeight
});
const nextDimensions = await platform2.getDimensions(elements2.floating);
if (width !== nextDimensions.width || height !== nextDimensions.height) {
return {
reset: {
rects: true
}
};
}
return {};
}
};
};
// node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
function hasWindow() {
return typeof window !== "undefined";
}
function getNodeName(node2) {
if (isNode(node2)) {
return (node2.nodeName || "").toLowerCase();
}
return "#document";
}
function getWindow2(node2) {
var _node$ownerDocument;
return (node2 == null || (_node$ownerDocument = node2.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
}
function getDocumentElement(node2) {
var _ref11;
return (_ref11 = (isNode(node2) ? node2.ownerDocument : node2.document) || window.document) == null ? void 0 : _ref11.documentElement;
}
function isNode(value) {
if (!hasWindow()) {
return false;
}
return value instanceof Node || value instanceof getWindow2(value).Node;
}
function isElement(value) {
if (!hasWindow()) {
return false;
}
return value instanceof Element || value instanceof getWindow2(value).Element;
}
function isHTMLElement(value) {
if (!hasWindow()) {
return false;
}
return value instanceof HTMLElement || value instanceof getWindow2(value).HTMLElement;
}
function isShadowRoot(value) {
if (!hasWindow() || typeof ShadowRoot === "undefined") {
return false;
}
return value instanceof ShadowRoot || value instanceof getWindow2(value).ShadowRoot;
}
var invalidOverflowDisplayValues = /* @__PURE__ */ new Set(["inline", "contents"]);
function isOverflowElement(element) {
const {
overflow,
overflowX,
overflowY,
display
} = getComputedStyle2(element);
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !invalidOverflowDisplayValues.has(display);
}
var tableElements = /* @__PURE__ */ new Set(["table", "td", "th"]);
function isTableElement(element) {
return tableElements.has(getNodeName(element));
}
var topLayerSelectors = [":popover-open", ":modal"];
function isTopLayer(element) {
return topLayerSelectors.some((selector2) => {
try {
return element.matches(selector2);
} catch (_e) {
return false;
}
});
}
var transformProperties = ["transform", "translate", "scale", "rotate", "perspective"];
var willChangeValues = ["transform", "translate", "scale", "rotate", "perspective", "filter"];
var containValues = ["paint", "layout", "strict", "content"];
function isContainingBlock(elementOrCss) {
const webkit = isWebKit();
const css3 = isElement(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss;
return transformProperties.some((value) => css3[value] ? css3[value] !== "none" : false) || (css3.containerType ? css3.containerType !== "normal" : false) || !webkit && (css3.backdropFilter ? css3.backdropFilter !== "none" : false) || !webkit && (css3.filter ? css3.filter !== "none" : false) || willChangeValues.some((value) => (css3.willChange || "").includes(value)) || containValues.some((value) => (css3.contain || "").includes(value));
}
function getContainingBlock(element) {
let currentNode = getParentNode(element);
while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
if (isContainingBlock(currentNode)) {
return currentNode;
} else if (isTopLayer(currentNode)) {
return null;
}
currentNode = getParentNode(currentNode);
}
return null;
}
function isWebKit() {
if (typeof CSS === "undefined" || !CSS.supports) return false;
return CSS.supports("-webkit-backdrop-filter", "none");
}
var lastTraversableNodeNames = /* @__PURE__ */ new Set(["html", "body", "#document"]);
function isLastTraversableNode(node2) {
return lastTraversableNodeNames.has(getNodeName(node2));
}
function getComputedStyle2(element) {
return getWindow2(element).getComputedStyle(element);
}
function getNodeScroll(element) {
if (isElement(element)) {
return {
scrollLeft: element.scrollLeft,
scrollTop: element.scrollTop
};
}
return {
scrollLeft: element.scrollX,
scrollTop: element.scrollY
};
}
function getParentNode(node2) {
if (getNodeName(node2) === "html") {
return node2;
}
const result = (
// Step into the shadow DOM of the parent of a slotted node.
node2.assignedSlot || // DOM Element detected.
node2.parentNode || // ShadowRoot detected.
isShadowRoot(node2) && node2.host || // Fallback.
getDocumentElement(node2)
);
return isShadowRoot(result) ? result.host : result;
}
function getNearestOverflowAncestor(node2) {
const parentNode = getParentNode(node2);
if (isLastTraversableNode(parentNode)) {
return node2.ownerDocument ? node2.ownerDocument.body : node2.body;
}
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
return parentNode;
}
return getNearestOverflowAncestor(parentNode);
}
function getOverflowAncestors(node2, list, traverseIframes) {
var _node$ownerDocument2;
if (list === void 0) {
list = [];
}
if (traverseIframes === void 0) {
traverseIframes = true;
}
const scrollableAncestor = getNearestOverflowAncestor(node2);
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node2.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
const win = getWindow2(scrollableAncestor);
if (isBody) {
const frameElement = getFrameElement(win);
return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []);
}
return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
}
function getFrameElement(win) {
return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
}
// node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
function getCssDimensions(element) {
const css3 = getComputedStyle2(element);
let width = parseFloat(css3.width) || 0;
let height = parseFloat(css3.height) || 0;
const hasOffset = isHTMLElement(element);
const offsetWidth = hasOffset ? element.offsetWidth : width;
const offsetHeight = hasOffset ? element.offsetHeight : height;
const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
if (shouldFallback) {
width = offsetWidth;
height = offsetHeight;
}
return {
width,
height,
$: shouldFallback
};
}
function unwrapElement(element) {
return !isElement(element) ? element.contextElement : element;
}
function getScale(element) {
const domElement = unwrapElement(element);
if (!isHTMLElement(domElement)) {
return createCoords(1);
}
const rect = domElement.getBoundingClientRect();
const {
width,
height,
$: $3
} = getCssDimensions(domElement);
let x2 = ($3 ? round(rect.width) : rect.width) / width;
let y3 = ($3 ? round(rect.height) : rect.height) / height;
if (!x2 || !Number.isFinite(x2)) {
x2 = 1;
}
if (!y3 || !Number.isFinite(y3)) {
y3 = 1;
}
return {
x: x2,
y: y3
};
}
var noOffsets = /* @__PURE__ */ createCoords(0);
function getVisualOffsets(element) {
const win = getWindow2(element);
if (!isWebKit() || !win.visualViewport) {
return noOffsets;
}
return {
x: win.visualViewport.offsetLeft,
y: win.visualViewport.offsetTop
};
}
function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
if (isFixed === void 0) {
isFixed = false;
}
if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow2(element)) {
return false;
}
return isFixed;
}
function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
if (includeScale === void 0) {
includeScale = false;
}
if (isFixedStrategy === void 0) {
isFixedStrategy = false;
}
const clientRect = element.getBoundingClientRect();
const domElement = unwrapElement(element);
let scale2 = createCoords(1);
if (includeScale) {
if (offsetParent) {
if (isElement(offsetParent)) {
scale2 = getScale(offsetParent);
}
} else {
scale2 = getScale(element);
}
}
const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
let x2 = (clientRect.left + visualOffsets.x) / scale2.x;
let y3 = (clientRect.top + visualOffsets.y) / scale2.y;
let width = clientRect.width / scale2.x;
let height = clientRect.height / scale2.y;
if (domElement) {
const win = getWindow2(domElement);
const offsetWin = offsetParent && isElement(offsetParent) ? getWindow2(offsetParent) : offsetParent;
let currentWin = win;
let currentIFrame = getFrameElement(currentWin);
while (currentIFrame && offsetParent && offsetWin !== currentWin) {
const iframeScale = getScale(currentIFrame);
const iframeRect = currentIFrame.getBoundingClientRect();
const css3 = getComputedStyle2(currentIFrame);
const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css3.paddingLeft)) * iframeScale.x;
const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css3.paddingTop)) * iframeScale.y;
x2 *= iframeScale.x;
y3 *= iframeScale.y;
width *= iframeScale.x;
height *= iframeScale.y;
x2 += left;
y3 += top;
currentWin = getWindow2(currentIFrame);
currentIFrame = getFrameElement(currentWin);
}
}
return rectToClientRect({
width,
height,
x: x2,
y: y3
});
}
function getWindowScrollBarX(element, rect) {
const leftScroll = getNodeScroll(element).scrollLeft;
if (!rect) {
return getBoundingClientRect(getDocumentElement(element)).left + leftScroll;
}
return rect.left + leftScroll;
}
function getHTMLOffset(documentElement, scroll) {
const htmlRect = documentElement.getBoundingClientRect();
const x2 = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect);
const y3 = htmlRect.top + scroll.scrollTop;
return {
x: x2,
y: y3
};
}
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref11) {
let {
elements: elements2,
rect,
offsetParent,
strategy
} = _ref11;
const isFixed = strategy === "fixed";
const documentElement = getDocumentElement(offsetParent);
const topLayer = elements2 ? isTopLayer(elements2.floating) : false;
if (offsetParent === documentElement || topLayer && isFixed) {
return rect;
}
let scroll = {
scrollLeft: 0,
scrollTop: 0
};
let scale2 = createCoords(1);
const offsets = createCoords(0);
const isOffsetParentAnElement = isHTMLElement(offsetParent);
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
scroll = getNodeScroll(offsetParent);
}
if (isHTMLElement(offsetParent)) {
const offsetRect = getBoundingClientRect(offsetParent);
scale2 = getScale(offsetParent);
offsets.x = offsetRect.x + offsetParent.clientLeft;
offsets.y = offsetRect.y + offsetParent.clientTop;
}
}
const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
return {
width: rect.width * scale2.x,
height: rect.height * scale2.y,
x: rect.x * scale2.x - scroll.scrollLeft * scale2.x + offsets.x + htmlOffset.x,
y: rect.y * scale2.y - scroll.scrollTop * scale2.y + offsets.y + htmlOffset.y
};
}
function getClientRects(element) {
return Array.from(element.getClientRects());
}
function getDocumentRect(element) {
const html = getDocumentElement(element);
const scroll = getNodeScroll(element);
const body = element.ownerDocument.body;
const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
let x2 = -scroll.scrollLeft + getWindowScrollBarX(element);
const y3 = -scroll.scrollTop;
if (getComputedStyle2(body).direction === "rtl") {
x2 += max(html.clientWidth, body.clientWidth) - width;
}
return {
width,
height,
x: x2,
y: y3
};
}
var SCROLLBAR_MAX = 25;
function getViewportRect(element, strategy) {
const win = getWindow2(element);
const html = getDocumentElement(element);
const visualViewport = win.visualViewport;
let width = html.clientWidth;
let height = html.clientHeight;
let x2 = 0;
let y3 = 0;
if (visualViewport) {
width = visualViewport.width;
height = visualViewport.height;
const visualViewportBased = isWebKit();
if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
x2 = visualViewport.offsetLeft;
y3 = visualViewport.offsetTop;
}
}
const windowScrollbarX = getWindowScrollBarX(html);
if (windowScrollbarX <= 0) {
const doc = html.ownerDocument;
const body = doc.body;
const bodyStyles = getComputedStyle(body);
const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0;
const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline);
if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) {
width -= clippingStableScrollbarWidth;
}
} else if (windowScrollbarX <= SCROLLBAR_MAX) {
width += windowScrollbarX;
}
return {
width,
height,
x: x2,
y: y3
};
}
var absoluteOrFixed = /* @__PURE__ */ new Set(["absolute", "fixed"]);
function getInnerBoundingClientRect(element, strategy) {
const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
const top = clientRect.top + element.clientTop;
const left = clientRect.left + element.clientLeft;
const scale2 = isHTMLElement(element) ? getScale(element) : createCoords(1);
const width = element.clientWidth * scale2.x;
const height = element.clientHeight * scale2.y;
const x2 = left * scale2.x;
const y3 = top * scale2.y;
return {
width,
height,
x: x2,
y: y3
};
}
function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
let rect;
if (clippingAncestor === "viewport") {
rect = getViewportRect(element, strategy);
} else if (clippingAncestor === "document") {
rect = getDocumentRect(getDocumentElement(element));
} else if (isElement(clippingAncestor)) {
rect = getInnerBoundingClientRect(clippingAncestor, strategy);
} else {
const visualOffsets = getVisualOffsets(element);
rect = {
x: clippingAncestor.x - visualOffsets.x,
y: clippingAncestor.y - visualOffsets.y,
width: clippingAncestor.width,
height: clippingAncestor.height
};
}
return rectToClientRect(rect);
}
function hasFixedPositionAncestor(element, stopNode) {
const parentNode = getParentNode(element);
if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
return false;
}
return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
}
function getClippingElementAncestors(element, cache2) {
const cachedResult = cache2.get(element);
if (cachedResult) {
return cachedResult;
}
let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
let currentContainingBlockComputedStyle = null;
const elementIsFixed = getComputedStyle2(element).position === "fixed";
let currentNode = elementIsFixed ? getParentNode(element) : element;
while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
const computedStyle = getComputedStyle2(currentNode);
const currentNodeIsContaining = isContainingBlock(currentNode);
if (!currentNodeIsContaining && computedStyle.position === "fixed") {
currentContainingBlockComputedStyle = null;
}
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && absoluteOrFixed.has(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
if (shouldDropCurrentNode) {
result = result.filter((ancestor) => ancestor !== currentNode);
} else {
currentContainingBlockComputedStyle = computedStyle;
}
currentNode = getParentNode(currentNode);
}
cache2.set(element, result);
return result;
}
function getClippingRect(_ref11) {
let {
element,
boundary,
rootBoundary,
strategy
} = _ref11;
const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary);
const clippingAncestors = [...elementClippingAncestors, rootBoundary];
const firstClippingAncestor = clippingAncestors[0];
const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
accRect.top = max(rect.top, accRect.top);
accRect.right = min(rect.right, accRect.right);
accRect.bottom = min(rect.bottom, accRect.bottom);
accRect.left = max(rect.left, accRect.left);
return accRect;
}, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
return {
width: clippingRect.right - clippingRect.left,
height: clippingRect.bottom - clippingRect.top,
x: clippingRect.left,
y: clippingRect.top
};
}
function getDimensions(element) {
const {
width,
height
} = getCssDimensions(element);
return {
width,
height
};
}
function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
const isOffsetParentAnElement = isHTMLElement(offsetParent);
const documentElement = getDocumentElement(offsetParent);
const isFixed = strategy === "fixed";
const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
let scroll = {
scrollLeft: 0,
scrollTop: 0
};
const offsets = createCoords(0);
function setLeftRTLScrollbarOffset() {
offsets.x = getWindowScrollBarX(documentElement);
}
if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
scroll = getNodeScroll(offsetParent);
}
if (isOffsetParentAnElement) {
const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
offsets.x = offsetRect.x + offsetParent.clientLeft;
offsets.y = offsetRect.y + offsetParent.clientTop;
} else if (documentElement) {
setLeftRTLScrollbarOffset();
}
}
if (isFixed && !isOffsetParentAnElement && documentElement) {
setLeftRTLScrollbarOffset();
}
const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
const x2 = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
const y3 = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
return {
x: x2,
y: y3,
width: rect.width,
height: rect.height
};
}
function isStaticPositioned(element) {
return getComputedStyle2(element).position === "static";
}
function getTrueOffsetParent(element, polyfill) {
if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") {
return null;
}
if (polyfill) {
return polyfill(element);
}
let rawOffsetParent = element.offsetParent;
if (getDocumentElement(element) === rawOffsetParent) {
rawOffsetParent = rawOffsetParent.ownerDocument.body;
}
return rawOffsetParent;
}
function getOffsetParent(element, polyfill) {
const win = getWindow2(element);
if (isTopLayer(element)) {
return win;
}
if (!isHTMLElement(element)) {
let svgOffsetParent = getParentNode(element);
while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) {
if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) {
return svgOffsetParent;
}
svgOffsetParent = getParentNode(svgOffsetParent);
}
return win;
}
let offsetParent = getTrueOffsetParent(element, polyfill);
while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) {
offsetParent = getTrueOffsetParent(offsetParent, polyfill);
}
if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) {
return win;
}
return offsetParent || getContainingBlock(element) || win;
}
var getElementRects = async function(data) {
const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
const getDimensionsFn = this.getDimensions;
const floatingDimensions = await getDimensionsFn(data.floating);
return {
reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
floating: {
x: 0,
y: 0,
width: floatingDimensions.width,
height: floatingDimensions.height
}
};
};
function isRTL(element) {
return getComputedStyle2(element).direction === "rtl";
}
var platform = {
convertOffsetParentRelativeRectToViewportRelativeRect,
getDocumentElement,
getClippingRect,
getOffsetParent,
getElementRects,
getClientRects,
getDimensions,
getScale,
isElement,
isRTL
};
function rectsAreEqual(a3, b3) {
return a3.x === b3.x && a3.y === b3.y && a3.width === b3.width && a3.height === b3.height;
}
function observeMove(element, onMove) {
let io = null;
let timeoutId;
const root = getDocumentElement(element);
function cleanup() {
var _io;
clearTimeout(timeoutId);
(_io = io) == null || _io.disconnect();
io = null;
}
function refresh(skip, threshold) {
if (skip === void 0) {
skip = false;
}
if (threshold === void 0) {
threshold = 1;
}
cleanup();
const elementRectForRootMargin = element.getBoundingClientRect();
const {
left,
top,
width,
height
} = elementRectForRootMargin;
if (!skip) {
onMove();
}
if (!width || !height) {
return;
}
const insetTop = floor(top);
const insetRight = floor(root.clientWidth - (left + width));
const insetBottom = floor(root.clientHeight - (top + height));
const insetLeft = floor(left);
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
const options2 = {
rootMargin,
threshold: max(0, min(1, threshold)) || 1
};
let isFirstUpdate = true;
function handleObserve(entries) {
const ratio = entries[0].intersectionRatio;
if (ratio !== threshold) {
if (!isFirstUpdate) {
return refresh();
}
if (!ratio) {
timeoutId = setTimeout(() => {
refresh(false, 1e-7);
}, 1e3);
} else {
refresh(false, ratio);
}
}
if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) {
refresh();
}
isFirstUpdate = false;
}
try {
io = new IntersectionObserver(handleObserve, {
...options2,
// Handle