Preview: components.js
Size: 3.83 MB
//proc/self/root/home/nshryvcy/radiantskinclinics.org/wp-includes/js/dist/components.js
"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();
<SelectProvider store={store} defaultValue="Apple" />
^ ^
Instead, pass the default state to the topmost store:
const store = useSelectStore({ defaultValue: "Apple" });
<SelectProvider store={store} />
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 <iframe>s
root: root.ownerDocument
});
} catch (_e) {
io = new IntersectionObserver(handleObserve, options2);
}
io.observe(element);
}
refresh(true);
return cleanup;
}
function autoUpdate(reference, floating, update, options2) {
if (options2 === void 0) {
options2 = {};
}
const {
ancestorScroll = true,
ancestorResize = true,
elementResize = typeof ResizeObserver === "function",
layoutShift = typeof IntersectionObserver === "function",
animationFrame = false
} = options2;
const referenceEl = unwrapElement(reference);
const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
ancestors.forEach((ancestor) => {
ancestorScroll && ancestor.addEventListener("scroll", update, {
passive: true
});
ancestorResize && ancestor.addEventListener("resize", update);
});
const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
let reobserveFrame = -1;
let resizeObserver = null;
if (elementResize) {
resizeObserver = new ResizeObserver((_ref11) => {
let [firstEntry] = _ref11;
if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
resizeObserver.unobserve(floating);
cancelAnimationFrame(reobserveFrame);
reobserveFrame = requestAnimationFrame(() => {
var _resizeObserver;
(_resizeObserver = resizeObserver) == null || _resizeObserver.observe(floating);
});
}
update();
});
if (referenceEl && !animationFrame) {
resizeObserver.observe(referenceEl);
}
resizeObserver.observe(floating);
}
let frameId;
let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
if (animationFrame) {
frameLoop();
}
function frameLoop() {
const nextRefRect = getBoundingClientRect(reference);
if (prevRefRect && !rectsAreEqual(prevRefRect, nextRefRect)) {
update();
}
prevRefRect = nextRefRect;
frameId = requestAnimationFrame(frameLoop);
}
update();
return () => {
var _resizeObserver2;
ancestors.forEach((ancestor) => {
ancestorScroll && ancestor.removeEventListener("scroll", update);
ancestorResize && ancestor.removeEventListener("resize", update);
});
cleanupIo == null || cleanupIo();
(_resizeObserver2 = resizeObserver) == null || _resizeObserver2.disconnect();
resizeObserver = null;
if (animationFrame) {
cancelAnimationFrame(frameId);
}
};
}
var offset2 = offset;
var shift2 = shift;
var flip2 = flip;
var size2 = size;
var arrow2 = arrow;
var limitShift2 = limitShift;
var computePosition2 = (reference, floating, options2) => {
const cache2 = /* @__PURE__ */ new Map();
const mergedOptions = {
platform,
...options2
};
const platformWithCache = {
...mergedOptions.platform,
_c: cache2
};
return computePosition(reference, floating, {
...mergedOptions,
platform: platformWithCache
});
};
// node_modules/@ariakit/react-core/esm/__chunks/KW7Z5AIL.js
var import_react28 = __toESM(require_react(), 1);
var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1);
var TagName20 = "div";
function createDOMRect(x2 = 0, y3 = 0, width = 0, height = 0) {
if (typeof DOMRect === "function") {
return new DOMRect(x2, y3, width, height);
}
const rect = {
x: x2,
y: y3,
width,
height,
top: y3,
right: x2 + width,
bottom: y3 + height,
left: x2
};
return { ...rect, toJSON: () => rect };
}
function getDOMRect(anchorRect) {
if (!anchorRect) return createDOMRect();
const { x: x2, y: y3, width, height } = anchorRect;
return createDOMRect(x2, y3, width, height);
}
function getAnchorElement(anchorElement, getAnchorRect) {
const contextElement = anchorElement || void 0;
return {
contextElement,
getBoundingClientRect: () => {
const anchor = anchorElement;
const anchorRect = getAnchorRect == null ? void 0 : getAnchorRect(anchor);
if (anchorRect || !anchor) {
return getDOMRect(anchorRect);
}
return anchor.getBoundingClientRect();
}
};
}
function isValidPlacement(flip22) {
return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(flip22);
}
function roundByDPR(value) {
const dpr = window.devicePixelRatio || 1;
return Math.round(value * dpr) / dpr;
}
function getOffsetMiddleware(arrowElement, props) {
return offset2(({ placement }) => {
var _a;
const arrowOffset = ((arrowElement == null ? void 0 : arrowElement.clientHeight) || 0) / 2;
const finalGutter = typeof props.gutter === "number" ? props.gutter + arrowOffset : (_a = props.gutter) != null ? _a : arrowOffset;
const hasAlignment = !!placement.split("-")[1];
return {
crossAxis: !hasAlignment ? props.shift : void 0,
mainAxis: finalGutter,
alignmentAxis: props.shift
};
});
}
function getFlipMiddleware(props) {
if (props.flip === false) return;
const fallbackPlacements = typeof props.flip === "string" ? props.flip.split(" ") : void 0;
invariant(
!fallbackPlacements || fallbackPlacements.every(isValidPlacement),
"`flip` expects a spaced-delimited list of placements"
);
return flip2({
padding: props.overflowPadding,
fallbackPlacements
});
}
function getShiftMiddleware(props) {
if (!props.slide && !props.overlap) return;
return shift2({
mainAxis: props.slide,
crossAxis: props.overlap,
padding: props.overflowPadding,
limiter: limitShift2()
});
}
function getSizeMiddleware(props) {
return size2({
padding: props.overflowPadding,
apply({ elements: elements2, availableWidth, availableHeight, rects }) {
const wrapper3 = elements2.floating;
const referenceWidth = Math.round(rects.reference.width);
availableWidth = Math.floor(availableWidth);
availableHeight = Math.floor(availableHeight);
wrapper3.style.setProperty(
"--popover-anchor-width",
`${referenceWidth}px`
);
wrapper3.style.setProperty(
"--popover-available-width",
`${availableWidth}px`
);
wrapper3.style.setProperty(
"--popover-available-height",
`${availableHeight}px`
);
if (props.sameWidth) {
wrapper3.style.width = `${referenceWidth}px`;
}
if (props.fitViewport) {
wrapper3.style.maxWidth = `${availableWidth}px`;
wrapper3.style.maxHeight = `${availableHeight}px`;
}
}
});
}
function getArrowMiddleware(arrowElement, props) {
if (!arrowElement) return;
return arrow2({
element: arrowElement,
padding: props.arrowPadding
});
}
var usePopover = createHook(
function usePopover2({
store,
modal = false,
portal = !!modal,
preserveTabOrder = true,
autoFocusOnShow = true,
wrapperProps,
fixed = false,
flip: flip22 = true,
shift: shift22 = 0,
slide = true,
overlap = false,
sameWidth = false,
fitViewport = false,
gutter,
arrowPadding = 4,
overflowPadding = 8,
getAnchorRect,
updatePosition,
...props
}) {
const context = usePopoverProviderContext();
store = store || context;
invariant(
store,
"Popover must receive a `store` prop or be wrapped in a PopoverProvider component."
);
const arrowElement = store.useState("arrowElement");
const anchorElement = store.useState("anchorElement");
const disclosureElement = store.useState("disclosureElement");
const popoverElement = store.useState("popoverElement");
const contentElement = store.useState("contentElement");
const placement = store.useState("placement");
const mounted = store.useState("mounted");
const rendered = store.useState("rendered");
const defaultArrowElementRef = (0, import_react28.useRef)(null);
const [positioned, setPositioned] = (0, import_react28.useState)(false);
const { portalRef, domReady } = usePortalRef(portal, props.portalRef);
const getAnchorRectProp = useEvent(getAnchorRect);
const updatePositionProp = useEvent(updatePosition);
const hasCustomUpdatePosition = !!updatePosition;
useSafeLayoutEffect(() => {
if (!(popoverElement == null ? void 0 : popoverElement.isConnected)) return;
popoverElement.style.setProperty(
"--popover-overflow-padding",
`${overflowPadding}px`
);
const anchor = getAnchorElement(anchorElement, getAnchorRectProp);
const updatePosition2 = async () => {
if (!mounted) return;
if (!arrowElement) {
defaultArrowElementRef.current = defaultArrowElementRef.current || document.createElement("div");
}
const arrow22 = arrowElement || defaultArrowElementRef.current;
const middleware2 = [
getOffsetMiddleware(arrow22, { gutter, shift: shift22 }),
getFlipMiddleware({ flip: flip22, overflowPadding }),
getShiftMiddleware({ slide, shift: shift22, overlap, overflowPadding }),
getArrowMiddleware(arrow22, { arrowPadding }),
getSizeMiddleware({
sameWidth,
fitViewport,
overflowPadding
})
];
const pos = await computePosition2(anchor, popoverElement, {
placement,
strategy: fixed ? "fixed" : "absolute",
middleware: middleware2
});
store == null ? void 0 : store.setState("currentPlacement", pos.placement);
setPositioned(true);
const x2 = roundByDPR(pos.x);
const y3 = roundByDPR(pos.y);
Object.assign(popoverElement.style, {
top: "0",
left: "0",
transform: `translate3d(${x2}px,${y3}px,0)`
});
if (arrow22 && pos.middlewareData.arrow) {
const { x: arrowX, y: arrowY } = pos.middlewareData.arrow;
const side = pos.placement.split("-")[0];
const centerX = arrow22.clientWidth / 2;
const centerY = arrow22.clientHeight / 2;
const originX = arrowX != null ? arrowX + centerX : -centerX;
const originY = arrowY != null ? arrowY + centerY : -centerY;
popoverElement.style.setProperty(
"--popover-transform-origin",
{
top: `${originX}px calc(100% + ${centerY}px)`,
bottom: `${originX}px ${-centerY}px`,
left: `calc(100% + ${centerX}px) ${originY}px`,
right: `${-centerX}px ${originY}px`
}[side]
);
Object.assign(arrow22.style, {
left: arrowX != null ? `${arrowX}px` : "",
top: arrowY != null ? `${arrowY}px` : "",
[side]: "100%"
});
}
};
const update = async () => {
if (hasCustomUpdatePosition) {
await updatePositionProp({ updatePosition: updatePosition2 });
setPositioned(true);
} else {
await updatePosition2();
}
};
const cancelAutoUpdate = autoUpdate(anchor, popoverElement, update, {
// JSDOM doesn't support ResizeObserver
elementResize: typeof ResizeObserver === "function"
});
return () => {
setPositioned(false);
cancelAutoUpdate();
};
}, [
store,
rendered,
popoverElement,
arrowElement,
anchorElement,
popoverElement,
placement,
mounted,
domReady,
fixed,
flip22,
shift22,
slide,
overlap,
sameWidth,
fitViewport,
gutter,
arrowPadding,
overflowPadding,
getAnchorRectProp,
hasCustomUpdatePosition,
updatePositionProp
]);
useSafeLayoutEffect(() => {
if (!mounted) return;
if (!domReady) return;
if (!(popoverElement == null ? void 0 : popoverElement.isConnected)) return;
if (!(contentElement == null ? void 0 : contentElement.isConnected)) return;
const applyZIndex = () => {
popoverElement.style.zIndex = getComputedStyle(contentElement).zIndex;
};
applyZIndex();
let raf = requestAnimationFrame(() => {
raf = requestAnimationFrame(applyZIndex);
});
return () => cancelAnimationFrame(raf);
}, [mounted, domReady, popoverElement, contentElement]);
const position2 = fixed ? "fixed" : "absolute";
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
"div",
{
...wrapperProps,
style: {
// https://floating-ui.com/docs/computeposition#initial-layout
position: position2,
top: 0,
left: 0,
width: "max-content",
...wrapperProps == null ? void 0 : wrapperProps.style
},
ref: store == null ? void 0 : store.setPopoverElement,
children: element
}
),
[store, position2, wrapperProps]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(PopoverScopedContextProvider, { value: store, children: element }),
[store]
);
props = {
// data-placing is not part of the public API. We're setting this here so
// we can wait for the popover to be positioned before other components
// move focus into it. For example, this attribute is observed by the
// Combobox component with the autoSelect behavior.
"data-placing": !positioned || void 0,
...props,
style: {
position: "relative",
...props.style
}
};
props = useDialog({
store,
modal,
portal,
preserveTabOrder,
preserveTabOrderAnchor: disclosureElement || anchorElement,
autoFocusOnShow: positioned && autoFocusOnShow,
...props,
portalRef
});
return props;
}
);
var Popover = createDialogComponent(
forwardRef2(function Popover2(props) {
const htmlProps = usePopover(props);
return createElement(TagName20, htmlProps);
}),
usePopoverProviderContext
);
// node_modules/@ariakit/react-core/esm/__chunks/4HTVKX2Y.js
var import_react29 = __toESM(require_react(), 1);
var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1);
var TagName21 = "div";
function isMovingOnHovercard(target, card, anchor, nested) {
if (hasFocusWithin(card)) return true;
if (!target) return false;
if (contains(card, target)) return true;
if (anchor && contains(anchor, target)) return true;
if (nested == null ? void 0 : nested.some((card2) => isMovingOnHovercard(target, card2, anchor))) {
return true;
}
return false;
}
function useAutoFocusOnHide({
store,
...props
}) {
const [autoFocusOnHide, setAutoFocusOnHide] = (0, import_react29.useState)(false);
const mounted = store.useState("mounted");
(0, import_react29.useEffect)(() => {
if (!mounted) {
setAutoFocusOnHide(false);
}
}, [mounted]);
const onFocusProp = props.onFocus;
const onFocus = useEvent((event) => {
onFocusProp == null ? void 0 : onFocusProp(event);
if (event.defaultPrevented) return;
setAutoFocusOnHide(true);
});
const finalFocusRef = (0, import_react29.useRef)(null);
(0, import_react29.useEffect)(() => {
return sync(store, ["anchorElement"], (state) => {
finalFocusRef.current = state.anchorElement;
});
}, []);
props = {
autoFocusOnHide,
finalFocus: finalFocusRef,
...props,
onFocus
};
return props;
}
var NestedHovercardContext = (0, import_react29.createContext)(null);
var useHovercard = createHook(
function useHovercard2({
store,
modal = false,
portal = !!modal,
hideOnEscape = true,
hideOnHoverOutside = true,
disablePointerEventsOnApproach = !!hideOnHoverOutside,
...props
}) {
const context = useHovercardProviderContext();
store = store || context;
invariant(
store,
"Hovercard must receive a `store` prop or be wrapped in a HovercardProvider component."
);
const ref = (0, import_react29.useRef)(null);
const [nestedHovercards, setNestedHovercards] = (0, import_react29.useState)([]);
const hideTimeoutRef = (0, import_react29.useRef)(0);
const enterPointRef = (0, import_react29.useRef)(null);
const { portalRef, domReady } = usePortalRef(portal, props.portalRef);
const isMouseMoving = useIsMouseMoving();
const mayHideOnHoverOutside = !!hideOnHoverOutside;
const hideOnHoverOutsideProp = useBooleanEvent(hideOnHoverOutside);
const mayDisablePointerEvents = !!disablePointerEventsOnApproach;
const disablePointerEventsProp = useBooleanEvent(
disablePointerEventsOnApproach
);
const open = store.useState("open");
const mounted = store.useState("mounted");
(0, import_react29.useEffect)(() => {
if (!domReady) return;
if (!mounted) return;
if (!mayHideOnHoverOutside && !mayDisablePointerEvents) return;
const element = ref.current;
if (!element) return;
const onMouseMove = (event) => {
if (!store) return;
if (!isMouseMoving()) return;
const { anchorElement, hideTimeout, timeout } = store.getState();
const enterPoint = enterPointRef.current;
const [target] = event.composedPath();
const anchor = anchorElement;
if (isMovingOnHovercard(target, element, anchor, nestedHovercards)) {
enterPointRef.current = target && anchor && contains(anchor, target) ? getEventPoint(event) : null;
window.clearTimeout(hideTimeoutRef.current);
hideTimeoutRef.current = 0;
return;
}
if (hideTimeoutRef.current) return;
if (enterPoint) {
const currentPoint = getEventPoint(event);
const polygon = getElementPolygon(element, enterPoint);
if (isPointInPolygon(currentPoint, polygon)) {
enterPointRef.current = currentPoint;
if (!disablePointerEventsProp(event)) return;
event.preventDefault();
event.stopPropagation();
return;
}
}
if (!hideOnHoverOutsideProp(event)) return;
hideTimeoutRef.current = window.setTimeout(() => {
hideTimeoutRef.current = 0;
store == null ? void 0 : store.hide();
}, hideTimeout != null ? hideTimeout : timeout);
};
return chain(
addGlobalEventListener("mousemove", onMouseMove, true),
() => clearTimeout(hideTimeoutRef.current)
);
}, [
store,
isMouseMoving,
domReady,
mounted,
mayHideOnHoverOutside,
mayDisablePointerEvents,
nestedHovercards,
disablePointerEventsProp,
hideOnHoverOutsideProp
]);
(0, import_react29.useEffect)(() => {
if (!domReady) return;
if (!mounted) return;
if (!mayDisablePointerEvents) return;
const disableEvent = (event) => {
const element = ref.current;
if (!element) return;
const enterPoint = enterPointRef.current;
if (!enterPoint) return;
const polygon = getElementPolygon(element, enterPoint);
if (isPointInPolygon(getEventPoint(event), polygon)) {
if (!disablePointerEventsProp(event)) return;
event.preventDefault();
event.stopPropagation();
}
};
return chain(
// Note: we may need to add pointer events here in the future.
addGlobalEventListener("mouseenter", disableEvent, true),
addGlobalEventListener("mouseover", disableEvent, true),
addGlobalEventListener("mouseout", disableEvent, true),
addGlobalEventListener("mouseleave", disableEvent, true)
);
}, [domReady, mounted, mayDisablePointerEvents, disablePointerEventsProp]);
(0, import_react29.useEffect)(() => {
if (!domReady) return;
if (open) return;
store == null ? void 0 : store.setAutoFocusOnShow(false);
}, [store, domReady, open]);
const openRef = useLiveRef(open);
(0, import_react29.useEffect)(() => {
if (!domReady) return;
return () => {
if (!openRef.current) {
store == null ? void 0 : store.setAutoFocusOnShow(false);
}
};
}, [store, domReady]);
const registerOnParent = (0, import_react29.useContext)(NestedHovercardContext);
useSafeLayoutEffect(() => {
if (modal) return;
if (!portal) return;
if (!mounted) return;
if (!domReady) return;
const element = ref.current;
if (!element) return;
return registerOnParent == null ? void 0 : registerOnParent(element);
}, [modal, portal, mounted, domReady]);
const registerNestedHovercard = (0, import_react29.useCallback)(
(element) => {
setNestedHovercards((prevElements) => [...prevElements, element]);
const parentUnregister = registerOnParent == null ? void 0 : registerOnParent(element);
return () => {
setNestedHovercards(
(prevElements) => prevElements.filter((item2) => item2 !== element)
);
parentUnregister == null ? void 0 : parentUnregister();
};
},
[registerOnParent]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(HovercardScopedContextProvider, { value: store, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(NestedHovercardContext.Provider, { value: registerNestedHovercard, children: element }) }),
[store, registerNestedHovercard]
);
props = {
...props,
ref: useMergeRefs(ref, props.ref)
};
props = useAutoFocusOnHide({ store, ...props });
const autoFocusOnShow = store.useState(
(state) => modal || state.autoFocusOnShow
);
props = usePopover({
store,
modal,
portal,
autoFocusOnShow,
...props,
portalRef,
hideOnEscape(event) {
if (isFalsyBooleanCallback(hideOnEscape, event)) return false;
requestAnimationFrame(() => {
requestAnimationFrame(() => {
store == null ? void 0 : store.hide();
});
});
return true;
}
});
return props;
}
);
var Hovercard = createDialogComponent(
forwardRef2(function Hovercard2(props) {
const htmlProps = useHovercard(props);
return createElement(TagName21, htmlProps);
}),
useHovercardProviderContext
);
// node_modules/@ariakit/react-core/esm/tooltip/tooltip.js
var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1);
var TagName22 = "div";
var useTooltip = createHook(
function useTooltip2({
store,
portal = true,
gutter = 8,
preserveTabOrder = false,
hideOnHoverOutside = true,
hideOnInteractOutside = true,
...props
}) {
const context = useTooltipProviderContext();
store = store || context;
invariant(
store,
"Tooltip must receive a `store` prop or be wrapped in a TooltipProvider component."
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(TooltipScopedContextProvider, { value: store, children: element }),
[store]
);
const role = store.useState(
(state) => state.type === "description" ? "tooltip" : "none"
);
props = { role, ...props };
props = useHovercard({
...props,
store,
portal,
gutter,
preserveTabOrder,
hideOnHoverOutside(event) {
if (isFalsyBooleanCallback(hideOnHoverOutside, event)) return false;
const anchorElement = store == null ? void 0 : store.getState().anchorElement;
if (!anchorElement) return true;
if ("focusVisible" in anchorElement.dataset) return false;
return true;
},
hideOnInteractOutside: (event) => {
if (isFalsyBooleanCallback(hideOnInteractOutside, event)) return false;
const anchorElement = store == null ? void 0 : store.getState().anchorElement;
if (!anchorElement) return true;
if (contains(anchorElement, event.target)) return false;
return true;
}
});
return props;
}
);
var Tooltip = createDialogComponent(
forwardRef2(function Tooltip2(props) {
const htmlProps = useTooltip(props);
return createElement(TagName22, htmlProps);
}),
useTooltipProviderContext
);
// node_modules/@ariakit/react-core/esm/__chunks/2XVFVSLB.js
var import_react30 = __toESM(require_react(), 1);
var TagName23 = "a";
var useHovercardAnchor = createHook(
function useHovercardAnchor2({ store, showOnHover = true, ...props }) {
const context = useHovercardProviderContext();
store = store || context;
invariant(
store,
"HovercardAnchor must receive a `store` prop or be wrapped in a HovercardProvider component."
);
const disabled = disabledFromProps(props);
const showTimeoutRef = (0, import_react30.useRef)(0);
(0, import_react30.useEffect)(() => () => window.clearTimeout(showTimeoutRef.current), []);
(0, import_react30.useEffect)(() => {
const onMouseLeave = (event) => {
if (!store) return;
const { anchorElement } = store.getState();
if (!anchorElement) return;
if (event.target !== anchorElement) return;
window.clearTimeout(showTimeoutRef.current);
showTimeoutRef.current = 0;
};
return addGlobalEventListener("mouseleave", onMouseLeave, true);
}, [store]);
const onMouseMoveProp = props.onMouseMove;
const showOnHoverProp = useBooleanEvent(showOnHover);
const isMouseMoving = useIsMouseMoving();
const onMouseMove = useEvent((event) => {
onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);
if (disabled) return;
if (!store) return;
if (event.defaultPrevented) return;
if (showTimeoutRef.current) return;
if (!isMouseMoving()) return;
if (!showOnHoverProp(event)) return;
const element = event.currentTarget;
store.setAnchorElement(element);
store.setDisclosureElement(element);
const { showTimeout, timeout } = store.getState();
const showHovercard = () => {
showTimeoutRef.current = 0;
if (!isMouseMoving()) return;
store == null ? void 0 : store.setAnchorElement(element);
store == null ? void 0 : store.show();
queueMicrotask(() => {
store == null ? void 0 : store.setDisclosureElement(element);
});
};
const timeoutMs = showTimeout != null ? showTimeout : timeout;
if (timeoutMs === 0) {
showHovercard();
} else {
showTimeoutRef.current = window.setTimeout(showHovercard, timeoutMs);
}
});
const onClickProp = props.onClick;
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (!store) return;
window.clearTimeout(showTimeoutRef.current);
showTimeoutRef.current = 0;
});
const ref = (0, import_react30.useCallback)(
(element) => {
if (!store) return;
const { anchorElement } = store.getState();
if (anchorElement == null ? void 0 : anchorElement.isConnected) return;
store.setAnchorElement(element);
},
[store]
);
props = {
...props,
ref: useMergeRefs(ref, props.ref),
onMouseMove,
onClick
};
props = useFocusable(props);
return props;
}
);
var HovercardAnchor = forwardRef2(function HovercardAnchor2(props) {
const htmlProps = useHovercardAnchor(props);
return createElement(TagName23, htmlProps);
});
// node_modules/@ariakit/react-core/esm/tooltip/tooltip-anchor.js
var import_react31 = __toESM(require_react(), 1);
var TagName24 = "div";
var globalStore = createStore({
activeStore: null
});
function createRemoveStoreCallback(store) {
return () => {
const { activeStore } = globalStore.getState();
if (activeStore !== store) return;
globalStore.setState("activeStore", null);
};
}
var useTooltipAnchor = createHook(
function useTooltipAnchor2({ store, showOnHover = true, ...props }) {
const context = useTooltipProviderContext();
store = store || context;
invariant(
store,
"TooltipAnchor must receive a `store` prop or be wrapped in a TooltipProvider component."
);
const canShowOnHoverRef = (0, import_react31.useRef)(false);
(0, import_react31.useEffect)(() => {
return sync(store, ["mounted"], (state) => {
if (state.mounted) return;
canShowOnHoverRef.current = false;
});
}, [store]);
(0, import_react31.useEffect)(() => {
if (!store) return;
return chain(
// Immediately remove the current store from the global store when
// the component unmounts. This is useful, for example, to avoid
// showing tooltips immediately on serial tests.
createRemoveStoreCallback(store),
sync(store, ["mounted", "skipTimeout"], (state) => {
if (!store) return;
if (state.mounted) {
const { activeStore } = globalStore.getState();
if (activeStore !== store) {
activeStore == null ? void 0 : activeStore.hide();
}
return globalStore.setState("activeStore", store);
}
const id3 = setTimeout(
createRemoveStoreCallback(store),
state.skipTimeout
);
return () => clearTimeout(id3);
})
);
}, [store]);
const onMouseEnterProp = props.onMouseEnter;
const onMouseEnter = useEvent((event) => {
onMouseEnterProp == null ? void 0 : onMouseEnterProp(event);
canShowOnHoverRef.current = true;
});
const onFocusVisibleProp = props.onFocusVisible;
const onFocusVisible = useEvent((event) => {
onFocusVisibleProp == null ? void 0 : onFocusVisibleProp(event);
if (event.defaultPrevented) return;
store == null ? void 0 : store.setAnchorElement(event.currentTarget);
store == null ? void 0 : store.show();
});
const onBlurProp = props.onBlur;
const onBlur = useEvent((event) => {
onBlurProp == null ? void 0 : onBlurProp(event);
if (event.defaultPrevented) return;
const { activeStore } = globalStore.getState();
canShowOnHoverRef.current = false;
if (activeStore === store) {
globalStore.setState("activeStore", null);
}
});
const type = store.useState("type");
const contentId = store.useState((state) => {
var _a;
return (_a = state.contentElement) == null ? void 0 : _a.id;
});
props = {
"aria-labelledby": type === "label" ? contentId : void 0,
...props,
onMouseEnter,
onFocusVisible,
onBlur
};
props = useHovercardAnchor({
store,
showOnHover(event) {
if (!canShowOnHoverRef.current) return false;
if (isFalsyBooleanCallback(showOnHover, event)) return false;
const { activeStore } = globalStore.getState();
if (!activeStore) return true;
store == null ? void 0 : store.show();
return false;
},
...props
});
return props;
}
);
var TooltipAnchor = forwardRef2(function TooltipAnchor2(props) {
const htmlProps = useTooltipAnchor(props);
return createElement(TagName24, htmlProps);
});
// node_modules/@ariakit/core/esm/__chunks/BFGNM53A.js
function createPopoverStore({
popover: otherPopover,
...props
} = {}) {
const store = mergeStore(
props.store,
omit2(otherPopover, [
"arrowElement",
"anchorElement",
"contentElement",
"popoverElement",
"disclosureElement"
])
);
throwOnConflictingProps(props, store);
const syncState = store == null ? void 0 : store.getState();
const dialog = createDialogStore({ ...props, store });
const placement = defaultValue(
props.placement,
syncState == null ? void 0 : syncState.placement,
"bottom"
);
const initialState = {
...dialog.getState(),
placement,
currentPlacement: placement,
anchorElement: defaultValue(syncState == null ? void 0 : syncState.anchorElement, null),
popoverElement: defaultValue(syncState == null ? void 0 : syncState.popoverElement, null),
arrowElement: defaultValue(syncState == null ? void 0 : syncState.arrowElement, null),
rendered: /* @__PURE__ */ Symbol("rendered")
};
const popover = createStore(initialState, dialog, store);
return {
...dialog,
...popover,
setAnchorElement: (element) => popover.setState("anchorElement", element),
setPopoverElement: (element) => popover.setState("popoverElement", element),
setArrowElement: (element) => popover.setState("arrowElement", element),
render: () => popover.setState("rendered", /* @__PURE__ */ Symbol("rendered"))
};
}
// node_modules/@ariakit/react-core/esm/__chunks/B6FLPFJM.js
function usePopoverStoreProps(store, update, props) {
useUpdateEffect(update, [props.popover]);
useStoreProps(store, props, "placement");
return useDialogStoreProps(store, update, props);
}
// node_modules/@ariakit/core/esm/__chunks/TIQDSBWP.js
function createHovercardStore(props = {}) {
var _a;
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const popover = createPopoverStore({
...props,
placement: defaultValue(
props.placement,
syncState == null ? void 0 : syncState.placement,
"bottom"
)
});
const timeout = defaultValue(props.timeout, syncState == null ? void 0 : syncState.timeout, 500);
const initialState = {
...popover.getState(),
timeout,
showTimeout: defaultValue(props.showTimeout, syncState == null ? void 0 : syncState.showTimeout),
hideTimeout: defaultValue(props.hideTimeout, syncState == null ? void 0 : syncState.hideTimeout),
autoFocusOnShow: defaultValue(syncState == null ? void 0 : syncState.autoFocusOnShow, false)
};
const hovercard = createStore(initialState, popover, props.store);
return {
...popover,
...hovercard,
setAutoFocusOnShow: (value) => hovercard.setState("autoFocusOnShow", value)
};
}
// node_modules/@ariakit/react-core/esm/__chunks/ECBEZ4YM.js
function useHovercardStoreProps(store, update, props) {
useStoreProps(store, props, "timeout");
useStoreProps(store, props, "showTimeout");
useStoreProps(store, props, "hideTimeout");
return usePopoverStoreProps(store, update, props);
}
// node_modules/@ariakit/core/esm/tooltip/tooltip-store.js
function createTooltipStore(props = {}) {
var _a;
if (true) {
if (props.type === "label") {
console.warn(
"The `type` option on the tooltip store is deprecated.",
"Render a visually hidden label or use the `aria-label` or `aria-labelledby` attributes on the anchor element instead.",
"See https://ariakit.org/components/tooltip#tooltip-anchors-must-have-accessible-names"
);
}
}
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const hovercard = createHovercardStore({
...props,
placement: defaultValue(
props.placement,
syncState == null ? void 0 : syncState.placement,
"top"
),
hideTimeout: defaultValue(props.hideTimeout, syncState == null ? void 0 : syncState.hideTimeout, 0)
});
const initialState = {
...hovercard.getState(),
type: defaultValue(props.type, syncState == null ? void 0 : syncState.type, "description"),
skipTimeout: defaultValue(props.skipTimeout, syncState == null ? void 0 : syncState.skipTimeout, 300)
};
const tooltip = createStore(initialState, hovercard, props.store);
return {
...hovercard,
...tooltip
};
}
// node_modules/@ariakit/react-core/esm/__chunks/FFWYDZCP.js
function useTooltipStoreProps(store, update, props) {
useStoreProps(store, props, "type");
useStoreProps(store, props, "skipTimeout");
return useHovercardStoreProps(store, update, props);
}
function useTooltipStore(props = {}) {
const [store, update] = useStore(createTooltipStore, props);
return useTooltipStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/__chunks/2DUOQURA.js
var import_react32 = __toESM(require_react(), 1);
var menubar = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var useMenubarContext = menubar.useContext;
var useMenubarScopedContext = menubar.useScopedContext;
var useMenubarProviderContext = menubar.useProviderContext;
var MenubarContextProvider = menubar.ContextProvider;
var MenubarScopedContextProvider = menubar.ScopedContextProvider;
var MenuItemCheckedContext = (0, import_react32.createContext)(
void 0
);
// node_modules/@ariakit/react-core/esm/__chunks/4POTBZ2J.js
var TagName25 = "div";
var usePopoverAnchor = createHook(
function usePopoverAnchor2({ store, ...props }) {
const context = usePopoverProviderContext();
store = store || context;
props = {
...props,
ref: useMergeRefs(store == null ? void 0 : store.setAnchorElement, props.ref)
};
return props;
}
);
var PopoverAnchor = forwardRef2(function PopoverAnchor2(props) {
const htmlProps = usePopoverAnchor(props);
return createElement(TagName25, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/HMKTUWOU.js
var import_react33 = __toESM(require_react(), 1);
var TagName26 = "button";
var useButton = createHook(
function useButton2(props) {
const ref = (0, import_react33.useRef)(null);
const tagName = useTagName(ref, TagName26);
const [isNativeButton, setIsNativeButton] = (0, import_react33.useState)(
() => !!tagName && isButton({ tagName, type: props.type })
);
(0, import_react33.useEffect)(() => {
if (!ref.current) return;
setIsNativeButton(isButton(ref.current));
}, []);
props = {
role: !isNativeButton && tagName !== "a" ? "button" : void 0,
...props,
ref: useMergeRefs(ref, props.ref)
};
props = useCommand(props);
return props;
}
);
var Button = forwardRef2(function Button2(props) {
const htmlProps = useButton(props);
return createElement(TagName26, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/NDVACHQI.js
var import_react34 = __toESM(require_react(), 1);
var TagName27 = "button";
var symbol2 = /* @__PURE__ */ Symbol("disclosure");
var useDisclosure = createHook(
function useDisclosure2({ store, toggleOnClick = true, ...props }) {
const context = useDisclosureProviderContext();
store = store || context;
invariant(
store,
"Disclosure must receive a `store` prop or be wrapped in a DisclosureProvider component."
);
const ref = (0, import_react34.useRef)(null);
const [expanded, setExpanded] = (0, import_react34.useState)(false);
const disclosureElement = store.useState("disclosureElement");
const open = store.useState("open");
(0, import_react34.useEffect)(() => {
let isCurrentDisclosure = disclosureElement === ref.current;
if (!(disclosureElement == null ? void 0 : disclosureElement.isConnected)) {
store == null ? void 0 : store.setDisclosureElement(ref.current);
isCurrentDisclosure = true;
}
setExpanded(open && isCurrentDisclosure);
}, [disclosureElement, store, open]);
const onClickProp = props.onClick;
const toggleOnClickProp = useBooleanEvent(toggleOnClick);
const [isDuplicate, metadataProps] = useMetadataProps(props, symbol2, true);
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
if (isDuplicate) return;
if (!toggleOnClickProp(event)) return;
store == null ? void 0 : store.setDisclosureElement(event.currentTarget);
store == null ? void 0 : store.toggle();
});
const contentElement = store.useState("contentElement");
props = {
"aria-expanded": expanded,
"aria-controls": contentElement == null ? void 0 : contentElement.id,
...metadataProps,
...props,
ref: useMergeRefs(ref, props.ref),
onClick
};
props = useButton(props);
return props;
}
);
var Disclosure = forwardRef2(function Disclosure2(props) {
const htmlProps = useDisclosure(props);
return createElement(TagName27, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/APVORPDK.js
var TagName28 = "button";
var useDialogDisclosure = createHook(
function useDialogDisclosure2({ store, ...props }) {
const context = useDialogProviderContext();
store = store || context;
invariant(
store,
"DialogDisclosure must receive a `store` prop or be wrapped in a DialogProvider component."
);
const contentElement = store.useState("contentElement");
props = {
"aria-haspopup": getPopupRole(contentElement, "dialog"),
...props
};
props = useDisclosure({ store, ...props });
return props;
}
);
var DialogDisclosure = forwardRef2(function DialogDisclosure2(props) {
const htmlProps = useDialogDisclosure(props);
return createElement(TagName28, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/RFRKSHIZ.js
var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1);
var TagName29 = "button";
var usePopoverDisclosure = createHook(function usePopoverDisclosure2({ store, ...props }) {
const context = usePopoverProviderContext();
store = store || context;
invariant(
store,
"PopoverDisclosure must receive a `store` prop or be wrapped in a PopoverProvider component."
);
const onClickProp = props.onClick;
const onClick = useEvent((event) => {
store == null ? void 0 : store.setAnchorElement(event.currentTarget);
onClickProp == null ? void 0 : onClickProp(event);
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(PopoverScopedContextProvider, { value: store, children: element }),
[store]
);
props = {
...props,
onClick
};
props = usePopoverAnchor({ store, ...props });
props = useDialogDisclosure({ store, ...props });
return props;
});
var PopoverDisclosure = forwardRef2(function PopoverDisclosure2(props) {
const htmlProps = usePopoverDisclosure(props);
return createElement(TagName29, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/37HM5VRA.js
var import_react35 = __toESM(require_react(), 1);
var import_jsx_runtime19 = __toESM(require_jsx_runtime(), 1);
var TagName30 = "span";
var pointsMap = {
top: "4,10 8,6 12,10",
right: "6,4 10,8 6,12",
bottom: "4,6 8,10 12,6",
left: "10,4 6,8 10,12"
};
var usePopoverDisclosureArrow = createHook(function usePopoverDisclosureArrow2({ store, placement, ...props }) {
const context = usePopoverContext();
store = store || context;
invariant(
store,
"PopoverDisclosureArrow must be wrapped in a PopoverDisclosure component."
);
const position2 = store.useState((state) => placement || state.placement);
const dir = position2.split("-")[0];
const points = pointsMap[dir];
const children = (0, import_react35.useMemo)(
() => /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
"svg",
{
display: "block",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round",
strokeWidth: 1.5,
viewBox: "0 0 16 16",
height: "1em",
width: "1em",
children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)("polyline", { points })
}
),
[points]
);
props = {
children,
"aria-hidden": true,
...props,
style: {
width: "1em",
height: "1em",
pointerEvents: "none",
...props.style
}
};
return removeUndefinedValues(props);
});
var PopoverDisclosureArrow = forwardRef2(
function PopoverDisclosureArrow2(props) {
const htmlProps = usePopoverDisclosureArrow(props);
return createElement(TagName30, htmlProps);
}
);
// node_modules/@ariakit/react-core/esm/__chunks/QOZ6WMRY.js
var ctx12 = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var useRadioContext = ctx12.useContext;
var useRadioScopedContext = ctx12.useScopedContext;
var useRadioProviderContext = ctx12.useProviderContext;
var RadioContextProvider = ctx12.ContextProvider;
var RadioScopedContextProvider = ctx12.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/5TKKKQCL.js
var import_react36 = __toESM(require_react(), 1);
var TagName31 = "input";
function getIsChecked(value, storeValue) {
if (storeValue === void 0) return;
if (value != null && storeValue != null) {
return storeValue === value;
}
return !!storeValue;
}
function isNativeRadio(tagName, type) {
return tagName === "input" && (!type || type === "radio");
}
var useRadio = createHook(function useRadio2({
store,
name,
value,
checked,
...props
}) {
const context = useRadioContext();
store = store || context;
const id3 = useId(props.id);
const ref = (0, import_react36.useRef)(null);
const isChecked = useStoreState(
store,
(state) => checked != null ? checked : getIsChecked(value, state == null ? void 0 : state.value)
);
(0, import_react36.useEffect)(() => {
if (!id3) return;
if (!isChecked) return;
const isActiveItem = (store == null ? void 0 : store.getState().activeId) === id3;
if (isActiveItem) return;
store == null ? void 0 : store.setActiveId(id3);
}, [store, isChecked, id3]);
const onChangeProp = props.onChange;
const tagName = useTagName(ref, TagName31);
const nativeRadio = isNativeRadio(tagName, props.type);
const disabled = disabledFromProps(props);
const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
(0, import_react36.useEffect)(() => {
const element = ref.current;
if (!element) return;
if (nativeRadio) return;
if (isChecked !== void 0) {
element.checked = isChecked;
}
if (name !== void 0) {
element.name = name;
}
if (value !== void 0) {
element.value = `${value}`;
}
}, [propertyUpdated, nativeRadio, isChecked, name, value]);
const onChange = useEvent((event) => {
if (disabled) {
event.preventDefault();
event.stopPropagation();
return;
}
if ((store == null ? void 0 : store.getState().value) === value) return;
if (!nativeRadio) {
event.currentTarget.checked = true;
schedulePropertyUpdate();
}
onChangeProp == null ? void 0 : onChangeProp(event);
if (event.defaultPrevented) return;
store == null ? void 0 : store.setValue(value);
});
const onClickProp = props.onClick;
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
if (nativeRadio) return;
onChange(event);
});
const onFocusProp = props.onFocus;
const onFocus = useEvent((event) => {
onFocusProp == null ? void 0 : onFocusProp(event);
if (event.defaultPrevented) return;
if (!nativeRadio) return;
if (!store) return;
const { moves, activeId } = store.getState();
if (!moves) return;
if (id3 && activeId !== id3) return;
onChange(event);
});
props = {
id: id3,
role: !nativeRadio ? "radio" : void 0,
type: nativeRadio ? "radio" : void 0,
"aria-checked": isChecked,
...props,
ref: useMergeRefs(ref, props.ref),
onChange,
onClick,
onFocus
};
props = useCompositeItem({
store,
clickOnEnter: !nativeRadio,
...props
});
return removeUndefinedValues({
name: nativeRadio ? name : void 0,
value: nativeRadio ? value : void 0,
checked: isChecked,
...props
});
});
var Radio = memo2(
forwardRef2(function Radio2(props) {
const htmlProps = useRadio(props);
return createElement(TagName31, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/radio/radio-group.js
var import_jsx_runtime20 = __toESM(require_jsx_runtime(), 1);
var TagName32 = "div";
var useRadioGroup = createHook(
function useRadioGroup2({ store, ...props }) {
const context = useRadioProviderContext();
store = store || context;
invariant(
store,
"RadioGroup must receive a `store` prop or be wrapped in a RadioProvider component."
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(RadioScopedContextProvider, { value: store, children: element }),
[store]
);
props = {
role: "radiogroup",
...props
};
props = useComposite({ store, ...props });
return props;
}
);
var RadioGroup = forwardRef2(function RadioGroup2(props) {
const htmlProps = useRadioGroup(props);
return createElement(TagName32, htmlProps);
});
// node_modules/@ariakit/core/esm/radio/radio-store.js
function createRadioStore({
...props
} = {}) {
var _a;
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const composite = createCompositeStore({
...props,
focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, true)
});
const initialState = {
...composite.getState(),
value: defaultValue(
props.value,
syncState == null ? void 0 : syncState.value,
props.defaultValue,
null
)
};
const radio = createStore(initialState, composite, props.store);
return {
...composite,
...radio,
setValue: (value) => radio.setState("value", value)
};
}
// node_modules/@ariakit/react-core/esm/__chunks/EBNR6XRJ.js
function useRadioStoreProps(store, update, props) {
store = useCompositeStoreProps(store, update, props);
useStoreProps(store, props, "value", "setValue");
return store;
}
function useRadioStore(props = {}) {
const [store, update] = useStore(createRadioStore, props);
return useRadioStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/__chunks/N5BMKDVD.js
var TagName33 = "span";
var useSelectArrow = createHook(
function useSelectArrow2({ store, ...props }) {
const context = useSelectContext();
store = store || context;
props = usePopoverDisclosureArrow({ store, ...props });
return props;
}
);
var SelectArrow = forwardRef2(function SelectArrow2(props) {
const htmlProps = useSelectArrow(props);
return createElement(TagName33, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/FORDJ4GP.js
var import_react37 = __toESM(require_react(), 1);
var TagName34 = "div";
var chars = "";
function clearChars() {
chars = "";
}
function isValidTypeaheadEvent(event) {
const target = event.target;
if (target && isTextField(target)) return false;
if (event.key === " " && chars.length) return true;
return event.key.length === 1 && !event.ctrlKey && !event.altKey && !event.metaKey && /^[\p{Letter}\p{Number}]$/u.test(event.key);
}
function isSelfTargetOrItem(event, items) {
if (isSelfTarget(event)) return true;
const target = event.target;
if (!target) return false;
const isItem2 = items.some((item2) => item2.element === target);
return isItem2;
}
function getEnabledItems2(items) {
return items.filter((item2) => !item2.disabled);
}
function itemTextStartsWith(item2, text) {
var _a;
const itemText = ((_a = item2.element) == null ? void 0 : _a.textContent) || item2.children || // The composite item object itself doesn't include a value property, but
// other components like Select do. Since CompositeTypeahead is a generic
// component that can be used with those as well, we also consider the value
// property as a fallback for the typeahead text content.
"value" in item2 && item2.value;
if (!itemText) return false;
return normalizeString(itemText).trim().toLowerCase().startsWith(text.toLowerCase());
}
function getSameInitialItems(items, char2, activeId) {
if (!activeId) return items;
const activeItem = items.find((item2) => item2.id === activeId);
if (!activeItem) return items;
if (!itemTextStartsWith(activeItem, char2)) return items;
if (chars !== char2 && itemTextStartsWith(activeItem, chars)) return items;
chars = char2;
return flipItems(
items.filter((item2) => itemTextStartsWith(item2, chars)),
activeId
).filter((item2) => item2.id !== activeId);
}
var useCompositeTypeahead = createHook(function useCompositeTypeahead2({ store, typeahead = true, ...props }) {
const context = useCompositeContext();
store = store || context;
invariant(
store,
"CompositeTypeahead must be a Composite component"
);
const onKeyDownCaptureProp = props.onKeyDownCapture;
const cleanupTimeoutRef = (0, import_react37.useRef)(0);
const onKeyDownCapture = useEvent((event) => {
onKeyDownCaptureProp == null ? void 0 : onKeyDownCaptureProp(event);
if (event.defaultPrevented) return;
if (!typeahead) return;
if (!store) return;
if (!isValidTypeaheadEvent(event)) {
return clearChars();
}
const { renderedItems, items, activeId, id: id3 } = store.getState();
let enabledItems = getEnabledItems2(
items.length > renderedItems.length ? items : renderedItems
);
const document2 = getDocument(event.currentTarget);
const selector2 = `[data-offscreen-id="${id3}"]`;
const offscreenItems = document2.querySelectorAll(selector2);
for (const element of offscreenItems) {
const disabled = element.ariaDisabled === "true" || "disabled" in element && !!element.disabled;
enabledItems.push({ id: element.id, element, disabled });
}
if (offscreenItems.length) {
enabledItems = sortBasedOnDOMPosition(enabledItems, (i3) => i3.element);
}
if (!isSelfTargetOrItem(event, enabledItems)) return clearChars();
event.preventDefault();
window.clearTimeout(cleanupTimeoutRef.current);
cleanupTimeoutRef.current = window.setTimeout(() => {
chars = "";
}, 500);
const char2 = event.key.toLowerCase();
chars += char2;
enabledItems = getSameInitialItems(enabledItems, char2, activeId);
const item2 = enabledItems.find((item22) => itemTextStartsWith(item22, chars));
if (item2) {
store.move(item2.id);
} else {
clearChars();
}
});
props = {
...props,
onKeyDownCapture
};
return removeUndefinedValues(props);
});
var CompositeTypeahead = forwardRef2(function CompositeTypeahead2(props) {
const htmlProps = useCompositeTypeahead(props);
return createElement(TagName34, htmlProps);
});
// node_modules/@ariakit/react-core/esm/select/select.js
var import_react38 = __toESM(require_react(), 1);
var import_jsx_runtime21 = __toESM(require_jsx_runtime(), 1);
var TagName35 = "button";
function getSelectedValues(select) {
return Array.from(select.selectedOptions).map((option) => option.value);
}
function nextWithValue(store, next2) {
return () => {
const nextId = next2();
if (!nextId) return;
let i3 = 0;
let nextItem = store.item(nextId);
const firstItem = nextItem;
while (nextItem && nextItem.value == null) {
const nextId2 = next2(++i3);
if (!nextId2) return;
nextItem = store.item(nextId2);
if (nextItem === firstItem) break;
}
return nextItem == null ? void 0 : nextItem.id;
};
}
var useSelect = createHook(function useSelect2({
store,
name,
form,
required,
showOnKeyDown = true,
moveOnKeyDown = true,
toggleOnPress = true,
toggleOnClick = toggleOnPress,
...props
}) {
const context = useSelectProviderContext();
store = store || context;
invariant(
store,
"Select must receive a `store` prop or be wrapped in a SelectProvider component."
);
const onKeyDownProp = props.onKeyDown;
const showOnKeyDownProp = useBooleanEvent(showOnKeyDown);
const moveOnKeyDownProp = useBooleanEvent(moveOnKeyDown);
const placement = store.useState("placement");
const dir = placement.split("-")[0];
const value = store.useState("value");
const multiSelectable = Array.isArray(value);
const onKeyDown = useEvent((event) => {
var _a;
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (event.defaultPrevented) return;
if (!store) return;
const { orientation, items: items2, activeId } = store.getState();
const isVertical = orientation !== "horizontal";
const isHorizontal = orientation !== "vertical";
const isGrid2 = !!((_a = items2.find((item2) => !item2.disabled && item2.value != null)) == null ? void 0 : _a.rowId);
const moveKeyMap = {
ArrowUp: (isGrid2 || isVertical) && nextWithValue(store, store.up),
ArrowRight: (isGrid2 || isHorizontal) && nextWithValue(store, store.next),
ArrowDown: (isGrid2 || isVertical) && nextWithValue(store, store.down),
ArrowLeft: (isGrid2 || isHorizontal) && nextWithValue(store, store.previous)
};
const getId = moveKeyMap[event.key];
if (getId && moveOnKeyDownProp(event)) {
event.preventDefault();
store.move(getId());
}
const isTopOrBottom = dir === "top" || dir === "bottom";
const isLeft = dir === "left";
const isRight = dir === "right";
const canShowKeyMap = {
ArrowDown: isTopOrBottom,
ArrowUp: isTopOrBottom,
ArrowLeft: isLeft,
ArrowRight: isRight
};
const canShow = canShowKeyMap[event.key];
if (canShow && showOnKeyDownProp(event)) {
event.preventDefault();
store.move(activeId);
queueBeforeEvent(event.currentTarget, "keyup", store.show);
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(SelectScopedContextProvider, { value: store, children: element }),
[store]
);
const [autofill, setAutofill] = (0, import_react38.useState)(false);
const nativeSelectChangedRef = (0, import_react38.useRef)(false);
(0, import_react38.useEffect)(() => {
const nativeSelectChanged = nativeSelectChangedRef.current;
nativeSelectChangedRef.current = false;
if (nativeSelectChanged) return;
setAutofill(false);
}, [value]);
const labelId = store.useState((state) => {
var _a;
return (_a = state.labelElement) == null ? void 0 : _a.id;
});
const label = props["aria-label"];
const labelledBy = props["aria-labelledby"] || labelId;
const items = store.useState((state) => {
if (!name) return;
return state.items;
});
const values = (0, import_react38.useMemo)(() => {
return [...new Set(items == null ? void 0 : items.map((i3) => i3.value).filter((v3) => v3 != null))];
}, [items]);
props = useWrapElement(
props,
(element) => {
if (!name) return element;
return /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [
/* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(
"select",
{
style: {
border: 0,
clip: "rect(0 0 0 0)",
height: "1px",
margin: "-1px",
overflow: "hidden",
padding: 0,
position: "absolute",
whiteSpace: "nowrap",
width: "1px"
},
tabIndex: -1,
"aria-hidden": true,
"aria-label": label,
"aria-labelledby": labelledBy,
name,
form,
required,
disabled: props.disabled,
value,
multiple: multiSelectable,
onFocus: () => {
var _a;
return (_a = store == null ? void 0 : store.getState().selectElement) == null ? void 0 : _a.focus();
},
onChange: (event) => {
nativeSelectChangedRef.current = true;
setAutofill(true);
store == null ? void 0 : store.setValue(
multiSelectable ? getSelectedValues(event.target) : event.target.value
);
},
children: [
toArray(value).map((value2) => {
if (value2 == null) return null;
if (values.includes(value2)) return null;
return /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("option", { value: value2, children: value2 }, value2);
}),
values.map((value2) => /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("option", { value: value2, children: value2 }, value2))
]
}
),
element
] });
},
[
store,
label,
labelledBy,
name,
form,
required,
value,
multiSelectable,
values,
props.disabled
]
);
const children = /* @__PURE__ */ (0, import_jsx_runtime21.jsxs)(import_jsx_runtime21.Fragment, { children: [
value,
/* @__PURE__ */ (0, import_jsx_runtime21.jsx)(SelectArrow, {})
] });
const contentElement = store.useState("contentElement");
props = {
role: "combobox",
"aria-autocomplete": "none",
"aria-labelledby": labelId,
"aria-haspopup": getPopupRole(contentElement, "listbox"),
"data-autofill": autofill || void 0,
"data-name": name,
children,
...props,
ref: useMergeRefs(store.setSelectElement, props.ref),
onKeyDown
};
props = usePopoverDisclosure({ store, toggleOnClick, ...props });
props = useCompositeTypeahead({ store, ...props });
return props;
});
var Select = forwardRef2(function Select2(props) {
const htmlProps = useSelect(props);
return createElement(TagName35, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/7HVFURXT.js
var import_react39 = __toESM(require_react(), 1);
var GroupLabelContext = (0, import_react39.createContext)(void 0);
// node_modules/@ariakit/react-core/esm/__chunks/Y6I7WX7H.js
var import_react40 = __toESM(require_react(), 1);
var import_jsx_runtime22 = __toESM(require_jsx_runtime(), 1);
var TagName36 = "div";
var useGroup = createHook(
function useGroup2(props) {
const [labelId, setLabelId] = (0, import_react40.useState)();
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime22.jsx)(GroupLabelContext.Provider, { value: setLabelId, children: element }),
[]
);
props = {
role: "group",
"aria-labelledby": labelId,
...props
};
return removeUndefinedValues(props);
}
);
var Group = forwardRef2(function Group2(props) {
const htmlProps = useGroup(props);
return createElement(TagName36, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/XXOHUFXO.js
var TagName37 = "div";
var useCompositeGroup = createHook(
function useCompositeGroup2({ store, ...props }) {
props = useGroup(props);
return props;
}
);
var CompositeGroup = forwardRef2(function CompositeGroup2(props) {
const htmlProps = useCompositeGroup(props);
return createElement(TagName37, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/NH3GYEZ7.js
var import_react41 = __toESM(require_react(), 1);
var TagName38 = "div";
var useGroupLabel = createHook(
function useGroupLabel2(props) {
const setLabelId = (0, import_react41.useContext)(GroupLabelContext);
const id3 = useId(props.id);
useSafeLayoutEffect(() => {
setLabelId == null ? void 0 : setLabelId(id3);
return () => setLabelId == null ? void 0 : setLabelId(void 0);
}, [setLabelId, id3]);
props = {
id: id3,
"aria-hidden": true,
...props
};
return removeUndefinedValues(props);
}
);
var GroupLabel = forwardRef2(function GroupLabel2(props) {
const htmlProps = useGroupLabel(props);
return createElement(TagName38, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/JUZDESDO.js
var TagName39 = "div";
var useCompositeGroupLabel = createHook(function useCompositeGroupLabel2({ store, ...props }) {
props = useGroupLabel(props);
return props;
});
var CompositeGroupLabel = forwardRef2(function CompositeGroupLabel2(props) {
const htmlProps = useCompositeGroupLabel(props);
return createElement(TagName39, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/X6LNAU2F.js
var import_react42 = __toESM(require_react(), 1);
var TagName40 = "div";
function getMouseDestination(event) {
const relatedTarget = event.relatedTarget;
if ((relatedTarget == null ? void 0 : relatedTarget.nodeType) === Node.ELEMENT_NODE) {
return relatedTarget;
}
return null;
}
function hoveringInside(event) {
const nextElement = getMouseDestination(event);
if (!nextElement) return false;
return contains(event.currentTarget, nextElement);
}
var symbol3 = /* @__PURE__ */ Symbol("composite-hover");
function movingToAnotherItem(event) {
let dest = getMouseDestination(event);
if (!dest) return false;
do {
if (hasOwnProperty(dest, symbol3) && dest[symbol3]) return true;
dest = dest.parentElement;
} while (dest);
return false;
}
var useCompositeHover = createHook(
function useCompositeHover2({
store,
focusOnHover = true,
blurOnHoverEnd = !!focusOnHover,
...props
}) {
const context = useCompositeContext();
store = store || context;
invariant(
store,
"CompositeHover must be wrapped in a Composite component."
);
const isMouseMoving = useIsMouseMoving();
const onMouseMoveProp = props.onMouseMove;
const focusOnHoverProp = useBooleanEvent(focusOnHover);
const onMouseMove = useEvent((event) => {
onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);
if (event.defaultPrevented) return;
if (!isMouseMoving()) return;
if (!focusOnHoverProp(event)) return;
if (!hasFocusWithin(event.currentTarget)) {
const baseElement = store == null ? void 0 : store.getState().baseElement;
if (baseElement && !hasFocus(baseElement)) {
baseElement.focus();
}
}
store == null ? void 0 : store.setActiveId(event.currentTarget.id);
});
const onMouseLeaveProp = props.onMouseLeave;
const blurOnHoverEndProp = useBooleanEvent(blurOnHoverEnd);
const onMouseLeave = useEvent((event) => {
var _a;
onMouseLeaveProp == null ? void 0 : onMouseLeaveProp(event);
if (event.defaultPrevented) return;
if (!isMouseMoving()) return;
if (hoveringInside(event)) return;
if (movingToAnotherItem(event)) return;
if (!focusOnHoverProp(event)) return;
if (!blurOnHoverEndProp(event)) return;
store == null ? void 0 : store.setActiveId(null);
(_a = store == null ? void 0 : store.getState().baseElement) == null ? void 0 : _a.focus();
});
const ref = (0, import_react42.useCallback)((element) => {
if (!element) return;
element[symbol3] = true;
}, []);
props = {
...props,
ref: useMergeRefs(ref, props.ref),
onMouseMove,
onMouseLeave
};
return removeUndefinedValues(props);
}
);
var CompositeHover = memo2(
forwardRef2(function CompositeHover2(props) {
const htmlProps = useCompositeHover(props);
return createElement(TagName40, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/__chunks/4M2S6L5P.js
var import_react43 = __toESM(require_react(), 1);
var import_jsx_runtime23 = __toESM(require_jsx_runtime(), 1);
var TagName41 = "div";
function isSelected(storeValue, itemValue) {
if (itemValue == null) return;
if (storeValue == null) return false;
if (Array.isArray(storeValue)) {
return storeValue.includes(itemValue);
}
return storeValue === itemValue;
}
var useSelectItem = createHook(
function useSelectItem2({
store,
value,
getItem: getItemProp,
hideOnClick,
setValueOnClick = value != null,
preventScrollOnKeyDown = true,
focusOnHover = true,
...props
}) {
var _a;
const context = useSelectScopedContext();
store = store || context;
invariant(
store,
"SelectItem must be wrapped in a SelectList or SelectPopover component."
);
const id3 = useId(props.id);
const disabled = disabledFromProps(props);
const { listElement, multiSelectable, selected, autoFocus } = useStoreStateObject(store, {
listElement: "listElement",
multiSelectable(state) {
return Array.isArray(state.value);
},
selected(state) {
return isSelected(state.value, value);
},
autoFocus(state) {
if (value == null) return false;
if (state.value == null) return false;
if (state.activeId !== id3 && (store == null ? void 0 : store.item(state.activeId))) {
return false;
}
if (Array.isArray(state.value)) {
return state.value[state.value.length - 1] === value;
}
return state.value === value;
}
});
const getItem = (0, import_react43.useCallback)(
(item2) => {
const nextItem = {
...item2,
value: disabled ? void 0 : value,
children: value
};
if (getItemProp) {
return getItemProp(nextItem);
}
return nextItem;
},
[disabled, value, getItemProp]
);
hideOnClick = hideOnClick != null ? hideOnClick : value != null && !multiSelectable;
const onClickProp = props.onClick;
const setValueOnClickProp = useBooleanEvent(setValueOnClick);
const hideOnClickProp = useBooleanEvent(hideOnClick);
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
if (isDownloading(event)) return;
if (isOpeningInNewTab(event)) return;
if (setValueOnClickProp(event) && value != null) {
store == null ? void 0 : store.setValue((prevValue) => {
if (!Array.isArray(prevValue)) return value;
if (prevValue.includes(value)) {
return prevValue.filter((v3) => v3 !== value);
}
return [...prevValue, value];
});
}
if (hideOnClickProp(event)) {
store == null ? void 0 : store.hide();
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime23.jsx)(SelectItemCheckedContext.Provider, { value: selected != null ? selected : false, children: element }),
[selected]
);
props = {
id: id3,
role: getPopupItemRole(listElement),
"aria-selected": selected,
children: value,
...props,
autoFocus: (_a = props.autoFocus) != null ? _a : autoFocus,
onClick
};
props = useCompositeItem({
store,
getItem,
preventScrollOnKeyDown,
...props
});
const focusOnHoverProp = useBooleanEvent(focusOnHover);
props = useCompositeHover({
store,
...props,
// We have to disable focusOnHover when the popup is closed, otherwise
// the active item will change to null (the container) when the popup is
// closed by clicking on an item.
focusOnHover(event) {
if (!focusOnHoverProp(event)) return false;
const state = store == null ? void 0 : store.getState();
return !!(state == null ? void 0 : state.open);
}
});
return props;
}
);
var SelectItem = memo2(
forwardRef2(function SelectItem2(props) {
const htmlProps = useSelectItem(props);
return createElement(TagName41, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/__chunks/EYKMH5G5.js
var import_react44 = __toESM(require_react(), 1);
var CheckboxCheckedContext = (0, import_react44.createContext)(false);
// node_modules/@ariakit/react-core/esm/__chunks/HOITXJDS.js
var import_react45 = __toESM(require_react(), 1);
var import_jsx_runtime24 = __toESM(require_jsx_runtime(), 1);
var TagName42 = "span";
var checkmark = /* @__PURE__ */ (0, import_jsx_runtime24.jsx)(
"svg",
{
display: "block",
fill: "none",
stroke: "currentColor",
strokeLinecap: "round",
strokeLinejoin: "round",
strokeWidth: 1.5,
viewBox: "0 0 16 16",
height: "1em",
width: "1em",
children: /* @__PURE__ */ (0, import_jsx_runtime24.jsx)("polyline", { points: "4,8 7,12 12,4" })
}
);
function getChildren(props) {
if (props.checked) {
return props.children || checkmark;
}
if (typeof props.children === "function") {
return props.children;
}
return null;
}
var useCheckboxCheck = createHook(
function useCheckboxCheck2({ store, checked, ...props }) {
const context = (0, import_react45.useContext)(CheckboxCheckedContext);
checked = checked != null ? checked : context;
const children = getChildren({ checked, children: props.children });
props = {
"aria-hidden": true,
...props,
children,
style: {
width: "1em",
height: "1em",
pointerEvents: "none",
...props.style
}
};
return removeUndefinedValues(props);
}
);
var CheckboxCheck = forwardRef2(function CheckboxCheck2(props) {
const htmlProps = useCheckboxCheck(props);
return createElement(TagName42, htmlProps);
});
// node_modules/@ariakit/react-core/esm/select/select-item-check.js
var import_react46 = __toESM(require_react(), 1);
var TagName43 = "span";
var useSelectItemCheck = createHook(
function useSelectItemCheck2({ store, checked, ...props }) {
const context = (0, import_react46.useContext)(SelectItemCheckedContext);
checked = checked != null ? checked : context;
props = useCheckboxCheck({ ...props, checked });
return props;
}
);
var SelectItemCheck = forwardRef2(function SelectItemCheck2(props) {
const htmlProps = useSelectItemCheck(props);
return createElement(TagName43, htmlProps);
});
// node_modules/@ariakit/react-core/esm/select/select-label.js
var TagName44 = "div";
var useSelectLabel = createHook(
function useSelectLabel2({ store, ...props }) {
const context = useSelectProviderContext();
store = store || context;
invariant(
store,
"SelectLabel must receive a `store` prop or be wrapped in a SelectProvider component."
);
const id3 = useId(props.id);
const onClickProp = props.onClick;
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
queueMicrotask(() => {
const select = store == null ? void 0 : store.getState().selectElement;
select == null ? void 0 : select.focus();
});
});
props = {
id: id3,
...props,
ref: useMergeRefs(store.setLabelElement, props.ref),
onClick,
style: {
cursor: "default",
...props.style
}
};
return removeUndefinedValues(props);
}
);
var SelectLabel = memo2(
forwardRef2(function SelectLabel2(props) {
const htmlProps = useSelectLabel(props);
return createElement(TagName44, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/__chunks/PFBP2CY4.js
var import_react47 = __toESM(require_react(), 1);
var import_jsx_runtime25 = __toESM(require_jsx_runtime(), 1);
var TagName45 = "div";
var SelectListContext = (0, import_react47.createContext)(null);
var useSelectList = createHook(
function useSelectList2({
store,
resetOnEscape = true,
hideOnEnter = true,
focusOnMove = true,
composite,
alwaysVisible,
...props
}) {
const context = useSelectContext();
store = store || context;
invariant(
store,
"SelectList must receive a `store` prop or be wrapped in a SelectProvider component."
);
const id3 = useId(props.id);
const value = store.useState("value");
const multiSelectable = Array.isArray(value);
const [defaultValue2, setDefaultValue] = (0, import_react47.useState)(value);
const mounted = store.useState("mounted");
(0, import_react47.useEffect)(() => {
if (mounted) return;
setDefaultValue(value);
}, [mounted, value]);
resetOnEscape = resetOnEscape && !multiSelectable;
const onKeyDownProp = props.onKeyDown;
const resetOnEscapeProp = useBooleanEvent(resetOnEscape);
const hideOnEnterProp = useBooleanEvent(hideOnEnter);
const onKeyDown = useEvent((event) => {
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (event.defaultPrevented) return;
if (event.key === "Escape" && resetOnEscapeProp(event)) {
store == null ? void 0 : store.setValue(defaultValue2);
}
if (event.key === " " || event.key === "Enter") {
if (isSelfTarget(event) && hideOnEnterProp(event)) {
event.preventDefault();
store == null ? void 0 : store.hide();
}
}
});
const headingContext = (0, import_react47.useContext)(SelectHeadingContext);
const headingState = (0, import_react47.useState)();
const [headingId, setHeadingId] = headingContext || headingState;
const headingContextValue = (0, import_react47.useMemo)(
() => [headingId, setHeadingId],
[headingId]
);
const [childStore, setChildStore] = (0, import_react47.useState)(null);
const setStore = (0, import_react47.useContext)(SelectListContext);
(0, import_react47.useEffect)(() => {
if (!setStore) return;
setStore(store);
return () => setStore(null);
}, [setStore, store]);
props = useWrapElement(
props,
(element2) => /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(SelectScopedContextProvider, { value: store, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(SelectListContext.Provider, { value: setChildStore, children: /* @__PURE__ */ (0, import_jsx_runtime25.jsx)(SelectHeadingContext.Provider, { value: headingContextValue, children: element2 }) }) }),
[store, headingContextValue]
);
const hasCombobox = !!store.combobox;
composite = composite != null ? composite : !hasCombobox && childStore !== store;
const [element, setElement] = useTransactionState(
composite ? store.setListElement : null
);
const role = useAttribute(element, "role", props.role);
const isCompositeRole = role === "listbox" || role === "menu" || role === "tree" || role === "grid";
const ariaMultiSelectable = composite || isCompositeRole ? multiSelectable || void 0 : void 0;
const hidden = isHidden(mounted, props.hidden, alwaysVisible);
const style2 = hidden ? { ...props.style, display: "none" } : props.style;
if (composite) {
props = {
role: "listbox",
"aria-multiselectable": ariaMultiSelectable,
...props
};
}
const labelId = store.useState(
(state) => {
var _a;
return headingId || ((_a = state.labelElement) == null ? void 0 : _a.id);
}
);
props = {
id: id3,
"aria-labelledby": labelId,
hidden,
...props,
ref: useMergeRefs(setElement, props.ref),
style: style2,
onKeyDown
};
props = useComposite({ store, ...props, composite });
props = useCompositeTypeahead({ store, typeahead: !hasCombobox, ...props });
return props;
}
);
var SelectList = forwardRef2(function SelectList2(props) {
const htmlProps = useSelectList(props);
return createElement(TagName45, htmlProps);
});
// node_modules/@ariakit/react-core/esm/select/select-popover.js
var TagName46 = "div";
var useSelectPopover = createHook(
function useSelectPopover2({ store, alwaysVisible, ...props }) {
const context = useSelectProviderContext();
store = store || context;
props = useSelectList({ store, alwaysVisible, ...props });
props = usePopover({ store, alwaysVisible, ...props });
return props;
}
);
var SelectPopover = createDialogComponent(
forwardRef2(function SelectPopover2(props) {
const htmlProps = useSelectPopover(props);
return createElement(TagName46, htmlProps);
}),
useSelectProviderContext
);
// node_modules/@ariakit/core/esm/select/select-store.js
function createSelectStore({
combobox,
...props
} = {}) {
const store = mergeStore(
props.store,
omit2(combobox, [
"value",
"items",
"renderedItems",
"baseElement",
"arrowElement",
"anchorElement",
"contentElement",
"popoverElement",
"disclosureElement"
])
);
throwOnConflictingProps(props, store);
const syncState = store.getState();
const composite = createCompositeStore({
...props,
store,
virtualFocus: defaultValue(
props.virtualFocus,
syncState.virtualFocus,
true
),
includesBaseElement: defaultValue(
props.includesBaseElement,
syncState.includesBaseElement,
false
),
activeId: defaultValue(
props.activeId,
syncState.activeId,
props.defaultActiveId,
null
),
orientation: defaultValue(
props.orientation,
syncState.orientation,
"vertical"
)
});
const popover = createPopoverStore({
...props,
store,
placement: defaultValue(
props.placement,
syncState.placement,
"bottom-start"
)
});
const initialValue2 = new String("");
const initialState = {
...composite.getState(),
...popover.getState(),
value: defaultValue(
props.value,
syncState.value,
props.defaultValue,
initialValue2
),
setValueOnMove: defaultValue(
props.setValueOnMove,
syncState.setValueOnMove,
false
),
labelElement: defaultValue(syncState.labelElement, null),
selectElement: defaultValue(syncState.selectElement, null),
listElement: defaultValue(syncState.listElement, null)
};
const select = createStore(initialState, composite, popover, store);
setup(
select,
() => sync(select, ["value", "items"], (state) => {
if (state.value !== initialValue2) return;
if (!state.items.length) return;
const item2 = state.items.find(
(item22) => !item22.disabled && item22.value != null
);
if ((item2 == null ? void 0 : item2.value) == null) return;
select.setState("value", item2.value);
})
);
setup(
select,
() => sync(select, ["mounted"], (state) => {
if (state.mounted) return;
select.setState("activeId", initialState.activeId);
})
);
setup(
select,
() => sync(select, ["mounted", "items", "value"], (state) => {
if (combobox) return;
if (state.mounted) return;
const values = toArray(state.value);
const lastValue = values[values.length - 1];
if (lastValue == null) return;
const item2 = state.items.find(
(item22) => !item22.disabled && item22.value === lastValue
);
if (!item2) return;
select.setState("activeId", item2.id);
})
);
setup(
select,
() => batch(select, ["setValueOnMove", "moves"], (state) => {
const { mounted, value, activeId } = select.getState();
if (!state.setValueOnMove && mounted) return;
if (Array.isArray(value)) return;
if (!state.moves) return;
if (!activeId) return;
const item2 = composite.item(activeId);
if (!item2 || item2.disabled || item2.value == null) return;
select.setState("value", item2.value);
})
);
return {
...composite,
...popover,
...select,
combobox,
setValue: (value) => select.setState("value", value),
setLabelElement: (element) => select.setState("labelElement", element),
setSelectElement: (element) => select.setState("selectElement", element),
setListElement: (element) => select.setState("listElement", element)
};
}
// node_modules/@ariakit/react-core/esm/__chunks/HVWMDOZM.js
function useSelectStoreOptions(props) {
const combobox = useComboboxProviderContext();
props = {
...props,
combobox: props.combobox !== void 0 ? props.combobox : combobox
};
return useCompositeStoreOptions(props);
}
function useSelectStoreProps(store, update, props) {
useUpdateEffect(update, [props.combobox]);
useStoreProps(store, props, "value", "setValue");
useStoreProps(store, props, "setValueOnMove");
return Object.assign(
usePopoverStoreProps(
useCompositeStoreProps(store, update, props),
update,
props
),
{ combobox: props.combobox }
);
}
function useSelectStore(props = {}) {
props = useSelectStoreOptions(props);
const [store, update] = useStore(createSelectStore, props);
return useSelectStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/__chunks/HLPY2PXK.js
var import_react48 = __toESM(require_react(), 1);
var import_jsx_runtime26 = __toESM(require_jsx_runtime(), 1);
var TagName47 = "div";
var useCompositeRow = createHook(
function useCompositeRow2({
store,
"aria-setsize": ariaSetSize,
"aria-posinset": ariaPosInSet,
...props
}) {
const context = useCompositeContext();
store = store || context;
invariant(
store,
"CompositeRow must be wrapped in a Composite component."
);
const id3 = useId(props.id);
const baseElement = store.useState(
(state) => state.baseElement || void 0
);
const providerValue = (0, import_react48.useMemo)(
() => ({ id: id3, baseElement, ariaSetSize, ariaPosInSet }),
[id3, baseElement, ariaSetSize, ariaPosInSet]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime26.jsx)(CompositeRowContext.Provider, { value: providerValue, children: element }),
[providerValue]
);
props = { id: id3, ...props };
return removeUndefinedValues(props);
}
);
var CompositeRow = forwardRef2(function CompositeRow2(props) {
const htmlProps = useCompositeRow(props);
return createElement(TagName47, htmlProps);
});
// node_modules/@ariakit/core/esm/checkbox/checkbox-store.js
function createCheckboxStore(props = {}) {
var _a;
throwOnConflictingProps(props, props.store);
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const initialState = {
value: defaultValue(
props.value,
syncState == null ? void 0 : syncState.value,
props.defaultValue,
false
)
};
const checkbox = createStore(initialState, props.store);
return {
...checkbox,
setValue: (value) => checkbox.setState("value", value)
};
}
// node_modules/@ariakit/react-core/esm/__chunks/ALZMXNL4.js
function useCheckboxStoreProps(store, update, props) {
useUpdateEffect(update, [props.store]);
useStoreProps(store, props, "value", "setValue");
return store;
}
function useCheckboxStore(props = {}) {
const [store, update] = useStore(createCheckboxStore, props);
return useCheckboxStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/__chunks/ZVXT4QFT.js
var ctx13 = createStoreContext();
var useCheckboxContext = ctx13.useContext;
var useCheckboxScopedContext = ctx13.useScopedContext;
var useCheckboxProviderContext = ctx13.useProviderContext;
var CheckboxContextProvider = ctx13.ContextProvider;
var CheckboxScopedContextProvider = ctx13.ScopedContextProvider;
// node_modules/@ariakit/react-core/esm/__chunks/I7KWAPMF.js
var import_react49 = __toESM(require_react(), 1);
var import_jsx_runtime27 = __toESM(require_jsx_runtime(), 1);
var TagName48 = "input";
function setMixed(element, mixed) {
if (mixed) {
element.indeterminate = true;
} else if (element.indeterminate) {
element.indeterminate = false;
}
}
function isNativeCheckbox(tagName, type) {
return tagName === "input" && (!type || type === "checkbox");
}
function getPrimitiveValue(value) {
if (Array.isArray(value)) {
return value.toString();
}
return value;
}
var useCheckbox = createHook(
function useCheckbox2({
store,
name,
value: valueProp,
checked: checkedProp,
defaultChecked,
...props
}) {
const context = useCheckboxContext();
store = store || context;
const [_checked, setChecked] = (0, import_react49.useState)(defaultChecked != null ? defaultChecked : false);
const checked = useStoreState(store, (state) => {
if (checkedProp !== void 0) return checkedProp;
if ((state == null ? void 0 : state.value) === void 0) return _checked;
if (valueProp != null) {
if (Array.isArray(state.value)) {
const primitiveValue = getPrimitiveValue(valueProp);
return state.value.includes(primitiveValue);
}
return state.value === valueProp;
}
if (Array.isArray(state.value)) return false;
if (typeof state.value === "boolean") return state.value;
return false;
});
const ref = (0, import_react49.useRef)(null);
const tagName = useTagName(ref, TagName48);
const nativeCheckbox = isNativeCheckbox(tagName, props.type);
const mixed = checked ? checked === "mixed" : void 0;
const isChecked = checked === "mixed" ? false : checked;
const disabled = disabledFromProps(props);
const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
(0, import_react49.useEffect)(() => {
const element = ref.current;
if (!element) return;
setMixed(element, mixed);
if (nativeCheckbox) return;
element.checked = isChecked;
if (name !== void 0) {
element.name = name;
}
if (valueProp !== void 0) {
element.value = `${valueProp}`;
}
}, [propertyUpdated, mixed, nativeCheckbox, isChecked, name, valueProp]);
const onChangeProp = props.onChange;
const onChange = useEvent((event) => {
if (disabled) {
event.stopPropagation();
event.preventDefault();
return;
}
setMixed(event.currentTarget, mixed);
if (!nativeCheckbox) {
event.currentTarget.checked = !event.currentTarget.checked;
schedulePropertyUpdate();
}
onChangeProp == null ? void 0 : onChangeProp(event);
if (event.defaultPrevented) return;
const elementChecked = event.currentTarget.checked;
setChecked(elementChecked);
store == null ? void 0 : store.setValue((prevValue) => {
if (valueProp == null) return elementChecked;
const primitiveValue = getPrimitiveValue(valueProp);
if (!Array.isArray(prevValue)) {
return prevValue === primitiveValue ? false : primitiveValue;
}
if (elementChecked) {
if (prevValue.includes(primitiveValue)) {
return prevValue;
}
return [...prevValue, primitiveValue];
}
return prevValue.filter((v3) => v3 !== primitiveValue);
});
});
const onClickProp = props.onClick;
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
if (nativeCheckbox) return;
onChange(event);
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime27.jsx)(CheckboxCheckedContext.Provider, { value: isChecked, children: element }),
[isChecked]
);
props = {
role: !nativeCheckbox ? "checkbox" : void 0,
type: nativeCheckbox ? "checkbox" : void 0,
"aria-checked": checked,
...props,
ref: useMergeRefs(ref, props.ref),
onChange,
onClick
};
props = useCommand({ clickOnEnter: !nativeCheckbox, ...props });
return removeUndefinedValues({
name: nativeCheckbox ? name : void 0,
value: nativeCheckbox ? valueProp : void 0,
checked: isChecked,
...props
});
}
);
var Checkbox = forwardRef2(function Checkbox2(props) {
const htmlProps = useCheckbox(props);
return createElement(TagName48, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/Z4X7TRJU.js
var import_react50 = __toESM(require_react(), 1);
var menu = createStoreContext(
[CompositeContextProvider, HovercardContextProvider],
[CompositeScopedContextProvider, HovercardScopedContextProvider]
);
var useMenuContext = menu.useContext;
var useMenuScopedContext = menu.useScopedContext;
var useMenuProviderContext = menu.useProviderContext;
var MenuContextProvider = menu.ContextProvider;
var MenuScopedContextProvider = menu.ScopedContextProvider;
var MenuItemCheckedContext2 = (0, import_react50.createContext)(
void 0
);
// node_modules/@ariakit/react-core/esm/__chunks/SVHPDYU7.js
var import_react51 = __toESM(require_react(), 1);
var import_jsx_runtime28 = __toESM(require_jsx_runtime(), 1);
var TagName49 = "div";
function useAriaLabelledBy({ store, ...props }) {
const [id3, setId] = (0, import_react51.useState)(void 0);
const label = props["aria-label"];
const disclosureElement = useStoreState(store, "disclosureElement");
const contentElement = useStoreState(store, "contentElement");
(0, import_react51.useEffect)(() => {
const disclosure = disclosureElement;
if (!disclosure) return;
const menu2 = contentElement;
if (!menu2) return;
const menuLabel = label || menu2.hasAttribute("aria-label");
if (menuLabel) {
setId(void 0);
} else if (disclosure.id) {
setId(disclosure.id);
}
}, [label, disclosureElement, contentElement]);
return id3;
}
var useMenuList = createHook(
function useMenuList2({ store, alwaysVisible, composite, ...props }) {
const context = useMenuProviderContext();
store = store || context;
invariant(
store,
"MenuList must receive a `store` prop or be wrapped in a MenuProvider component."
);
const parentMenu = store.parent;
const parentMenubar = store.menubar;
const hasParentMenu = !!parentMenu;
const id3 = useId(props.id);
const onKeyDownProp = props.onKeyDown;
const dir = store.useState(
(state) => state.placement.split("-")[0]
);
const orientation = store.useState(
(state) => state.orientation === "both" ? void 0 : state.orientation
);
const isHorizontal = orientation !== "vertical";
const isMenubarHorizontal = useStoreState(
parentMenubar,
(state) => !!state && state.orientation !== "vertical"
);
const onKeyDown = useEvent((event) => {
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (event.defaultPrevented) return;
if (hasParentMenu || parentMenubar && !isHorizontal) {
const hideMap = {
ArrowRight: () => dir === "left" && !isHorizontal,
ArrowLeft: () => dir === "right" && !isHorizontal,
ArrowUp: () => dir === "bottom" && isHorizontal,
ArrowDown: () => dir === "top" && isHorizontal
};
const action = hideMap[event.key];
if (action == null ? void 0 : action()) {
event.stopPropagation();
event.preventDefault();
return store == null ? void 0 : store.hide();
}
}
if (parentMenubar) {
const keyMap = {
ArrowRight: () => {
if (!isMenubarHorizontal) return;
return parentMenubar.next();
},
ArrowLeft: () => {
if (!isMenubarHorizontal) return;
return parentMenubar.previous();
},
ArrowDown: () => {
if (isMenubarHorizontal) return;
return parentMenubar.next();
},
ArrowUp: () => {
if (isMenubarHorizontal) return;
return parentMenubar.previous();
}
};
const action = keyMap[event.key];
const id22 = action == null ? void 0 : action();
if (id22 !== void 0) {
event.stopPropagation();
event.preventDefault();
parentMenubar.move(id22);
}
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime28.jsx)(MenuScopedContextProvider, { value: store, children: element }),
[store]
);
const ariaLabelledBy = useAriaLabelledBy({ store, ...props });
const mounted = store.useState("mounted");
const hidden = isHidden(mounted, props.hidden, alwaysVisible);
const style2 = hidden ? { ...props.style, display: "none" } : props.style;
props = {
id: id3,
"aria-labelledby": ariaLabelledBy,
hidden,
...props,
ref: useMergeRefs(id3 ? store.setContentElement : null, props.ref),
style: style2,
onKeyDown
};
const hasCombobox = !!store.combobox;
composite = composite != null ? composite : !hasCombobox;
if (composite) {
props = {
role: "menu",
"aria-orientation": orientation,
...props
};
}
props = useComposite({ store, composite, ...props });
props = useCompositeTypeahead({ store, typeahead: !hasCombobox, ...props });
return props;
}
);
var MenuList = forwardRef2(function MenuList2(props) {
const htmlProps = useMenuList(props);
return createElement(TagName49, htmlProps);
});
// node_modules/@ariakit/react-core/esm/menu/menu.js
var import_react52 = __toESM(require_react(), 1);
var TagName50 = "div";
var useMenu = createHook(function useMenu2({
store,
modal: modalProp = false,
portal = !!modalProp,
hideOnEscape = true,
autoFocusOnShow = true,
hideOnHoverOutside,
alwaysVisible,
...props
}) {
const context = useMenuProviderContext();
store = store || context;
invariant(
store,
"Menu must receive a `store` prop or be wrapped in a MenuProvider component."
);
const ref = (0, import_react52.useRef)(null);
const parentMenu = store.parent;
const parentMenubar = store.menubar;
const hasParentMenu = !!parentMenu;
const parentIsMenubar = !!parentMenubar && !hasParentMenu;
props = {
...props,
ref: useMergeRefs(ref, props.ref)
};
const { "aria-labelledby": ariaLabelledBy, ...menuListProps } = useMenuList({
store,
alwaysVisible,
...props
});
props = menuListProps;
const [initialFocusRef, setInitialFocusRef] = (0, import_react52.useState)();
const autoFocusOnShowState = store.useState("autoFocusOnShow");
const initialFocus = store.useState("initialFocus");
const baseElement = store.useState("baseElement");
const items = store.useState("renderedItems");
(0, import_react52.useEffect)(() => {
let cleaning = false;
setInitialFocusRef((prevInitialFocusRef) => {
var _a, _b, _c;
if (cleaning) return;
if (!autoFocusOnShowState) return;
if ((_a = prevInitialFocusRef == null ? void 0 : prevInitialFocusRef.current) == null ? void 0 : _a.isConnected) return prevInitialFocusRef;
const ref2 = (0, import_react52.createRef)();
switch (initialFocus) {
// TODO: Refactor
case "first":
ref2.current = ((_b = items.find((item2) => !item2.disabled && item2.element)) == null ? void 0 : _b.element) || null;
break;
case "last":
ref2.current = ((_c = [...items].reverse().find((item2) => !item2.disabled && item2.element)) == null ? void 0 : _c.element) || null;
break;
default:
ref2.current = baseElement;
}
return ref2;
});
return () => {
cleaning = true;
};
}, [store, autoFocusOnShowState, initialFocus, items, baseElement]);
const modal = hasParentMenu ? false : modalProp;
const mayAutoFocusOnShow = !!autoFocusOnShow;
const canAutoFocusOnShow = !!initialFocusRef || !!props.initialFocus || !!modal;
const contentElement = useStoreState(
store.combobox || store,
"contentElement"
);
const parentContentElement = useStoreState(
(parentMenu == null ? void 0 : parentMenu.combobox) || parentMenu,
"contentElement"
);
const preserveTabOrderAnchor = (0, import_react52.useMemo)(() => {
if (!parentContentElement) return;
if (!contentElement) return;
const role = contentElement.getAttribute("role");
const parentRole = parentContentElement.getAttribute("role");
const parentIsMenuOrMenubar = parentRole === "menu" || parentRole === "menubar";
if (parentIsMenuOrMenubar && role === "menu") return;
return parentContentElement;
}, [contentElement, parentContentElement]);
if (preserveTabOrderAnchor !== void 0) {
props = {
preserveTabOrderAnchor,
...props
};
}
props = useHovercard({
store,
alwaysVisible,
initialFocus: initialFocusRef,
autoFocusOnShow: mayAutoFocusOnShow ? canAutoFocusOnShow && autoFocusOnShow : autoFocusOnShowState || !!modal,
...props,
hideOnEscape(event) {
if (isFalsyBooleanCallback(hideOnEscape, event)) return false;
store == null ? void 0 : store.hideAll();
return true;
},
hideOnHoverOutside(event) {
const disclosureElement = store == null ? void 0 : store.getState().disclosureElement;
const getHideOnHoverOutside = () => {
if (typeof hideOnHoverOutside === "function") {
return hideOnHoverOutside(event);
}
if (hideOnHoverOutside != null) return hideOnHoverOutside;
if (hasParentMenu) return true;
if (!parentIsMenubar) return false;
if (!disclosureElement) return true;
if (hasFocusWithin(disclosureElement)) return false;
return true;
};
if (!getHideOnHoverOutside()) return false;
if (event.defaultPrevented) return true;
if (!hasParentMenu) return true;
if (!disclosureElement) return true;
fireEvent(disclosureElement, "mouseout", event);
if (!hasFocusWithin(disclosureElement)) return true;
requestAnimationFrame(() => {
if (hasFocusWithin(disclosureElement)) return;
store == null ? void 0 : store.hide();
});
return false;
},
modal,
portal,
backdrop: hasParentMenu ? false : props.backdrop
});
props = {
"aria-labelledby": ariaLabelledBy,
...props
};
return props;
});
var Menu = createDialogComponent(
forwardRef2(function Menu2(props) {
const htmlProps = useMenu(props);
return createElement(TagName50, htmlProps);
}),
useMenuProviderContext
);
// node_modules/@ariakit/react-core/esm/menu/menu-button.js
var import_react53 = __toESM(require_react(), 1);
var import_jsx_runtime29 = __toESM(require_jsx_runtime(), 1);
var TagName51 = "button";
function getInitialFocus(event, dir) {
const keyMap = {
ArrowDown: dir === "bottom" || dir === "top" ? "first" : false,
ArrowUp: dir === "bottom" || dir === "top" ? "last" : false,
ArrowRight: dir === "right" ? "first" : false,
ArrowLeft: dir === "left" ? "first" : false
};
return keyMap[event.key];
}
function hasActiveItem(items, excludeElement) {
return !!(items == null ? void 0 : items.some((item2) => {
if (!item2.element) return false;
if (item2.element === excludeElement) return false;
return item2.element.getAttribute("aria-expanded") === "true";
}));
}
var useMenuButton = createHook(
function useMenuButton2({
store,
focusable,
accessibleWhenDisabled,
showOnHover,
...props
}) {
const context = useMenuProviderContext();
store = store || context;
invariant(
store,
"MenuButton must receive a `store` prop or be wrapped in a MenuProvider component."
);
const ref = (0, import_react53.useRef)(null);
const parentMenu = store.parent;
const parentMenubar = store.menubar;
const hasParentMenu = !!parentMenu;
const parentIsMenubar = !!parentMenubar && !hasParentMenu;
const disabled = disabledFromProps(props);
const showMenu = () => {
const trigger = ref.current;
if (!trigger) return;
store == null ? void 0 : store.setDisclosureElement(trigger);
store == null ? void 0 : store.setAnchorElement(trigger);
store == null ? void 0 : store.show();
};
const onFocusProp = props.onFocus;
const onFocus = useEvent((event) => {
onFocusProp == null ? void 0 : onFocusProp(event);
if (disabled) return;
if (event.defaultPrevented) return;
store == null ? void 0 : store.setAutoFocusOnShow(false);
store == null ? void 0 : store.setActiveId(null);
if (!parentMenubar) return;
if (!parentIsMenubar) return;
const { items } = parentMenubar.getState();
if (hasActiveItem(items, event.currentTarget)) {
showMenu();
}
});
const dir = useStoreState(
store,
(state) => state.placement.split("-")[0]
);
const onKeyDownProp = props.onKeyDown;
const onKeyDown = useEvent((event) => {
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (disabled) return;
if (event.defaultPrevented) return;
const initialFocus = getInitialFocus(event, dir);
if (initialFocus) {
event.preventDefault();
showMenu();
store == null ? void 0 : store.setAutoFocusOnShow(true);
store == null ? void 0 : store.setInitialFocus(initialFocus);
}
});
const onClickProp = props.onClick;
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
if (!store) return;
const isKeyboardClick = !event.detail;
const { open } = store.getState();
if (!open || isKeyboardClick) {
if (!hasParentMenu || isKeyboardClick) {
store.setAutoFocusOnShow(true);
}
store.setInitialFocus(isKeyboardClick ? "first" : "container");
}
if (hasParentMenu) {
showMenu();
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(MenuContextProvider, { value: store, children: element }),
[store]
);
if (hasParentMenu) {
props = {
...props,
render: /* @__PURE__ */ (0, import_jsx_runtime29.jsx)(Role.div, { render: props.render })
};
}
const id3 = useId(props.id);
const parentContentElement = useStoreState(
(parentMenu == null ? void 0 : parentMenu.combobox) || parentMenu,
"contentElement"
);
const role = hasParentMenu || parentIsMenubar ? getPopupItemRole(parentContentElement, "menuitem") : void 0;
const contentElement = store.useState("contentElement");
props = {
id: id3,
role,
"aria-haspopup": getPopupRole(contentElement, "menu"),
...props,
ref: useMergeRefs(ref, props.ref),
onFocus,
onKeyDown,
onClick
};
props = useHovercardAnchor({
store,
focusable,
accessibleWhenDisabled,
...props,
showOnHover: (event) => {
const getShowOnHover = () => {
if (typeof showOnHover === "function") return showOnHover(event);
if (showOnHover != null) return showOnHover;
if (hasParentMenu) return true;
if (!parentMenubar) return false;
const { items } = parentMenubar.getState();
return parentIsMenubar && hasActiveItem(items);
};
const canShowOnHover = getShowOnHover();
if (!canShowOnHover) return false;
const parent = parentIsMenubar ? parentMenubar : parentMenu;
if (!parent) return true;
parent.setActiveId(event.currentTarget.id);
return true;
}
});
props = usePopoverDisclosure({
store,
toggleOnClick: !hasParentMenu,
focusable,
accessibleWhenDisabled,
...props
});
props = useCompositeTypeahead({
store,
typeahead: parentIsMenubar,
...props
});
return props;
}
);
var MenuButton = forwardRef2(function MenuButton2(props) {
const htmlProps = useMenuButton(props);
return createElement(TagName51, htmlProps);
});
// node_modules/@ariakit/react-core/esm/menu/menu-group.js
var TagName52 = "div";
var useMenuGroup = createHook(
function useMenuGroup2(props) {
props = useCompositeGroup(props);
return props;
}
);
var MenuGroup = forwardRef2(function MenuGroup2(props) {
const htmlProps = useMenuGroup(props);
return createElement(TagName52, htmlProps);
});
// node_modules/@ariakit/react-core/esm/menu/menu-group-label.js
var TagName53 = "div";
var useMenuGroupLabel = createHook(
function useMenuGroupLabel2(props) {
props = useCompositeGroupLabel(props);
return props;
}
);
var MenuGroupLabel = forwardRef2(function MenuGroupLabel2(props) {
const htmlProps = useMenuGroupLabel(props);
return createElement(TagName53, htmlProps);
});
// node_modules/@ariakit/react-core/esm/__chunks/MOWGOTGG.js
var TagName54 = "div";
function menuHasFocus(baseElement, items, currentTarget) {
var _a;
if (!baseElement) return false;
if (hasFocusWithin(baseElement)) return true;
const expandedItem = items == null ? void 0 : items.find((item2) => {
var _a2;
if (item2.element === currentTarget) return false;
return ((_a2 = item2.element) == null ? void 0 : _a2.getAttribute("aria-expanded")) === "true";
});
const expandedMenuId = (_a = expandedItem == null ? void 0 : expandedItem.element) == null ? void 0 : _a.getAttribute("aria-controls");
if (!expandedMenuId) return false;
const doc = getDocument(baseElement);
const expandedMenu = doc.getElementById(expandedMenuId);
if (!expandedMenu) return false;
if (hasFocusWithin(expandedMenu)) return true;
return !!expandedMenu.querySelector("[role=menuitem][aria-expanded=true]");
}
var useMenuItem = createHook(
function useMenuItem2({
store,
hideOnClick = true,
preventScrollOnKeyDown = true,
focusOnHover,
blurOnHoverEnd,
...props
}) {
const menuContext = useMenuScopedContext(true);
const menubarContext = useMenubarScopedContext();
store = store || menuContext || menubarContext;
invariant(
store,
"MenuItem must be wrapped in a MenuList, Menu or Menubar component"
);
const onClickProp = props.onClick;
const hideOnClickProp = useBooleanEvent(hideOnClick);
const hideMenu = "hideAll" in store ? store.hideAll : void 0;
const isWithinMenu = !!hideMenu;
const onClick = useEvent((event) => {
onClickProp == null ? void 0 : onClickProp(event);
if (event.defaultPrevented) return;
if (isDownloading(event)) return;
if (isOpeningInNewTab(event)) return;
if (!hideMenu) return;
const popupType = event.currentTarget.getAttribute("aria-haspopup");
if (popupType === "menu") return;
if (!hideOnClickProp(event)) return;
hideMenu();
});
const contentElement = useStoreState(
store,
(state) => "contentElement" in state ? state.contentElement : null
);
const role = getPopupItemRole(contentElement, "menuitem");
props = {
role,
...props,
onClick
};
props = useCompositeItem({
store,
preventScrollOnKeyDown,
...props
});
props = useCompositeHover({
store,
...props,
focusOnHover(event) {
const getFocusOnHover = () => {
if (typeof focusOnHover === "function") return focusOnHover(event);
if (focusOnHover != null) return focusOnHover;
return true;
};
if (!store) return false;
if (!getFocusOnHover()) return false;
const { baseElement, items } = store.getState();
if (isWithinMenu) {
if (event.currentTarget.hasAttribute("aria-expanded")) {
event.currentTarget.focus();
}
return true;
}
if (menuHasFocus(baseElement, items, event.currentTarget)) {
event.currentTarget.focus();
return true;
}
return false;
},
blurOnHoverEnd(event) {
if (typeof blurOnHoverEnd === "function") return blurOnHoverEnd(event);
if (blurOnHoverEnd != null) return blurOnHoverEnd;
return isWithinMenu;
}
});
return props;
}
);
var MenuItem = memo2(
forwardRef2(function MenuItem2(props) {
const htmlProps = useMenuItem(props);
return createElement(TagName54, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/menu/menu-item-check.js
var import_react54 = __toESM(require_react(), 1);
var TagName55 = "span";
var useMenuItemCheck = createHook(
function useMenuItemCheck2({ store, checked, ...props }) {
const context = (0, import_react54.useContext)(MenuItemCheckedContext2);
checked = checked != null ? checked : context;
props = useCheckboxCheck({ ...props, checked });
return props;
}
);
var MenuItemCheck = forwardRef2(function MenuItemCheck2(props) {
const htmlProps = useMenuItemCheck(props);
return createElement(TagName55, htmlProps);
});
// node_modules/@ariakit/react-core/esm/menu/menu-item-checkbox.js
var import_react55 = __toESM(require_react(), 1);
var TagName56 = "div";
function getPrimitiveValue2(value) {
if (Array.isArray(value)) {
return value.toString();
}
return value;
}
function getValue(storeValue, value, checked) {
if (value === void 0) {
if (Array.isArray(storeValue)) return storeValue;
return !!checked;
}
const primitiveValue = getPrimitiveValue2(value);
if (!Array.isArray(storeValue)) {
if (checked) {
return primitiveValue;
}
return storeValue === primitiveValue ? false : storeValue;
}
if (checked) {
if (storeValue.includes(primitiveValue)) {
return storeValue;
}
return [...storeValue, primitiveValue];
}
return storeValue.filter((v3) => v3 !== primitiveValue);
}
var useMenuItemCheckbox = createHook(
function useMenuItemCheckbox2({
store,
name,
value,
checked,
defaultChecked: defaultCheckedProp,
hideOnClick = false,
...props
}) {
const context = useMenuScopedContext();
store = store || context;
invariant(
store,
"MenuItemCheckbox must be wrapped in a MenuList or Menu component"
);
const defaultChecked = useInitialValue(defaultCheckedProp);
(0, import_react55.useEffect)(() => {
store == null ? void 0 : store.setValue(name, (prevValue = []) => {
if (!defaultChecked) return prevValue;
return getValue(prevValue, value, true);
});
}, [store, name, value, defaultChecked]);
(0, import_react55.useEffect)(() => {
if (checked === void 0) return;
store == null ? void 0 : store.setValue(name, (prevValue) => {
return getValue(prevValue, value, checked);
});
}, [store, name, value, checked]);
const checkboxStore = useCheckboxStore({
value: store.useState((state) => state.values[name]),
setValue(internalValue) {
store == null ? void 0 : store.setValue(name, () => {
if (checked === void 0) return internalValue;
const nextValue = getValue(internalValue, value, checked);
if (!Array.isArray(nextValue)) return nextValue;
if (!Array.isArray(internalValue)) return nextValue;
if (shallowEqual(internalValue, nextValue)) return internalValue;
return nextValue;
});
}
});
props = {
role: "menuitemcheckbox",
...props
};
props = useCheckbox({
store: checkboxStore,
name,
value,
checked,
...props
});
props = useMenuItem({ store, hideOnClick, ...props });
return props;
}
);
var MenuItemCheckbox = memo2(
forwardRef2(function MenuItemCheckbox2(props) {
const htmlProps = useMenuItemCheckbox(props);
return createElement(TagName56, htmlProps);
})
);
// node_modules/@ariakit/react-core/esm/menu/menu-item-radio.js
var import_react56 = __toESM(require_react(), 1);
var import_jsx_runtime30 = __toESM(require_jsx_runtime(), 1);
var TagName57 = "div";
function getValue2(prevValue, value, checked) {
if (checked === void 0) return prevValue;
if (checked) return value;
return prevValue;
}
var useMenuItemRadio = createHook(
function useMenuItemRadio2({
store,
name,
value,
checked,
onChange: onChangeProp,
hideOnClick = false,
...props
}) {
const context = useMenuScopedContext();
store = store || context;
invariant(
store,
"MenuItemRadio must be wrapped in a MenuList or Menu component"
);
const defaultChecked = useInitialValue(props.defaultChecked);
(0, import_react56.useEffect)(() => {
store == null ? void 0 : store.setValue(name, (prevValue = false) => {
return getValue2(prevValue, value, defaultChecked);
});
}, [store, name, value, defaultChecked]);
(0, import_react56.useEffect)(() => {
if (checked === void 0) return;
store == null ? void 0 : store.setValue(name, (prevValue) => {
return getValue2(prevValue, value, checked);
});
}, [store, name, value, checked]);
const isChecked = store.useState((state) => state.values[name] === value);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0, import_jsx_runtime30.jsx)(MenuItemCheckedContext2.Provider, { value: !!isChecked, children: element }),
[isChecked]
);
props = {
role: "menuitemradio",
...props
};
props = useRadio({
name,
value,
checked: isChecked,
onChange(event) {
onChangeProp == null ? void 0 : onChangeProp(event);
if (event.defaultPrevented) return;
const element = event.currentTarget;
store == null ? void 0 : store.setValue(name, (prevValue) => {
return getValue2(prevValue, value, checked != null ? checked : element.checked);
});
},
...props
});
props = useMenuItem({ store, hideOnClick, ...props });
return props;
}
);
var MenuItemRadio = memo2(
forwardRef2(function MenuItemRadio2(props) {
const htmlProps = useMenuItemRadio(props);
return createElement(TagName57, htmlProps);
})
);
// node_modules/@ariakit/core/esm/menu/menu-store.js
function createMenuStore({
combobox,
parent,
menubar: menubar2,
...props
} = {}) {
const parentIsMenubar = !!menubar2 && !parent;
const store = mergeStore(
props.store,
pick2(parent, ["values"]),
omit2(combobox, [
"arrowElement",
"anchorElement",
"contentElement",
"popoverElement",
"disclosureElement"
])
);
throwOnConflictingProps(props, store);
const syncState = store.getState();
const composite = createCompositeStore({
...props,
store,
orientation: defaultValue(
props.orientation,
syncState.orientation,
"vertical"
)
});
const hovercard = createHovercardStore({
...props,
store,
placement: defaultValue(
props.placement,
syncState.placement,
"bottom-start"
),
timeout: defaultValue(
props.timeout,
syncState.timeout,
parentIsMenubar ? 0 : 150
),
hideTimeout: defaultValue(props.hideTimeout, syncState.hideTimeout, 0)
});
const initialState = {
...composite.getState(),
...hovercard.getState(),
initialFocus: defaultValue(syncState.initialFocus, "container"),
values: defaultValue(
props.values,
syncState.values,
props.defaultValues,
{}
)
};
const menu2 = createStore(initialState, composite, hovercard, store);
setup(
menu2,
() => sync(menu2, ["mounted"], (state) => {
if (state.mounted) return;
menu2.setState("activeId", null);
})
);
setup(
menu2,
() => sync(parent, ["orientation"], (state) => {
menu2.setState(
"placement",
state.orientation === "vertical" ? "right-start" : "bottom-start"
);
})
);
return {
...composite,
...hovercard,
...menu2,
combobox,
parent,
menubar: menubar2,
hideAll: () => {
hovercard.hide();
parent == null ? void 0 : parent.hideAll();
},
setInitialFocus: (value) => menu2.setState("initialFocus", value),
setValues: (values) => menu2.setState("values", values),
setValue: (name, value) => {
if (name === "__proto__") return;
if (name === "constructor") return;
if (Array.isArray(name)) return;
menu2.setState("values", (values) => {
const prevValue = values[name];
const nextValue = applyState(value, prevValue);
if (nextValue === prevValue) return values;
return {
...values,
[name]: nextValue !== void 0 && nextValue
};
});
}
};
}
// node_modules/@ariakit/react-core/esm/__chunks/62CEUOYM.js
function useMenuStoreProps(store, update, props) {
useUpdateEffect(update, [props.combobox, props.parent, props.menubar]);
useStoreProps(store, props, "values", "setValues");
return Object.assign(
useHovercardStoreProps(
useCompositeStoreProps(store, update, props),
update,
props
),
{
combobox: props.combobox,
parent: props.parent,
menubar: props.menubar
}
);
}
function useMenuStore(props = {}) {
const parent = useMenuContext();
const menubar2 = useMenubarContext();
const combobox = useComboboxProviderContext();
props = {
...props,
parent: props.parent !== void 0 ? props.parent : parent,
menubar: props.menubar !== void 0 ? props.menubar : menubar2,
combobox: props.combobox !== void 0 ? props.combobox : combobox
};
const [store, update] = useStore(createMenuStore, props);
return useMenuStoreProps(store, update, props);
}
// node_modules/@ariakit/react-core/esm/menu/menu-separator.js
var TagName58 = "hr";
var useMenuSeparator = createHook(
function useMenuSeparator2({ store, ...props }) {
const context = useMenuContext();
store = store || context;
props = useCompositeSeparator({ store, ...props });
return props;
}
);
var MenuSeparator = forwardRef2(function MenuSeparator2(props) {
const htmlProps = useMenuSeparator(props);
return createElement(TagName58, htmlProps);
});
// packages/components/build-module/composite/index.mjs
var import_i18n = __toESM(require_i18n(), 1);
var import_element8 = __toESM(require_element(), 1);
// packages/components/build-module/composite/context.mjs
var import_element = __toESM(require_element(), 1);
var CompositeContext = (0, import_element.createContext)({});
CompositeContext.displayName = "CompositeContext";
var useCompositeContext2 = () => (0, import_element.useContext)(CompositeContext);
// packages/components/build-module/composite/group.mjs
var import_element2 = __toESM(require_element(), 1);
var import_jsx_runtime31 = __toESM(require_jsx_runtime(), 1);
var CompositeGroup22 = (0, import_element2.forwardRef)(function CompositeGroup3(props, ref) {
const context = useCompositeContext2();
const store = props.store ?? context.store;
return /* @__PURE__ */ (0, import_jsx_runtime31.jsx)(CompositeGroup, {
store,
...props,
ref
});
});
// packages/components/build-module/composite/group-label.mjs
var import_element3 = __toESM(require_element(), 1);
var import_jsx_runtime32 = __toESM(require_jsx_runtime(), 1);
var CompositeGroupLabel22 = (0, import_element3.forwardRef)(function CompositeGroupLabel3(props, ref) {
const context = useCompositeContext2();
const store = props.store ?? context.store;
return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)(CompositeGroupLabel, {
store,
...props,
ref
});
});
// packages/components/build-module/composite/hover.mjs
var import_element4 = __toESM(require_element(), 1);
var import_jsx_runtime33 = __toESM(require_jsx_runtime(), 1);
var CompositeHover22 = (0, import_element4.forwardRef)(function CompositeHover3(props, ref) {
const context = useCompositeContext2();
const store = props.store ?? context.store;
return /* @__PURE__ */ (0, import_jsx_runtime33.jsx)(CompositeHover, {
store,
...props,
ref
});
});
// packages/components/build-module/composite/item.mjs
var import_element5 = __toESM(require_element(), 1);
var import_jsx_runtime34 = __toESM(require_jsx_runtime(), 1);
var CompositeItem22 = (0, import_element5.forwardRef)(function CompositeItem3(props, ref) {
const context = useCompositeContext2();
const store = props.store ?? context.store;
return /* @__PURE__ */ (0, import_jsx_runtime34.jsx)(CompositeItem, {
store,
...props,
ref
});
});
// packages/components/build-module/composite/row.mjs
var import_element6 = __toESM(require_element(), 1);
var import_jsx_runtime35 = __toESM(require_jsx_runtime(), 1);
var CompositeRow22 = (0, import_element6.forwardRef)(function CompositeRow3(props, ref) {
const context = useCompositeContext2();
const store = props.store ?? context.store;
return /* @__PURE__ */ (0, import_jsx_runtime35.jsx)(CompositeRow, {
store,
...props,
ref
});
});
// packages/components/build-module/composite/typeahead.mjs
var import_element7 = __toESM(require_element(), 1);
var import_jsx_runtime36 = __toESM(require_jsx_runtime(), 1);
var CompositeTypeahead22 = (0, import_element7.forwardRef)(function CompositeTypeahead3(props, ref) {
const context = useCompositeContext2();
const store = props.store ?? context.store;
return /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(CompositeTypeahead, {
store,
...props,
ref
});
});
// packages/components/build-module/composite/index.mjs
var import_jsx_runtime37 = __toESM(require_jsx_runtime(), 1);
var Composite22 = Object.assign((0, import_element8.forwardRef)(function Composite3({
// Composite store props
activeId,
defaultActiveId,
setActiveId,
focusLoop = false,
focusWrap = false,
focusShift = false,
virtualFocus = false,
orientation = "both",
rtl: rtl2 = (0, import_i18n.isRTL)(),
// Composite component props
children,
disabled = false,
// Rest props
...props
}, ref) {
const storeProp = props.store;
const internalStore = useCompositeStore({
activeId,
defaultActiveId,
setActiveId,
focusLoop,
focusWrap,
focusShift,
virtualFocus,
orientation,
rtl: rtl2
});
const store = storeProp ?? internalStore;
const contextValue = (0, import_element8.useMemo)(() => ({
store
}), [store]);
return /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(Composite, {
disabled,
store,
...props,
ref,
children: /* @__PURE__ */ (0, import_jsx_runtime37.jsx)(CompositeContext.Provider, {
value: contextValue,
children
})
});
}), {
/**
* Renders a group element for composite items.
*
* @example
* ```jsx
* import { Composite } from '@wordpress/components';
*
* <Composite>
* <Composite.Group>
* <Composite.GroupLabel>Label</Composite.GroupLabel>
* <Composite.Item>Item 1</Composite.Item>
* <Composite.Item>Item 2</Composite.Item>
* </CompositeGroup>
* </Composite>
* ```
*/
Group: Object.assign(CompositeGroup22, {
displayName: "Composite.Group"
}),
/**
* Renders a label in a composite group. This component must be wrapped with
* `Composite.Group` so the `aria-labelledby` prop is properly set on the
* composite group element.
*
* @example
* ```jsx
* import { Composite } from '@wordpress/components';
*
* <Composite>
* <Composite.Group>
* <Composite.GroupLabel>Label</Composite.GroupLabel>
* <Composite.Item>Item 1</Composite.Item>
* <Composite.Item>Item 2</Composite.Item>
* </CompositeGroup>
* </Composite>
* ```
*/
GroupLabel: Object.assign(CompositeGroupLabel22, {
displayName: "Composite.GroupLabel"
}),
/**
* Renders a composite item.
*
* @example
* ```jsx
* import { Composite } from '@wordpress/components';
*
* <Composite>
* <Composite.Item>Item 1</Composite.Item>
* <Composite.Item>Item 2</Composite.Item>
* <Composite.Item>Item 3</Composite.Item>
* </Composite>
* ```
*/
Item: Object.assign(CompositeItem22, {
displayName: "Composite.Item"
}),
/**
* Renders a composite row. Wrapping `Composite.Item` elements within
* `Composite.Row` will create a two-dimensional composite widget, such as a
* grid.
*
* @example
* ```jsx
* import { Composite } from '@wordpress/components';
*
* <Composite>
* <Composite.Row>
* <Composite.Item>Item 1.1</Composite.Item>
* <Composite.Item>Item 1.2</Composite.Item>
* <Composite.Item>Item 1.3</Composite.Item>
* </Composite.Row>
* <Composite.Row>
* <Composite.Item>Item 2.1</Composite.Item>
* <Composite.Item>Item 2.2</Composite.Item>
* <Composite.Item>Item 2.3</Composite.Item>
* </Composite.Row>
* </Composite>
* ```
*/
Row: Object.assign(CompositeRow22, {
displayName: "Composite.Row"
}),
/**
* Renders an element in a composite widget that receives focus on mouse move
* and loses focus to the composite base element on mouse leave. This should
* be combined with the `Composite.Item` component.
*
* @example
* ```jsx
* import { Composite } from '@wordpress/components';
*
* <Composite>
* <Composite.Hover render={ <Composite.Item /> }>
* Item 1
* </Composite.Hover>
* <Composite.Hover render={ <Composite.Item /> }>
* Item 2
* </Composite.Hover>
* </Composite>
* ```
*/
Hover: Object.assign(CompositeHover22, {
displayName: "Composite.Hover"
}),
/**
* Renders a component that adds typeahead functionality to composite
* components. Hitting printable character keys will move focus to the next
* composite item that begins with the input characters.
*
* @example
* ```jsx
* import { Composite } from '@wordpress/components';
*
* <Composite render={ <CompositeTypeahead /> }>
* <Composite.Item>Item 1</Composite.Item>
* <Composite.Item>Item 2</Composite.Item>
* </Composite>
* ```
*/
Typeahead: Object.assign(CompositeTypeahead22, {
displayName: "Composite.Typeahead"
}),
/**
* The React context used by the composite components. It can be used by
* to access the composite store, and to forward the context when composite
* sub-components are rendered across portals (ie. `SlotFill` components)
* that would not otherwise forward the context to the `Fill` children.
*
* @example
* ```jsx
* import { Composite } from '@wordpress/components';
* import { useContext } from '@wordpress/element';
*
* const compositeContext = useContext( Composite.Context );
* ```
*/
Context: Object.assign(CompositeContext, {
displayName: "Composite.Context"
})
});
// packages/components/build-module/tooltip/index.mjs
var import_compose = __toESM(require_compose(), 1);
var import_element14 = __toESM(require_element(), 1);
var import_deprecated = __toESM(require_deprecated(), 1);
// packages/components/build-module/shortcut/index.mjs
var import_jsx_runtime38 = __toESM(require_jsx_runtime(), 1);
function Shortcut(props) {
const {
shortcut,
className: className2
} = props;
if (!shortcut) {
return null;
}
let displayText;
let ariaLabel;
if (typeof shortcut === "string") {
displayText = shortcut;
}
if (shortcut !== null && typeof shortcut === "object") {
displayText = shortcut.display;
ariaLabel = shortcut.ariaLabel;
}
return /* @__PURE__ */ (0, import_jsx_runtime38.jsx)("span", {
className: className2,
"aria-label": ariaLabel,
children: displayText
});
}
var shortcut_default = Shortcut;
// packages/components/node_modules/framer-motion/dist/es/utils/warn-once.mjs
var warned = /* @__PURE__ */ new Set();
function warnOnce(condition, message2, element) {
if (condition || warned.has(message2))
return;
console.warn(message2);
if (element)
console.warn(element);
warned.add(message2);
}
// packages/components/node_modules/framer-motion/dist/es/render/components/create-proxy.mjs
function createDOMMotionComponentProxy(componentFactory) {
if (typeof Proxy === "undefined") {
return componentFactory;
}
const componentCache = /* @__PURE__ */ new Map();
const deprecatedFactoryFunction = (...args) => {
if (true) {
warnOnce(false, "motion() is deprecated. Use motion.create() instead.");
}
return componentFactory(...args);
};
return new Proxy(deprecatedFactoryFunction, {
/**
* Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
* The prop name is passed through as `key` and we can use that to generate a `motion`
* DOM component with that name.
*/
get: (_target, key) => {
if (key === "create")
return componentFactory;
if (!componentCache.has(key)) {
componentCache.set(key, componentFactory(key));
}
return componentCache.get(key);
}
});
}
// packages/components/node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs
function isAnimationControls(v3) {
return v3 !== null && typeof v3 === "object" && typeof v3.start === "function";
}
// packages/components/node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs
var isKeyframesTarget = (v3) => {
return Array.isArray(v3);
};
// packages/components/node_modules/framer-motion/dist/es/utils/shallow-compare.mjs
function shallowCompare(next2, prev2) {
if (!Array.isArray(prev2))
return false;
const prevLength = prev2.length;
if (prevLength !== next2.length)
return false;
for (let i3 = 0; i3 < prevLength; i3++) {
if (prev2[i3] !== next2[i3])
return false;
}
return true;
}
// packages/components/node_modules/framer-motion/dist/es/render/utils/is-variant-label.mjs
function isVariantLabel(v3) {
return typeof v3 === "string" || Array.isArray(v3);
}
// packages/components/node_modules/framer-motion/dist/es/render/utils/resolve-variants.mjs
function getValueState(visualElement) {
const state = [{}, {}];
visualElement === null || visualElement === void 0 ? void 0 : visualElement.values.forEach((value, key) => {
state[0][key] = value.get();
state[1][key] = value.getVelocity();
});
return state;
}
function resolveVariantFromProps(props, definition, custom, visualElement) {
if (typeof definition === "function") {
const [current, velocity] = getValueState(visualElement);
definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
}
if (typeof definition === "string") {
definition = props.variants && props.variants[definition];
}
if (typeof definition === "function") {
const [current, velocity] = getValueState(visualElement);
definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
}
return definition;
}
// packages/components/node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs
function resolveVariant(visualElement, definition, custom) {
const props = visualElement.getProps();
return resolveVariantFromProps(props, definition, custom !== void 0 ? custom : props.custom, visualElement);
}
// packages/components/node_modules/framer-motion/dist/es/render/utils/variant-props.mjs
var variantPriorityOrder = [
"animate",
"whileInView",
"whileFocus",
"whileHover",
"whileTap",
"whileDrag",
"exit"
];
var variantProps = ["initial", ...variantPriorityOrder];
// packages/components/node_modules/framer-motion/dist/es/render/html/utils/transform.mjs
var transformPropOrder = [
"transformPerspective",
"x",
"y",
"z",
"translateX",
"translateY",
"translateZ",
"scale",
"scaleX",
"scaleY",
"rotate",
"rotateX",
"rotateY",
"rotateZ",
"skew",
"skewX",
"skewY"
];
var transformProps = new Set(transformPropOrder);
// packages/components/node_modules/framer-motion/dist/es/utils/time-conversion.mjs
var secondsToMilliseconds = (seconds) => seconds * 1e3;
var millisecondsToSeconds = (milliseconds) => milliseconds / 1e3;
// packages/components/node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs
var underDampedSpring = {
type: "spring",
stiffness: 500,
damping: 25,
restSpeed: 10
};
var criticallyDampedSpring = (target) => ({
type: "spring",
stiffness: 550,
damping: target === 0 ? 2 * Math.sqrt(550) : 30,
restSpeed: 10
});
var keyframesTransition = {
type: "keyframes",
duration: 0.8
};
var ease = {
type: "keyframes",
ease: [0.25, 0.1, 0.35, 1],
duration: 0.3
};
var getDefaultTransition = (valueKey, { keyframes: keyframes4 }) => {
if (keyframes4.length > 2) {
return keyframesTransition;
} else if (transformProps.has(valueKey)) {
return valueKey.startsWith("scale") ? criticallyDampedSpring(keyframes4[1]) : underDampedSpring;
}
return ease;
};
// packages/components/node_modules/framer-motion/dist/es/animation/utils/get-value-transition.mjs
function getValueTransition(transition, key) {
return transition ? transition[key] || transition["default"] || transition : void 0;
}
// packages/components/node_modules/framer-motion/dist/es/utils/GlobalConfig.mjs
var MotionGlobalConfig = {
skipAnimations: false,
useManualTiming: false
};
// packages/components/node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs
var instantAnimationState = {
current: false
};
// packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs
var isNotNull = (value) => value !== null;
function getFinalKeyframe(keyframes4, { repeat, repeatType = "loop" }, finalKeyframe) {
const resolvedKeyframes = keyframes4.filter(isNotNull);
const index2 = repeat && repeatType !== "loop" && repeat % 2 === 1 ? 0 : resolvedKeyframes.length - 1;
return !index2 || finalKeyframe === void 0 ? resolvedKeyframes[index2] : finalKeyframe;
}
// node_modules/motion-utils/dist/es/noop.mjs
var noop2 = (any) => any;
// node_modules/motion-utils/dist/es/errors.mjs
var warning = noop2;
var invariant2 = noop2;
if (true) {
warning = (check, message2) => {
if (!check && typeof console !== "undefined") {
console.warn(message2);
}
};
invariant2 = (check, message2) => {
if (!check) {
throw new Error(message2);
}
};
}
// packages/components/node_modules/framer-motion/dist/es/frameloop/render-step.mjs
function createRenderStep(runNextFrame) {
let thisFrame = /* @__PURE__ */ new Set();
let nextFrame = /* @__PURE__ */ new Set();
let isProcessing = false;
let flushNextFrame = false;
const toKeepAlive = /* @__PURE__ */ new WeakSet();
let latestFrameData = {
delta: 0,
timestamp: 0,
isProcessing: false
};
function triggerCallback(callback) {
if (toKeepAlive.has(callback)) {
step.schedule(callback);
runNextFrame();
}
callback(latestFrameData);
}
const step = {
/**
* Schedule a process to run on the next frame.
*/
schedule: (callback, keepAlive = false, immediate = false) => {
const addToCurrentFrame = immediate && isProcessing;
const queue = addToCurrentFrame ? thisFrame : nextFrame;
if (keepAlive)
toKeepAlive.add(callback);
if (!queue.has(callback))
queue.add(callback);
return callback;
},
/**
* Cancel the provided callback from running on the next frame.
*/
cancel: (callback) => {
nextFrame.delete(callback);
toKeepAlive.delete(callback);
},
/**
* Execute all schedule callbacks.
*/
process: (frameData2) => {
latestFrameData = frameData2;
if (isProcessing) {
flushNextFrame = true;
return;
}
isProcessing = true;
[thisFrame, nextFrame] = [nextFrame, thisFrame];
thisFrame.forEach(triggerCallback);
thisFrame.clear();
isProcessing = false;
if (flushNextFrame) {
flushNextFrame = false;
step.process(frameData2);
}
}
};
return step;
}
// packages/components/node_modules/framer-motion/dist/es/frameloop/batcher.mjs
var stepsOrder = [
"read",
// Read
"resolveKeyframes",
// Write/Read/Write/Read
"update",
// Compute
"preRender",
// Compute
"render",
// Write
"postRender"
// Compute
];
var maxElapsed = 40;
function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
let runNextFrame = false;
let useDefaultElapsed = true;
const state = {
delta: 0,
timestamp: 0,
isProcessing: false
};
const flagRunNextFrame = () => runNextFrame = true;
const steps = stepsOrder.reduce((acc, key) => {
acc[key] = createRenderStep(flagRunNextFrame);
return acc;
}, {});
const { read, resolveKeyframes, update, preRender, render, postRender } = steps;
const processBatch = () => {
const timestamp = MotionGlobalConfig.useManualTiming ? state.timestamp : performance.now();
runNextFrame = false;
state.delta = useDefaultElapsed ? 1e3 / 60 : Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
state.timestamp = timestamp;
state.isProcessing = true;
read.process(state);
resolveKeyframes.process(state);
update.process(state);
preRender.process(state);
render.process(state);
postRender.process(state);
state.isProcessing = false;
if (runNextFrame && allowKeepAlive) {
useDefaultElapsed = false;
scheduleNextBatch(processBatch);
}
};
const wake = () => {
runNextFrame = true;
useDefaultElapsed = true;
if (!state.isProcessing) {
scheduleNextBatch(processBatch);
}
};
const schedule = stepsOrder.reduce((acc, key) => {
const step = steps[key];
acc[key] = (process2, keepAlive = false, immediate = false) => {
if (!runNextFrame)
wake();
return step.schedule(process2, keepAlive, immediate);
};
return acc;
}, {});
const cancel = (process2) => {
for (let i3 = 0; i3 < stepsOrder.length; i3++) {
steps[stepsOrder[i3]].cancel(process2);
}
};
return { schedule, cancel, state, steps };
}
// packages/components/node_modules/framer-motion/dist/es/frameloop/frame.mjs
var { schedule: frame, cancel: cancelFrame, state: frameData, steps: frameSteps } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop2, true);
// packages/components/node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs
var calcBezier = (t4, a1, a22) => (((1 - 3 * a22 + 3 * a1) * t4 + (3 * a22 - 6 * a1)) * t4 + 3 * a1) * t4;
var subdivisionPrecision = 1e-7;
var subdivisionMaxIterations = 12;
function binarySubdivide(x2, lowerBound, upperBound, mX1, mX2) {
let currentX;
let currentT;
let i3 = 0;
do {
currentT = lowerBound + (upperBound - lowerBound) / 2;
currentX = calcBezier(currentT, mX1, mX2) - x2;
if (currentX > 0) {
upperBound = currentT;
} else {
lowerBound = currentT;
}
} while (Math.abs(currentX) > subdivisionPrecision && ++i3 < subdivisionMaxIterations);
return currentT;
}
function cubicBezier(mX1, mY1, mX2, mY2) {
if (mX1 === mY1 && mX2 === mY2)
return noop2;
const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);
return (t4) => t4 === 0 || t4 === 1 ? t4 : calcBezier(getTForX(t4), mY1, mY2);
}
// packages/components/node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs
var mirrorEasing = (easing) => (p3) => p3 <= 0.5 ? easing(2 * p3) / 2 : (2 - easing(2 * (1 - p3))) / 2;
// packages/components/node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs
var reverseEasing = (easing) => (p3) => 1 - easing(1 - p3);
// packages/components/node_modules/framer-motion/dist/es/easing/back.mjs
var backOut = /* @__PURE__ */ cubicBezier(0.33, 1.53, 0.69, 0.99);
var backIn = /* @__PURE__ */ reverseEasing(backOut);
var backInOut = /* @__PURE__ */ mirrorEasing(backIn);
// packages/components/node_modules/framer-motion/dist/es/easing/anticipate.mjs
var anticipate = (p3) => (p3 *= 2) < 1 ? 0.5 * backIn(p3) : 0.5 * (2 - Math.pow(2, -10 * (p3 - 1)));
// packages/components/node_modules/framer-motion/dist/es/easing/circ.mjs
var circIn = (p3) => 1 - Math.sin(Math.acos(p3));
var circOut = reverseEasing(circIn);
var circInOut = mirrorEasing(circIn);
// packages/components/node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs
var isZeroValueString = (v3) => /^0[^.\s]+$/u.test(v3);
// packages/components/node_modules/framer-motion/dist/es/animation/utils/is-none.mjs
function isNone(value) {
if (typeof value === "number") {
return value === 0;
} else if (value !== null) {
return value === "none" || value === "0" || isZeroValueString(value);
} else {
return true;
}
}
// packages/components/node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs
var isNumericalString = (v3) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(v3);
// packages/components/node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs
var checkStringStartsWith = (token2) => (key) => typeof key === "string" && key.startsWith(token2);
var isCSSVariableName = /* @__PURE__ */ checkStringStartsWith("--");
var startsAsVariableToken = /* @__PURE__ */ checkStringStartsWith("var(--");
var isCSSVariableToken = (value) => {
const startsWithToken = startsAsVariableToken(value);
if (!startsWithToken)
return false;
return singleCssVariableRegex.test(value.split("/*")[0].trim());
};
var singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
// packages/components/node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs
var splitCSSVariableRegex = (
// eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words
/^var\(--(?:([\w-]+)|([\w-]+), ?([a-zA-Z\d ()%#.,-]+))\)/u
);
function parseCSSVariable(current) {
const match4 = splitCSSVariableRegex.exec(current);
if (!match4)
return [,];
const [, token1, token2, fallback] = match4;
return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, fallback];
}
var maxDepth = 4;
function getVariableValue(current, element, depth = 1) {
invariant2(depth <= maxDepth, `Max CSS variable fallback depth detected in property "${current}". This may indicate a circular fallback dependency.`);
const [token2, fallback] = parseCSSVariable(current);
if (!token2)
return;
const resolved = window.getComputedStyle(element).getPropertyValue(token2);
if (resolved) {
const trimmed = resolved.trim();
return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;
}
return isCSSVariableToken(fallback) ? getVariableValue(fallback, element, depth + 1) : fallback;
}
// packages/components/node_modules/framer-motion/dist/es/utils/clamp.mjs
var clamp2 = (min3, max3, v3) => {
if (v3 > max3)
return max3;
if (v3 < min3)
return min3;
return v3;
};
// packages/components/node_modules/framer-motion/dist/es/value/types/numbers/index.mjs
var number = {
test: (v3) => typeof v3 === "number",
parse: parseFloat,
transform: (v3) => v3
};
var alpha = {
...number,
transform: (v3) => clamp2(0, 1, v3)
};
var scale = {
...number,
default: 1
};
// packages/components/node_modules/framer-motion/dist/es/value/types/numbers/units.mjs
var createUnitType = (unit) => ({
test: (v3) => typeof v3 === "string" && v3.endsWith(unit) && v3.split(" ").length === 1,
parse: parseFloat,
transform: (v3) => `${v3}${unit}`
});
var degrees = /* @__PURE__ */ createUnitType("deg");
var percent = /* @__PURE__ */ createUnitType("%");
var px = /* @__PURE__ */ createUnitType("px");
var vh = /* @__PURE__ */ createUnitType("vh");
var vw = /* @__PURE__ */ createUnitType("vw");
var progressPercentage = {
...percent,
parse: (v3) => percent.parse(v3) / 100,
transform: (v3) => percent.transform(v3 * 100)
};
// packages/components/node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs
var positionalKeys = /* @__PURE__ */ new Set([
"width",
"height",
"top",
"left",
"right",
"bottom",
"x",
"y",
"translateX",
"translateY"
]);
var isNumOrPxType = (v3) => v3 === number || v3 === px;
var getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(", ")[pos]);
var getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {
if (transform === "none" || !transform)
return 0;
const matrix3d = transform.match(/^matrix3d\((.+)\)$/u);
if (matrix3d) {
return getPosFromMatrix(matrix3d[1], pos3);
} else {
const matrix = transform.match(/^matrix\((.+)\)$/u);
if (matrix) {
return getPosFromMatrix(matrix[1], pos2);
} else {
return 0;
}
}
};
var transformKeys = /* @__PURE__ */ new Set(["x", "y", "z"]);
var nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));
function removeNonTranslationalTransform(visualElement) {
const removedTransforms = [];
nonTranslationalTransformKeys.forEach((key) => {
const value = visualElement.getValue(key);
if (value !== void 0) {
removedTransforms.push([key, value.get()]);
value.set(key.startsWith("scale") ? 1 : 0);
}
});
return removedTransforms;
}
var positionalValues = {
// Dimensions
width: ({ x: x2 }, { paddingLeft = "0", paddingRight = "0" }) => x2.max - x2.min - parseFloat(paddingLeft) - parseFloat(paddingRight),
height: ({ y: y3 }, { paddingTop = "0", paddingBottom = "0" }) => y3.max - y3.min - parseFloat(paddingTop) - parseFloat(paddingBottom),
top: (_bbox, { top }) => parseFloat(top),
left: (_bbox, { left }) => parseFloat(left),
bottom: ({ y: y3 }, { top }) => parseFloat(top) + (y3.max - y3.min),
right: ({ x: x2 }, { left }) => parseFloat(left) + (x2.max - x2.min),
// Transform
x: getTranslateFromMatrix(4, 13),
y: getTranslateFromMatrix(5, 14)
};
positionalValues.translateX = positionalValues.x;
positionalValues.translateY = positionalValues.y;
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs
var testValueType = (v3) => (type) => type.test(v3);
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs
var auto = {
test: (v3) => v3 === "auto",
parse: (v3) => v3
};
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs
var dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];
var findDimensionValueType = (v3) => dimensionValueTypes.find(testValueType(v3));
// packages/components/node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs
var toResolve = /* @__PURE__ */ new Set();
var isScheduled = false;
var anyNeedsMeasurement = false;
function measureAllKeyframes() {
if (anyNeedsMeasurement) {
const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);
const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));
const transformsToRestore = /* @__PURE__ */ new Map();
elementsToMeasure.forEach((element) => {
const removedTransforms = removeNonTranslationalTransform(element);
if (!removedTransforms.length)
return;
transformsToRestore.set(element, removedTransforms);
element.render();
});
resolversToMeasure.forEach((resolver) => resolver.measureInitialState());
elementsToMeasure.forEach((element) => {
element.render();
const restore = transformsToRestore.get(element);
if (restore) {
restore.forEach(([key, value]) => {
var _a;
(_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);
});
}
});
resolversToMeasure.forEach((resolver) => resolver.measureEndState());
resolversToMeasure.forEach((resolver) => {
if (resolver.suspendedScrollY !== void 0) {
window.scrollTo(0, resolver.suspendedScrollY);
}
});
}
anyNeedsMeasurement = false;
isScheduled = false;
toResolve.forEach((resolver) => resolver.complete());
toResolve.clear();
}
function readAllKeyframes() {
toResolve.forEach((resolver) => {
resolver.readKeyframes();
if (resolver.needsMeasurement) {
anyNeedsMeasurement = true;
}
});
}
function flushKeyframeResolvers() {
readAllKeyframes();
measureAllKeyframes();
}
var KeyframeResolver = class {
constructor(unresolvedKeyframes, onComplete, name, motionValue2, element, isAsync = false) {
this.isComplete = false;
this.isAsync = false;
this.needsMeasurement = false;
this.isScheduled = false;
this.unresolvedKeyframes = [...unresolvedKeyframes];
this.onComplete = onComplete;
this.name = name;
this.motionValue = motionValue2;
this.element = element;
this.isAsync = isAsync;
}
scheduleResolve() {
this.isScheduled = true;
if (this.isAsync) {
toResolve.add(this);
if (!isScheduled) {
isScheduled = true;
frame.read(readAllKeyframes);
frame.resolveKeyframes(measureAllKeyframes);
}
} else {
this.readKeyframes();
this.complete();
}
}
readKeyframes() {
const { unresolvedKeyframes, name, element, motionValue: motionValue2 } = this;
for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
if (unresolvedKeyframes[i3] === null) {
if (i3 === 0) {
const currentValue = motionValue2 === null || motionValue2 === void 0 ? void 0 : motionValue2.get();
const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
if (currentValue !== void 0) {
unresolvedKeyframes[0] = currentValue;
} else if (element && name) {
const valueAsRead = element.readValue(name, finalKeyframe);
if (valueAsRead !== void 0 && valueAsRead !== null) {
unresolvedKeyframes[0] = valueAsRead;
}
}
if (unresolvedKeyframes[0] === void 0) {
unresolvedKeyframes[0] = finalKeyframe;
}
if (motionValue2 && currentValue === void 0) {
motionValue2.set(unresolvedKeyframes[0]);
}
} else {
unresolvedKeyframes[i3] = unresolvedKeyframes[i3 - 1];
}
}
}
}
setFinalKeyframe() {
}
measureInitialState() {
}
renderEndStyles() {
}
measureEndState() {
}
complete() {
this.isComplete = true;
this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);
toResolve.delete(this);
}
cancel() {
if (!this.isComplete) {
this.isScheduled = false;
toResolve.delete(this);
}
}
resume() {
if (!this.isComplete)
this.scheduleResolve();
}
};
// packages/components/node_modules/framer-motion/dist/es/value/types/utils/sanitize.mjs
var sanitize = (v3) => Math.round(v3 * 1e5) / 1e5;
// packages/components/node_modules/framer-motion/dist/es/value/types/utils/float-regex.mjs
var floatRegex = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
// packages/components/node_modules/framer-motion/dist/es/value/types/utils/is-nullish.mjs
function isNullish(v3) {
return v3 == null;
}
// packages/components/node_modules/framer-motion/dist/es/value/types/utils/single-color-regex.mjs
var singleColorRegex = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu;
// packages/components/node_modules/framer-motion/dist/es/value/types/color/utils.mjs
var isColorString = (type, testProp) => (v3) => {
return Boolean(typeof v3 === "string" && singleColorRegex.test(v3) && v3.startsWith(type) || testProp && !isNullish(v3) && Object.prototype.hasOwnProperty.call(v3, testProp));
};
var splitColor = (aName, bName, cName) => (v3) => {
if (typeof v3 !== "string")
return v3;
const [a3, b3, c3, alpha2] = v3.match(floatRegex);
return {
[aName]: parseFloat(a3),
[bName]: parseFloat(b3),
[cName]: parseFloat(c3),
alpha: alpha2 !== void 0 ? parseFloat(alpha2) : 1
};
};
// packages/components/node_modules/framer-motion/dist/es/value/types/color/rgba.mjs
var clampRgbUnit = (v3) => clamp2(0, 255, v3);
var rgbUnit = {
...number,
transform: (v3) => Math.round(clampRgbUnit(v3))
};
var rgba = {
test: /* @__PURE__ */ isColorString("rgb", "red"),
parse: /* @__PURE__ */ splitColor("red", "green", "blue"),
transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => "rgba(" + rgbUnit.transform(red) + ", " + rgbUnit.transform(green) + ", " + rgbUnit.transform(blue) + ", " + sanitize(alpha.transform(alpha$1)) + ")"
};
// packages/components/node_modules/framer-motion/dist/es/value/types/color/hex.mjs
function parseHex(v3) {
let r4 = "";
let g3 = "";
let b3 = "";
let a3 = "";
if (v3.length > 5) {
r4 = v3.substring(1, 3);
g3 = v3.substring(3, 5);
b3 = v3.substring(5, 7);
a3 = v3.substring(7, 9);
} else {
r4 = v3.substring(1, 2);
g3 = v3.substring(2, 3);
b3 = v3.substring(3, 4);
a3 = v3.substring(4, 5);
r4 += r4;
g3 += g3;
b3 += b3;
a3 += a3;
}
return {
red: parseInt(r4, 16),
green: parseInt(g3, 16),
blue: parseInt(b3, 16),
alpha: a3 ? parseInt(a3, 16) / 255 : 1
};
}
var hex = {
test: /* @__PURE__ */ isColorString("#"),
parse: parseHex,
transform: rgba.transform
};
// packages/components/node_modules/framer-motion/dist/es/value/types/color/hsla.mjs
var hsla = {
test: /* @__PURE__ */ isColorString("hsl", "hue"),
parse: /* @__PURE__ */ splitColor("hue", "saturation", "lightness"),
transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {
return "hsla(" + Math.round(hue) + ", " + percent.transform(sanitize(saturation)) + ", " + percent.transform(sanitize(lightness)) + ", " + sanitize(alpha.transform(alpha$1)) + ")";
}
};
// packages/components/node_modules/framer-motion/dist/es/value/types/color/index.mjs
var color = {
test: (v3) => rgba.test(v3) || hex.test(v3) || hsla.test(v3),
parse: (v3) => {
if (rgba.test(v3)) {
return rgba.parse(v3);
} else if (hsla.test(v3)) {
return hsla.parse(v3);
} else {
return hex.parse(v3);
}
},
transform: (v3) => {
return typeof v3 === "string" ? v3 : v3.hasOwnProperty("red") ? rgba.transform(v3) : hsla.transform(v3);
}
};
// packages/components/node_modules/framer-motion/dist/es/value/types/utils/color-regex.mjs
var colorRegex = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
// packages/components/node_modules/framer-motion/dist/es/value/types/complex/index.mjs
function test(v3) {
var _a, _b;
return isNaN(v3) && typeof v3 === "string" && (((_a = v3.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) + (((_b = v3.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) > 0;
}
var NUMBER_TOKEN = "number";
var COLOR_TOKEN = "color";
var VAR_TOKEN = "var";
var VAR_FUNCTION_TOKEN = "var(";
var SPLIT_TOKEN = "${}";
var complexRegex = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
function analyseComplexValue(value) {
const originalValue = value.toString();
const values = [];
const indexes = {
color: [],
number: [],
var: []
};
const types = [];
let i3 = 0;
const tokenised = originalValue.replace(complexRegex, (parsedValue) => {
if (color.test(parsedValue)) {
indexes.color.push(i3);
types.push(COLOR_TOKEN);
values.push(color.parse(parsedValue));
} else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
indexes.var.push(i3);
types.push(VAR_TOKEN);
values.push(parsedValue);
} else {
indexes.number.push(i3);
types.push(NUMBER_TOKEN);
values.push(parseFloat(parsedValue));
}
++i3;
return SPLIT_TOKEN;
});
const split = tokenised.split(SPLIT_TOKEN);
return { values, split, indexes, types };
}
function parseComplexValue(v3) {
return analyseComplexValue(v3).values;
}
function createTransformer(source) {
const { split, types } = analyseComplexValue(source);
const numSections = split.length;
return (v3) => {
let output = "";
for (let i3 = 0; i3 < numSections; i3++) {
output += split[i3];
if (v3[i3] !== void 0) {
const type = types[i3];
if (type === NUMBER_TOKEN) {
output += sanitize(v3[i3]);
} else if (type === COLOR_TOKEN) {
output += color.transform(v3[i3]);
} else {
output += v3[i3];
}
}
}
return output;
};
}
var convertNumbersToZero = (v3) => typeof v3 === "number" ? 0 : v3;
function getAnimatableNone(v3) {
const parsed = parseComplexValue(v3);
const transformer = createTransformer(v3);
return transformer(parsed.map(convertNumbersToZero));
}
var complex = {
test,
parse: parseComplexValue,
createTransformer,
getAnimatableNone
};
// packages/components/node_modules/framer-motion/dist/es/value/types/complex/filter.mjs
var maxDefaults = /* @__PURE__ */ new Set(["brightness", "contrast", "saturate", "opacity"]);
function applyDefaultFilter(v3) {
const [name, value] = v3.slice(0, -1).split("(");
if (name === "drop-shadow")
return v3;
const [number2] = value.match(floatRegex) || [];
if (!number2)
return v3;
const unit = value.replace(number2, "");
let defaultValue2 = maxDefaults.has(name) ? 1 : 0;
if (number2 !== value)
defaultValue2 *= 100;
return name + "(" + defaultValue2 + unit + ")";
}
var functionRegex = /\b([a-z-]*)\(.*?\)/gu;
var filter = {
...complex,
getAnimatableNone: (v3) => {
const functions = v3.match(functionRegex);
return functions ? functions.map(applyDefaultFilter).join(" ") : v3;
}
};
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/number-browser.mjs
var browserNumberValueTypes = {
// Border props
borderWidth: px,
borderTopWidth: px,
borderRightWidth: px,
borderBottomWidth: px,
borderLeftWidth: px,
borderRadius: px,
radius: px,
borderTopLeftRadius: px,
borderTopRightRadius: px,
borderBottomRightRadius: px,
borderBottomLeftRadius: px,
// Positioning props
width: px,
maxWidth: px,
height: px,
maxHeight: px,
top: px,
right: px,
bottom: px,
left: px,
// Spacing props
padding: px,
paddingTop: px,
paddingRight: px,
paddingBottom: px,
paddingLeft: px,
margin: px,
marginTop: px,
marginRight: px,
marginBottom: px,
marginLeft: px,
// Misc
backgroundPositionX: px,
backgroundPositionY: px
};
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/transform.mjs
var transformValueTypes = {
rotate: degrees,
rotateX: degrees,
rotateY: degrees,
rotateZ: degrees,
scale,
scaleX: scale,
scaleY: scale,
scaleZ: scale,
skew: degrees,
skewX: degrees,
skewY: degrees,
distance: px,
translateX: px,
translateY: px,
translateZ: px,
x: px,
y: px,
z: px,
perspective: px,
transformPerspective: px,
opacity: alpha,
originX: progressPercentage,
originY: progressPercentage,
originZ: px
};
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs
var int = {
...number,
transform: Math.round
};
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs
var numberValueTypes = {
...browserNumberValueTypes,
...transformValueTypes,
zIndex: int,
size: px,
// SVG
fillOpacity: alpha,
strokeOpacity: alpha,
numOctaves: int
};
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs
var defaultValueTypes = {
...numberValueTypes,
// Color props
color,
backgroundColor: color,
outlineColor: color,
fill: color,
stroke: color,
// Border props
borderColor: color,
borderTopColor: color,
borderRightColor: color,
borderBottomColor: color,
borderLeftColor: color,
filter,
WebkitFilter: filter
};
var getDefaultValueType = (key) => defaultValueTypes[key];
// packages/components/node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs
function getAnimatableNone2(key, value) {
let defaultValueType = getDefaultValueType(key);
if (defaultValueType !== filter)
defaultValueType = complex;
return defaultValueType.getAnimatableNone ? defaultValueType.getAnimatableNone(value) : void 0;
}
// packages/components/node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs
var invalidTemplates = /* @__PURE__ */ new Set(["auto", "none", "0"]);
function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
let i3 = 0;
let animatableTemplate = void 0;
while (i3 < unresolvedKeyframes.length && !animatableTemplate) {
const keyframe = unresolvedKeyframes[i3];
if (typeof keyframe === "string" && !invalidTemplates.has(keyframe) && analyseComplexValue(keyframe).values.length) {
animatableTemplate = unresolvedKeyframes[i3];
}
i3++;
}
if (animatableTemplate && name) {
for (const noneIndex of noneKeyframeIndexes) {
unresolvedKeyframes[noneIndex] = getAnimatableNone2(name, animatableTemplate);
}
}
}
// packages/components/node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs
var DOMKeyframesResolver = class extends KeyframeResolver {
constructor(unresolvedKeyframes, onComplete, name, motionValue2, element) {
super(unresolvedKeyframes, onComplete, name, motionValue2, element, true);
}
readKeyframes() {
const { unresolvedKeyframes, element, name } = this;
if (!element || !element.current)
return;
super.readKeyframes();
for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
let keyframe = unresolvedKeyframes[i3];
if (typeof keyframe === "string") {
keyframe = keyframe.trim();
if (isCSSVariableToken(keyframe)) {
const resolved = getVariableValue(keyframe, element.current);
if (resolved !== void 0) {
unresolvedKeyframes[i3] = resolved;
}
if (i3 === unresolvedKeyframes.length - 1) {
this.finalKeyframe = keyframe;
}
}
}
}
this.resolveNoneKeyframes();
if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {
return;
}
const [origin, target] = unresolvedKeyframes;
const originType = findDimensionValueType(origin);
const targetType = findDimensionValueType(target);
if (originType === targetType)
return;
if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {
for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
const value = unresolvedKeyframes[i3];
if (typeof value === "string") {
unresolvedKeyframes[i3] = parseFloat(value);
}
}
} else {
this.needsMeasurement = true;
}
}
resolveNoneKeyframes() {
const { unresolvedKeyframes, name } = this;
const noneKeyframeIndexes = [];
for (let i3 = 0; i3 < unresolvedKeyframes.length; i3++) {
if (isNone(unresolvedKeyframes[i3])) {
noneKeyframeIndexes.push(i3);
}
}
if (noneKeyframeIndexes.length) {
makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);
}
}
measureInitialState() {
const { element, unresolvedKeyframes, name } = this;
if (!element || !element.current)
return;
if (name === "height") {
this.suspendedScrollY = window.pageYOffset;
}
this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
unresolvedKeyframes[0] = this.measuredOrigin;
const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
if (measureKeyframe !== void 0) {
element.getValue(name, measureKeyframe).jump(measureKeyframe, false);
}
}
measureEndState() {
var _a;
const { element, name, unresolvedKeyframes } = this;
if (!element || !element.current)
return;
const value = element.getValue(name);
value && value.jump(this.measuredOrigin, false);
const finalKeyframeIndex = unresolvedKeyframes.length - 1;
const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];
unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));
if (finalKeyframe !== null && this.finalKeyframe === void 0) {
this.finalKeyframe = finalKeyframe;
}
if ((_a = this.removedTransforms) === null || _a === void 0 ? void 0 : _a.length) {
this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {
element.getValue(unsetTransformName).set(unsetTransformValue);
});
}
this.resolveNoneKeyframes();
}
};
// packages/components/node_modules/framer-motion/dist/es/animation/generators/utils/is-generator.mjs
function isGenerator(type) {
return typeof type === "function";
}
// packages/components/node_modules/framer-motion/dist/es/frameloop/sync-time.mjs
var now;
function clearTime() {
now = void 0;
}
var time = {
now: () => {
if (now === void 0) {
time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming ? frameData.timestamp : performance.now());
}
return now;
},
set: (newTime) => {
now = newTime;
queueMicrotask(clearTime);
}
};
// packages/components/node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs
var isAnimatable = (value, name) => {
if (name === "zIndex")
return false;
if (typeof value === "number" || Array.isArray(value))
return true;
if (typeof value === "string" && // It's animatable if we have a string
(complex.test(value) || value === "0") && // And it contains numbers and/or colors
!value.startsWith("url(")) {
return true;
}
return false;
};
// packages/components/node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs
function hasKeyframesChanged(keyframes4) {
const current = keyframes4[0];
if (keyframes4.length === 1)
return true;
for (let i3 = 0; i3 < keyframes4.length; i3++) {
if (keyframes4[i3] !== current)
return true;
}
}
function canAnimate(keyframes4, name, type, velocity) {
const originKeyframe = keyframes4[0];
if (originKeyframe === null)
return false;
if (name === "display" || name === "visibility")
return true;
const targetKeyframe = keyframes4[keyframes4.length - 1];
const isOriginAnimatable = isAnimatable(originKeyframe, name);
const isTargetAnimatable = isAnimatable(targetKeyframe, name);
warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from "${originKeyframe}" to "${targetKeyframe}". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \`style\` property.`);
if (!isOriginAnimatable || !isTargetAnimatable) {
return false;
}
return hasKeyframesChanged(keyframes4) || (type === "spring" || isGenerator(type)) && velocity;
}
// packages/components/node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs
var MAX_RESOLVE_DELAY = 40;
var BaseAnimation = class {
constructor({ autoplay = true, delay: delay2 = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", ...options2 }) {
this.isStopped = false;
this.hasAttemptedResolve = false;
this.createdAt = time.now();
this.options = {
autoplay,
delay: delay2,
type,
repeat,
repeatDelay,
repeatType,
...options2
};
this.updateFinishedPromise();
}
/**
* This method uses the createdAt and resolvedAt to calculate the
* animation startTime. *Ideally*, we would use the createdAt time as t=0
* as the following frame would then be the first frame of the animation in
* progress, which would feel snappier.
*
* However, if there's a delay (main thread work) between the creation of
* the animation and the first commited frame, we prefer to use resolvedAt
* to avoid a sudden jump into the animation.
*/
calcStartTime() {
if (!this.resolvedAt)
return this.createdAt;
return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY ? this.resolvedAt : this.createdAt;
}
/**
* A getter for resolved data. If keyframes are not yet resolved, accessing
* this.resolved will synchronously flush all pending keyframe resolvers.
* This is a deoptimisation, but at its worst still batches read/writes.
*/
get resolved() {
if (!this._resolved && !this.hasAttemptedResolve) {
flushKeyframeResolvers();
}
return this._resolved;
}
/**
* A method to be called when the keyframes resolver completes. This method
* will check if its possible to run the animation and, if not, skip it.
* Otherwise, it will call initPlayback on the implementing class.
*/
onKeyframesResolved(keyframes4, finalKeyframe) {
this.resolvedAt = time.now();
this.hasAttemptedResolve = true;
const { name, type, velocity, delay: delay2, onComplete, onUpdate, isGenerator: isGenerator2 } = this.options;
if (!isGenerator2 && !canAnimate(keyframes4, name, type, velocity)) {
if (instantAnimationState.current || !delay2) {
onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(getFinalKeyframe(keyframes4, this.options, finalKeyframe));
onComplete === null || onComplete === void 0 ? void 0 : onComplete();
this.resolveFinishedPromise();
return;
} else {
this.options.duration = 0;
}
}
const resolvedAnimation = this.initPlayback(keyframes4, finalKeyframe);
if (resolvedAnimation === false)
return;
this._resolved = {
keyframes: keyframes4,
finalKeyframe,
...resolvedAnimation
};
this.onPostResolved();
}
onPostResolved() {
}
/**
* Allows the returned animation to be awaited or promise-chained. Currently
* resolves when the animation finishes at all but in a future update could/should
* reject if its cancels.
*/
then(resolve, reject) {
return this.currentFinishedPromise.then(resolve, reject);
}
flatten() {
this.options.type = "keyframes";
this.options.ease = "linear";
}
updateFinishedPromise() {
this.currentFinishedPromise = new Promise((resolve) => {
this.resolveFinishedPromise = resolve;
});
}
};
// packages/components/node_modules/framer-motion/dist/es/utils/progress.mjs
var progress = (from2, to, value) => {
const toFromDifference = to - from2;
return toFromDifference === 0 ? 1 : (value - from2) / toFromDifference;
};
// packages/components/node_modules/framer-motion/dist/es/animation/animators/waapi/utils/linear.mjs
var generateLinearEasing = (easing, duration, resolution = 10) => {
let points = "";
const numPoints = Math.max(Math.round(duration / resolution), 2);
for (let i3 = 0; i3 < numPoints; i3++) {
points += easing(progress(0, numPoints - 1, i3)) + ", ";
}
return `linear(${points.substring(0, points.length - 2)})`;
};
// packages/components/node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs
function velocityPerSecond(velocity, frameDuration) {
return frameDuration ? velocity * (1e3 / frameDuration) : 0;
}
// packages/components/node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs
var velocitySampleDuration = 5;
function calcGeneratorVelocity(resolveValue, t4, current) {
const prevT = Math.max(t4 - velocitySampleDuration, 0);
return velocityPerSecond(current - resolveValue(prevT), t4 - prevT);
}
// packages/components/node_modules/framer-motion/dist/es/animation/generators/spring/defaults.mjs
var springDefaults = {
// Default spring physics
stiffness: 100,
damping: 10,
mass: 1,
velocity: 0,
// Default duration/bounce-based options
duration: 800,
// in ms
bounce: 0.3,
visualDuration: 0.3,
// in seconds
// Rest thresholds
restSpeed: {
granular: 0.01,
default: 2
},
restDelta: {
granular: 5e-3,
default: 0.5
},
// Limits
minDuration: 0.01,
// in seconds
maxDuration: 10,
// in seconds
minDamping: 0.05,
maxDamping: 1
};
// packages/components/node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs
var safeMin = 1e-3;
function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
let envelope;
let derivative;
warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less");
let dampingRatio = 1 - bounce;
dampingRatio = clamp2(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
duration = clamp2(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));
if (dampingRatio < 1) {
envelope = (undampedFreq2) => {
const exponentialDecay = undampedFreq2 * dampingRatio;
const delta = exponentialDecay * duration;
const a3 = exponentialDecay - velocity;
const b3 = calcAngularFreq(undampedFreq2, dampingRatio);
const c3 = Math.exp(-delta);
return safeMin - a3 / b3 * c3;
};
derivative = (undampedFreq2) => {
const exponentialDecay = undampedFreq2 * dampingRatio;
const delta = exponentialDecay * duration;
const d3 = delta * velocity + velocity;
const e3 = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq2, 2) * duration;
const f3 = Math.exp(-delta);
const g3 = calcAngularFreq(Math.pow(undampedFreq2, 2), dampingRatio);
const factor = -envelope(undampedFreq2) + safeMin > 0 ? -1 : 1;
return factor * ((d3 - e3) * f3) / g3;
};
} else {
envelope = (undampedFreq2) => {
const a3 = Math.exp(-undampedFreq2 * duration);
const b3 = (undampedFreq2 - velocity) * duration + 1;
return -safeMin + a3 * b3;
};
derivative = (undampedFreq2) => {
const a3 = Math.exp(-undampedFreq2 * duration);
const b3 = (velocity - undampedFreq2) * (duration * duration);
return a3 * b3;
};
}
const initialGuess = 5 / duration;
const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
duration = secondsToMilliseconds(duration);
if (isNaN(undampedFreq)) {
return {
stiffness: springDefaults.stiffness,
damping: springDefaults.damping,
duration
};
} else {
const stiffness = Math.pow(undampedFreq, 2) * mass;
return {
stiffness,
damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
duration
};
}
}
var rootIterations = 12;
function approximateRoot(envelope, derivative, initialGuess) {
let result = initialGuess;
for (let i3 = 1; i3 < rootIterations; i3++) {
result = result - envelope(result) / derivative(result);
}
return result;
}
function calcAngularFreq(undampedFreq, dampingRatio) {
return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
}
// packages/components/node_modules/framer-motion/dist/es/animation/generators/utils/calc-duration.mjs
var maxGeneratorDuration = 2e4;
function calcGeneratorDuration(generator) {
let duration = 0;
const timeStep = 50;
let state = generator.next(duration);
while (!state.done && duration < maxGeneratorDuration) {
duration += timeStep;
state = generator.next(duration);
}
return duration >= maxGeneratorDuration ? Infinity : duration;
}
// packages/components/node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs
var durationKeys = ["duration", "bounce"];
var physicsKeys = ["stiffness", "damping", "mass"];
function isSpringType(options2, keys) {
return keys.some((key) => options2[key] !== void 0);
}
function getSpringOptions(options2) {
let springOptions = {
velocity: springDefaults.velocity,
stiffness: springDefaults.stiffness,
damping: springDefaults.damping,
mass: springDefaults.mass,
isResolvedFromDuration: false,
...options2
};
if (!isSpringType(options2, physicsKeys) && isSpringType(options2, durationKeys)) {
if (options2.visualDuration) {
const visualDuration = options2.visualDuration;
const root = 2 * Math.PI / (visualDuration * 1.2);
const stiffness = root * root;
const damping = 2 * clamp2(0.05, 1, 1 - options2.bounce) * Math.sqrt(stiffness);
springOptions = {
...springOptions,
mass: springDefaults.mass,
stiffness,
damping
};
} else {
const derived = findSpring(options2);
springOptions = {
...springOptions,
...derived,
mass: springDefaults.mass
};
springOptions.isResolvedFromDuration = true;
}
}
return springOptions;
}
function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
const options2 = typeof optionsOrVisualDuration !== "object" ? {
visualDuration: optionsOrVisualDuration,
keyframes: [0, 1],
bounce
} : optionsOrVisualDuration;
let { restSpeed, restDelta } = options2;
const origin = options2.keyframes[0];
const target = options2.keyframes[options2.keyframes.length - 1];
const state = { done: false, value: origin };
const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
...options2,
velocity: -millisecondsToSeconds(options2.velocity || 0)
});
const initialVelocity = velocity || 0;
const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
const initialDelta = target - origin;
const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
const isGranularScale = Math.abs(initialDelta) < 5;
restSpeed || (restSpeed = isGranularScale ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default);
restDelta || (restDelta = isGranularScale ? springDefaults.restDelta.granular : springDefaults.restDelta.default);
let resolveSpring;
if (dampingRatio < 1) {
const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
resolveSpring = (t4) => {
const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t4);
return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq * Math.sin(angularFreq * t4) + initialDelta * Math.cos(angularFreq * t4));
};
} else if (dampingRatio === 1) {
resolveSpring = (t4) => target - Math.exp(-undampedAngularFreq * t4) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t4);
} else {
const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
resolveSpring = (t4) => {
const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t4);
const freqForT = Math.min(dampedAngularFreq * t4, 300);
return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
};
}
const generator = {
calculatedDuration: isResolvedFromDuration ? duration || null : null,
next: (t4) => {
const current = resolveSpring(t4);
if (!isResolvedFromDuration) {
let currentVelocity = 0;
if (dampingRatio < 1) {
currentVelocity = t4 === 0 ? secondsToMilliseconds(initialVelocity) : calcGeneratorVelocity(resolveSpring, t4, current);
}
const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;
} else {
state.done = t4 >= duration;
}
state.value = state.done ? target : current;
return state;
},
toString: () => {
const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
const easing = generateLinearEasing((progress2) => generator.next(calculatedDuration * progress2).value, calculatedDuration, 30);
return calculatedDuration + "ms " + easing;
}
};
return generator;
}
// packages/components/node_modules/framer-motion/dist/es/animation/generators/inertia.mjs
function inertia({ keyframes: keyframes4, velocity = 0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min: min3, max: max3, restDelta = 0.5, restSpeed }) {
const origin = keyframes4[0];
const state = {
done: false,
value: origin
};
const isOutOfBounds = (v3) => min3 !== void 0 && v3 < min3 || max3 !== void 0 && v3 > max3;
const nearestBoundary = (v3) => {
if (min3 === void 0)
return max3;
if (max3 === void 0)
return min3;
return Math.abs(min3 - v3) < Math.abs(max3 - v3) ? min3 : max3;
};
let amplitude = power * velocity;
const ideal = origin + amplitude;
const target = modifyTarget === void 0 ? ideal : modifyTarget(ideal);
if (target !== ideal)
amplitude = target - origin;
const calcDelta = (t4) => -amplitude * Math.exp(-t4 / timeConstant);
const calcLatest = (t4) => target + calcDelta(t4);
const applyFriction = (t4) => {
const delta = calcDelta(t4);
const latest = calcLatest(t4);
state.done = Math.abs(delta) <= restDelta;
state.value = state.done ? target : latest;
};
let timeReachedBoundary;
let spring$1;
const checkCatchBoundary = (t4) => {
if (!isOutOfBounds(state.value))
return;
timeReachedBoundary = t4;
spring$1 = spring({
keyframes: [state.value, nearestBoundary(state.value)],
velocity: calcGeneratorVelocity(calcLatest, t4, state.value),
// TODO: This should be passing * 1000
damping: bounceDamping,
stiffness: bounceStiffness,
restDelta,
restSpeed
});
};
checkCatchBoundary(0);
return {
calculatedDuration: null,
next: (t4) => {
let hasUpdatedFrame = false;
if (!spring$1 && timeReachedBoundary === void 0) {
hasUpdatedFrame = true;
applyFriction(t4);
checkCatchBoundary(t4);
}
if (timeReachedBoundary !== void 0 && t4 >= timeReachedBoundary) {
return spring$1.next(t4 - timeReachedBoundary);
} else {
!hasUpdatedFrame && applyFriction(t4);
return state;
}
}
};
}
// packages/components/node_modules/framer-motion/dist/es/easing/ease.mjs
var easeIn = /* @__PURE__ */ cubicBezier(0.42, 0, 1, 1);
var easeOut = /* @__PURE__ */ cubicBezier(0, 0, 0.58, 1);
var easeInOut = /* @__PURE__ */ cubicBezier(0.42, 0, 0.58, 1);
// packages/components/node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs
var isEasingArray = (ease2) => {
return Array.isArray(ease2) && typeof ease2[0] !== "number";
};
// packages/components/node_modules/framer-motion/dist/es/easing/utils/is-bezier-definition.mjs
var isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === "number";
// packages/components/node_modules/framer-motion/dist/es/easing/utils/map.mjs
var easingLookup = {
linear: noop2,
easeIn,
easeInOut,
easeOut,
circIn,
circInOut,
circOut,
backIn,
backInOut,
backOut,
anticipate
};
var easingDefinitionToFunction = (definition) => {
if (isBezierDefinition(definition)) {
invariant2(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);
const [x1, y1, x2, y22] = definition;
return cubicBezier(x1, y1, x2, y22);
} else if (typeof definition === "string") {
invariant2(easingLookup[definition] !== void 0, `Invalid easing type '${definition}'`);
return easingLookup[definition];
}
return definition;
};
// packages/components/node_modules/framer-motion/dist/es/utils/pipe.mjs
var combineFunctions = (a3, b3) => (v3) => b3(a3(v3));
var pipe = (...transformers) => transformers.reduce(combineFunctions);
// packages/components/node_modules/framer-motion/dist/es/utils/mix/number.mjs
var mixNumber = (from2, to, progress2) => {
return from2 + (to - from2) * progress2;
};
// packages/components/node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs
function hueToRgb(p3, q2, t4) {
if (t4 < 0)
t4 += 1;
if (t4 > 1)
t4 -= 1;
if (t4 < 1 / 6)
return p3 + (q2 - p3) * 6 * t4;
if (t4 < 1 / 2)
return q2;
if (t4 < 2 / 3)
return p3 + (q2 - p3) * (2 / 3 - t4) * 6;
return p3;
}
function hslaToRgba({ hue, saturation, lightness, alpha: alpha2 }) {
hue /= 360;
saturation /= 100;
lightness /= 100;
let red = 0;
let green = 0;
let blue = 0;
if (!saturation) {
red = green = blue = lightness;
} else {
const q2 = lightness < 0.5 ? lightness * (1 + saturation) : lightness + saturation - lightness * saturation;
const p3 = 2 * lightness - q2;
red = hueToRgb(p3, q2, hue + 1 / 3);
green = hueToRgb(p3, q2, hue);
blue = hueToRgb(p3, q2, hue - 1 / 3);
}
return {
red: Math.round(red * 255),
green: Math.round(green * 255),
blue: Math.round(blue * 255),
alpha: alpha2
};
}
// packages/components/node_modules/framer-motion/dist/es/utils/mix/immediate.mjs
function mixImmediate(a3, b3) {
return (p3) => p3 > 0 ? b3 : a3;
}
// packages/components/node_modules/framer-motion/dist/es/utils/mix/color.mjs
var mixLinearColor = (from2, to, v3) => {
const fromExpo = from2 * from2;
const expo = v3 * (to * to - fromExpo) + fromExpo;
return expo < 0 ? 0 : Math.sqrt(expo);
};
var colorTypes = [hex, rgba, hsla];
var getColorType = (v3) => colorTypes.find((type) => type.test(v3));
function asRGBA(color2) {
const type = getColorType(color2);
warning(Boolean(type), `'${color2}' is not an animatable color. Use the equivalent color code instead.`);
if (!Boolean(type))
return false;
let model = type.parse(color2);
if (type === hsla) {
model = hslaToRgba(model);
}
return model;
}
var mixColor = (from2, to) => {
const fromRGBA = asRGBA(from2);
const toRGBA = asRGBA(to);
if (!fromRGBA || !toRGBA) {
return mixImmediate(from2, to);
}
const blended = { ...fromRGBA };
return (v3) => {
blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v3);
blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v3);
blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v3);
blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v3);
return rgba.transform(blended);
};
};
// packages/components/node_modules/framer-motion/dist/es/utils/mix/visibility.mjs
var invisibleValues = /* @__PURE__ */ new Set(["none", "hidden"]);
function mixVisibility(origin, target) {
if (invisibleValues.has(origin)) {
return (p3) => p3 <= 0 ? origin : target;
} else {
return (p3) => p3 >= 1 ? target : origin;
}
}
// packages/components/node_modules/framer-motion/dist/es/utils/mix/complex.mjs
function mixNumber2(a3, b3) {
return (p3) => mixNumber(a3, b3, p3);
}
function getMixer(a3) {
if (typeof a3 === "number") {
return mixNumber2;
} else if (typeof a3 === "string") {
return isCSSVariableToken(a3) ? mixImmediate : color.test(a3) ? mixColor : mixComplex;
} else if (Array.isArray(a3)) {
return mixArray;
} else if (typeof a3 === "object") {
return color.test(a3) ? mixColor : mixObject;
}
return mixImmediate;
}
function mixArray(a3, b3) {
const output = [...a3];
const numValues = output.length;
const blendValue = a3.map((v3, i3) => getMixer(v3)(v3, b3[i3]));
return (p3) => {
for (let i3 = 0; i3 < numValues; i3++) {
output[i3] = blendValue[i3](p3);
}
return output;
};
}
function mixObject(a3, b3) {
const output = { ...a3, ...b3 };
const blendValue = {};
for (const key in output) {
if (a3[key] !== void 0 && b3[key] !== void 0) {
blendValue[key] = getMixer(a3[key])(a3[key], b3[key]);
}
}
return (v3) => {
for (const key in blendValue) {
output[key] = blendValue[key](v3);
}
return output;
};
}
function matchOrder(origin, target) {
var _a;
const orderedOrigin = [];
const pointers = { color: 0, var: 0, number: 0 };
for (let i3 = 0; i3 < target.values.length; i3++) {
const type = target.types[i3];
const originIndex = origin.indexes[type][pointers[type]];
const originValue = (_a = origin.values[originIndex]) !== null && _a !== void 0 ? _a : 0;
orderedOrigin[i3] = originValue;
pointers[type]++;
}
return orderedOrigin;
}
var mixComplex = (origin, target) => {
const template = complex.createTransformer(target);
const originStats = analyseComplexValue(origin);
const targetStats = analyseComplexValue(target);
const canInterpolate = originStats.indexes.var.length === targetStats.indexes.var.length && originStats.indexes.color.length === targetStats.indexes.color.length && originStats.indexes.number.length >= targetStats.indexes.number.length;
if (canInterpolate) {
if (invisibleValues.has(origin) && !targetStats.values.length || invisibleValues.has(target) && !originStats.values.length) {
return mixVisibility(origin, target);
}
return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);
} else {
warning(true, `Complex values '${origin}' and '${target}' too dif
Showing 512.00 KB of 3.83 MB. Use Edit/Download for full content.
Directory Contents
Dirs: 3 × Files: 133