Server : Apache System : Linux 122.228.205.92.host.secureserver.net 5.14.0-362.18.1.el9_3.x86_64 #1 SMP PREEMPT_DYNAMIC Mon Jan 29 07:05:48 EST 2024 x86_64 User : ondostategov ( 1002) PHP Version : 8.1.33 Disable Function : NONE Directory : /home/ondostategov/public_html/wp-includes/js/dist/ |
/******/ (() => { // webpackBootstrap
/******/ var __webpack_modules__ = ({
/***/ 66:
/***/ ((module) => {
"use strict";
var isMergeableObject = function isMergeableObject(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)
}
// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
function isReactElement(value) {
return value.$$typeof === REACT_ELEMENT_TYPE
}
function emptyTarget(val) {
return Array.isArray(val) ? [] : {}
}
function cloneUnlessOtherwiseSpecified(value, options) {
return (options.clone !== false && options.isMergeableObject(value))
? deepmerge(emptyTarget(value), value, options)
: value
}
function defaultArrayMerge(target, source, options) {
return target.concat(source).map(function(element) {
return cloneUnlessOtherwiseSpecified(element, options)
})
}
function getMergeFunction(key, options) {
if (!options.customMerge) {
return deepmerge
}
var customMerge = options.customMerge(key);
return typeof customMerge === 'function' ? customMerge : deepmerge
}
function getEnumerableOwnPropertySymbols(target) {
return Object.getOwnPropertySymbols
? Object.getOwnPropertySymbols(target).filter(function(symbol) {
return Object.propertyIsEnumerable.call(target, symbol)
})
: []
}
function getKeys(target) {
return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
}
function propertyIsOnObject(object, property) {
try {
return property in object
} catch(_) {
return false
}
}
// Protects from prototype poisoning and unexpected merging up the prototype chain.
function propertyIsUnsafe(target, key) {
return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
}
function mergeObject(target, source, options) {
var destination = {};
if (options.isMergeableObject(target)) {
getKeys(target).forEach(function(key) {
destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
});
}
getKeys(source).forEach(function(key) {
if (propertyIsUnsafe(target, key)) {
return
}
if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
} else {
destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
}
});
return destination
}
function deepmerge(target, source, options) {
options = options || {};
options.arrayMerge = options.arrayMerge || defaultArrayMerge;
options.isMergeableObject = options.isMergeableObject || isMergeableObject;
// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
// implementations can use it. The caller may not replace it.
options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
var sourceIsArray = Array.isArray(source);
var targetIsArray = Array.isArray(target);
var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
if (!sourceAndTargetTypesMatch) {
return cloneUnlessOtherwiseSpecified(source, options)
} else if (sourceIsArray) {
return options.arrayMerge(target, source, options)
} else {
return mergeObject(target, source, options)
}
}
deepmerge.all = function deepmergeAll(array, options) {
if (!Array.isArray(array)) {
throw new Error('first argument should be an array')
}
return array.reduce(function(prev, next) {
return deepmerge(prev, next, options)
}, {})
};
var deepmerge_1 = deepmerge;
module.exports = deepmerge_1;
/***/ }),
/***/ 83:
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
"use strict";
/**
* @license React
* use-sync-external-store-shim.production.js
*
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var React = __webpack_require__(1609);
function is(x, y) {
return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
}
var objectIs = "function" === typeof Object.is ? Object.is : is,
useState = React.useState,
useEffect = React.useEffect,
useLayoutEffect = React.useLayoutEffect,
useDebugValue = React.useDebugValue;
function useSyncExternalStore$2(subscribe, getSnapshot) {
var value = getSnapshot(),
_useState = useState({ inst: { value: value, getSnapshot: getSnapshot } }),
inst = _useState[0].inst,
forceUpdate = _useState[1];
useLayoutEffect(
function () {
inst.value = value;
inst.getSnapshot = getSnapshot;
checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
},
[subscribe, value, getSnapshot]
);
useEffect(
function () {
checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
return subscribe(function () {
checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
});
},
[subscribe]
);
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 !0;
}
}
function useSyncExternalStore$1(subscribe, getSnapshot) {
return getSnapshot();
}
var shim =
"undefined" === typeof window ||
"undefined" === typeof window.document ||
"undefined" === typeof window.document.createElement
? useSyncExternalStore$1
: useSyncExternalStore$2;
exports.useSyncExternalStore =
void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
/***/ }),
/***/ 422:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
if (true) {
module.exports = __webpack_require__(83);
} else {}
/***/ }),
/***/ 1178:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
if (true) {
module.exports = __webpack_require__(2950);
} else {}
/***/ }),
/***/ 1609:
/***/ ((module) => {
"use strict";
module.exports = window["React"];
/***/ }),
/***/ 1880:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
"use strict";
var reactIs = __webpack_require__(1178);
/**
* Copyright 2015, Yahoo! Inc.
* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
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) {
// React v16.11 and below
if (reactIs.isMemo(component)) {
return MEMO_STATICS;
} // React v16.12 and above
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') {
// don't hoist over string (html) components
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 i = 0; i < keys.length; ++i) {
var key = keys[i];
if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
try {
// Avoid failures from read-only properties
defineProperty(targetComponent, key, descriptor);
} catch (e) {}
}
}
}
return targetComponent;
}
module.exports = hoistNonReactStatics;
/***/ }),
/***/ 2950:
/***/ ((__unused_webpack_module, exports) => {
"use strict";
/** @license React v16.13.1
* react-is.production.min.js
*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;
exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};
exports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};
exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;
/***/ }),
/***/ 7734:
/***/ ((module) => {
"use strict";
// do not edit .js files directly - edit src/index.jst
var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
module.exports = function equal(a, b) {
if (a === b) return true;
if (a && b && typeof a == 'object' && typeof b == 'object') {
if (a.constructor !== b.constructor) return false;
var length, i, keys;
if (Array.isArray(a)) {
length = a.length;
if (length != b.length) return false;
for (i = length; i-- !== 0;)
if (!equal(a[i], b[i])) return false;
return true;
}
if ((a instanceof Map) && (b instanceof Map)) {
if (a.size !== b.size) return false;
for (i of a.entries())
if (!b.has(i[0])) return false;
for (i of a.entries())
if (!equal(i[1], b.get(i[0]))) return false;
return true;
}
if ((a instanceof Set) && (b instanceof Set)) {
if (a.size !== b.size) return false;
for (i of a.entries())
if (!b.has(i[0])) return false;
return true;
}
if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
length = a.length;
if (length != b.length) return false;
for (i = length; i-- !== 0;)
if (a[i] !== b[i]) return false;
return true;
}
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length) return false;
for (i = length; i-- !== 0;)
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
for (i = length; i-- !== 0;) {
var key = keys[i];
if (!equal(a[key], b[key])) return false;
}
return true;
}
// true if both NaN, false otherwise
return a!==a && b!==b;
};
/***/ }),
/***/ 8924:
/***/ ((__unused_webpack_module, exports) => {
// Copyright (c) 2014 Rafael Caricio. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var GradientParser = (GradientParser || {});
GradientParser.stringify = (function() {
var visitor = {
'visit_linear-gradient': function(node) {
return visitor.visit_gradient(node);
},
'visit_repeating-linear-gradient': function(node) {
return visitor.visit_gradient(node);
},
'visit_radial-gradient': function(node) {
return visitor.visit_gradient(node);
},
'visit_repeating-radial-gradient': function(node) {
return visitor.visit_gradient(node);
},
'visit_gradient': function(node) {
var orientation = visitor.visit(node.orientation);
if (orientation) {
orientation += ', ';
}
return node.type + '(' + orientation + visitor.visit(node.colorStops) + ')';
},
'visit_shape': function(node) {
var result = node.value,
at = visitor.visit(node.at),
style = visitor.visit(node.style);
if (style) {
result += ' ' + style;
}
if (at) {
result += ' at ' + at;
}
return result;
},
'visit_default-radial': function(node) {
var result = '',
at = visitor.visit(node.at);
if (at) {
result += at;
}
return result;
},
'visit_extent-keyword': function(node) {
var result = node.value,
at = visitor.visit(node.at);
if (at) {
result += ' at ' + at;
}
return result;
},
'visit_position-keyword': function(node) {
return node.value;
},
'visit_position': function(node) {
return visitor.visit(node.value.x) + ' ' + visitor.visit(node.value.y);
},
'visit_%': function(node) {
return node.value + '%';
},
'visit_em': function(node) {
return node.value + 'em';
},
'visit_px': function(node) {
return node.value + 'px';
},
'visit_calc': function(node) {
return 'calc(' + node.value + ')';
},
'visit_literal': function(node) {
return visitor.visit_color(node.value, node);
},
'visit_hex': function(node) {
return visitor.visit_color('#' + node.value, node);
},
'visit_rgb': function(node) {
return visitor.visit_color('rgb(' + node.value.join(', ') + ')', node);
},
'visit_rgba': function(node) {
return visitor.visit_color('rgba(' + node.value.join(', ') + ')', node);
},
'visit_hsl': function(node) {
return visitor.visit_color('hsl(' + node.value[0] + ', ' + node.value[1] + '%, ' + node.value[2] + '%)', node);
},
'visit_hsla': function(node) {
return visitor.visit_color('hsla(' + node.value[0] + ', ' + node.value[1] + '%, ' + node.value[2] + '%, ' + node.value[3] + ')', node);
},
'visit_var': function(node) {
return visitor.visit_color('var(' + node.value + ')', node);
},
'visit_color': function(resultColor, node) {
var result = resultColor,
length = visitor.visit(node.length);
if (length) {
result += ' ' + length;
}
return result;
},
'visit_angular': function(node) {
return node.value + 'deg';
},
'visit_directional': function(node) {
return 'to ' + node.value;
},
'visit_array': function(elements) {
var result = '',
size = elements.length;
elements.forEach(function(element, i) {
result += visitor.visit(element);
if (i < size - 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);
};
})();
// Copyright (c) 2014 Rafael Caricio. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
var GradientParser = (GradientParser || {});
GradientParser.parse = (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: 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() {
// Check for standard CSS3 "to" direction
var sideOrCorner = matchSideOrCorner();
if (sideOrCorner) {
return sideOrCorner;
}
// Check for legacy single keyword direction (e.g., "right", "top")
var legacyDirection = match('position-keyword', tokens.positionKeywords, 1);
if (legacyDirection) {
// For legacy syntax, we convert to the directional type
return {
type: 'directional',
value: legacyDirection.value
};
}
// If neither, check for angle
return matchAngle();
}
function matchSideOrCorner() {
return match('directional', tokens.sideOrCorner, 1);
}
function matchAngle() {
return match('angular', tokens.angleValue, 1) ||
match('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 {
// Check for "at" position first, which is a common browser output format
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 = match('shape', /^(circle)/i, 0);
if (circle) {
circle.style = matchLength() || matchExtentKeyword();
}
return circle;
}
function matchEllipse() {
var ellipse = match('shape', /^(ellipse)/i, 0);
if (ellipse) {
ellipse.style = matchPositioning() || matchDistance() || matchExtentKeyword();
}
return ellipse;
}
function matchExtentKeyword() {
return match('extent-keyword', tokens.extentKeywords, 1);
}
function matchAtPosition() {
if (match('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 color = matchColor();
if (!color) {
error('Expected color definition');
}
color.length = matchDistance();
return color;
}
function matchColor() {
return matchHexColor() ||
matchHSLAColor() ||
matchHSLColor() ||
matchRGBAColor() ||
matchRGBColor() ||
matchVarColor() ||
matchLiteralColor();
}
function matchLiteralColor() {
return match('literal', tokens.literalColor, 0);
}
function matchHexColor() {
return match('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() {
// Check for percentage before trying to parse the hue
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 alpha = matchNumber();
if (!sat || !light) {
error('Expected percentage value for saturation and lightness in HSLA');
}
return {
type: 'hsla',
value: [hue, sat, light, alpha]
};
});
}
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 match('%', tokens.percentageValue, 1) ||
matchPositionKeyword() ||
matchCalc() ||
matchLength();
}
function matchPositionKeyword() {
return match('position-keyword', tokens.positionKeywords, 1);
}
function matchCalc() {
return matchCall(tokens.calcValue, function() {
var openParenCount = 1; // Start with the opening parenthesis from calc(
var i = 0;
// Parse through the content looking for balanced parentheses
while (openParenCount > 0 && i < input.length) {
var char = input.charAt(i);
if (char === '(') {
openParenCount++;
} else if (char === ')') {
openParenCount--;
}
i++;
}
// If we exited because we ran out of input but still have open parentheses, error
if (openParenCount > 0) {
error('Missing closing parenthesis in calc() expression');
}
// Get the content inside the calc() without the last closing paren
var calcContent = input.substring(0, i - 1);
// Consume the calc expression content
consume(i - 1); // -1 because we don't want to consume the closing parenthesis
return {
type: 'calc',
value: calcContent
};
});
}
function matchLength() {
return match('px', tokens.pixelValue, 1) ||
match('em', tokens.emValue, 1);
}
function match(type, pattern, captureIndex) {
var captures = scan(pattern);
if (captures) {
return {
type: 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(size) {
input = input.substr(size);
}
return function(code) {
input = code.toString().trim();
// Remove trailing semicolon if present
if (input.endsWith(';')) {
input = input.slice(0, -1);
}
return getAST();
};
})();
exports.parse = GradientParser.parse;
exports.stringify = GradientParser.stringify;
/***/ }),
/***/ 9664:
/***/ ((module) => {
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __nested_webpack_require_187__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __nested_webpack_require_187__);
/******/
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __nested_webpack_require_187__.m = modules;
/******/
/******/ // expose the module cache
/******/ __nested_webpack_require_187__.c = installedModules;
/******/
/******/ // __webpack_public_path__
/******/ __nested_webpack_require_187__.p = "";
/******/
/******/ // Load entry module and return exports
/******/ return __nested_webpack_require_187__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __nested_webpack_require_1468__) {
module.exports = __nested_webpack_require_1468__(1);
/***/ }),
/* 1 */
/***/ (function(module, exports, __nested_webpack_require_1587__) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _utils = __nested_webpack_require_1587__(2);
Object.defineProperty(exports, 'combineChunks', {
enumerable: true,
get: function get() {
return _utils.combineChunks;
}
});
Object.defineProperty(exports, 'fillInChunks', {
enumerable: true,
get: function get() {
return _utils.fillInChunks;
}
});
Object.defineProperty(exports, 'findAll', {
enumerable: true,
get: function get() {
return _utils.findAll;
}
});
Object.defineProperty(exports, 'findChunks', {
enumerable: true,
get: function get() {
return _utils.findChunks;
}
});
/***/ }),
/* 2 */
/***/ (function(module, exports) {
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
/**
* Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word.
* @return Array of "chunks" (where a Chunk is { start:number, end:number, highlight:boolean })
*/
var findAll = exports.findAll = function findAll(_ref) {
var autoEscape = _ref.autoEscape,
_ref$caseSensitive = _ref.caseSensitive,
caseSensitive = _ref$caseSensitive === undefined ? false : _ref$caseSensitive,
_ref$findChunks = _ref.findChunks,
findChunks = _ref$findChunks === undefined ? defaultFindChunks : _ref$findChunks,
sanitize = _ref.sanitize,
searchWords = _ref.searchWords,
textToHighlight = _ref.textToHighlight;
return fillInChunks({
chunksToHighlight: combineChunks({
chunks: findChunks({
autoEscape: autoEscape,
caseSensitive: caseSensitive,
sanitize: sanitize,
searchWords: searchWords,
textToHighlight: textToHighlight
})
}),
totalLength: textToHighlight ? textToHighlight.length : 0
});
};
/**
* Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks.
* @return {start:number, end:number}[]
*/
var combineChunks = exports.combineChunks = function combineChunks(_ref2) {
var chunks = _ref2.chunks;
chunks = chunks.sort(function (first, second) {
return first.start - second.start;
}).reduce(function (processedChunks, nextChunk) {
// First chunk just goes straight in the array...
if (processedChunks.length === 0) {
return [nextChunk];
} else {
// ... subsequent chunks get checked to see if they overlap...
var prevChunk = processedChunks.pop();
if (nextChunk.start <= prevChunk.end) {
// It may be the case that prevChunk completely surrounds nextChunk, so take the
// largest of the end indeces.
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;
};
/**
* Examine text for any matches.
* If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}).
* @return {start:number, end:number}[]
*/
var defaultFindChunks = function defaultFindChunks(_ref3) {
var autoEscape = _ref3.autoEscape,
caseSensitive = _ref3.caseSensitive,
_ref3$sanitize = _ref3.sanitize,
sanitize = _ref3$sanitize === undefined ? defaultSanitize : _ref3$sanitize,
searchWords = _ref3.searchWords,
textToHighlight = _ref3.textToHighlight;
textToHighlight = sanitize(textToHighlight);
return searchWords.filter(function (searchWord) {
return searchWord;
}) // Remove empty words
.reduce(function (chunks, searchWord) {
searchWord = sanitize(searchWord);
if (autoEscape) {
searchWord = escapeRegExpFn(searchWord);
}
var regex = new RegExp(searchWord, caseSensitive ? 'g' : 'gi');
var match = void 0;
while (match = regex.exec(textToHighlight)) {
var _start = match.index;
var _end = regex.lastIndex;
// We do not return zero-length matches
if (_end > _start) {
chunks.push({ highlight: false, start: _start, end: _end });
}
// Prevent browsers like Firefox from getting stuck in an infinite loop
// See http://www.regexguru.com/2008/04/watch-out-for-zero-length-matches/
if (match.index === regex.lastIndex) {
regex.lastIndex++;
}
}
return chunks;
}, []);
};
// Allow the findChunks to be overridden in findAll,
// but for backwards compatibility we export as the old name
exports.findChunks = defaultFindChunks;
/**
* Given a set of chunks to highlight, create an additional set of chunks
* to represent the bits of text between the highlighted text.
* @param chunksToHighlight {start:number, end:number}[]
* @param totalLength number
* @return {start:number, end:number, highlight:boolean}[]
*/
var fillInChunks = exports.fillInChunks = function fillInChunks(_ref4) {
var chunksToHighlight = _ref4.chunksToHighlight,
totalLength = _ref4.totalLength;
var allChunks = [];
var append = function append(start, end, highlight) {
if (end - start > 0) {
allChunks.push({
start: start,
end: end,
highlight: highlight
});
}
};
if (chunksToHighlight.length === 0) {
append(0, totalLength, false);
} else {
var lastIndex = 0;
chunksToHighlight.forEach(function (chunk) {
append(lastIndex, chunk.start, false);
append(chunk.start, chunk.end, true);
lastIndex = chunk.end;
});
append(lastIndex, totalLength, false);
}
return allChunks;
};
function defaultSanitize(string) {
return string;
}
function escapeRegExpFn(string) {
return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
}
/***/ })
/******/ ]);
/***/ }),
/***/ 9681:
/***/ ((module) => {
var characterMap = {
"À": "A",
"Á": "A",
"Â": "A",
"Ã": "A",
"Ä": "A",
"Å": "A",
"Ấ": "A",
"Ắ": "A",
"Ẳ": "A",
"Ẵ": "A",
"Ặ": "A",
"Æ": "AE",
"Ầ": "A",
"Ằ": "A",
"Ȃ": "A",
"Ả": "A",
"Ạ": "A",
"Ẩ": "A",
"Ẫ": "A",
"Ậ": "A",
"Ç": "C",
"Ḉ": "C",
"È": "E",
"É": "E",
"Ê": "E",
"Ë": "E",
"Ế": "E",
"Ḗ": "E",
"Ề": "E",
"Ḕ": "E",
"Ḝ": "E",
"Ȇ": "E",
"Ẻ": "E",
"Ẽ": "E",
"Ẹ": "E",
"Ể": "E",
"Ễ": "E",
"Ệ": "E",
"Ì": "I",
"Í": "I",
"Î": "I",
"Ï": "I",
"Ḯ": "I",
"Ȋ": "I",
"Ỉ": "I",
"Ị": "I",
"Ð": "D",
"Ñ": "N",
"Ò": "O",
"Ó": "O",
"Ô": "O",
"Õ": "O",
"Ö": "O",
"Ø": "O",
"Ố": "O",
"Ṍ": "O",
"Ṓ": "O",
"Ȏ": "O",
"Ỏ": "O",
"Ọ": "O",
"Ổ": "O",
"Ỗ": "O",
"Ộ": "O",
"Ờ": "O",
"Ở": "O",
"Ỡ": "O",
"Ớ": "O",
"Ợ": "O",
"Ù": "U",
"Ú": "U",
"Û": "U",
"Ü": "U",
"Ủ": "U",
"Ụ": "U",
"Ử": "U",
"Ữ": "U",
"Ự": "U",
"Ý": "Y",
"à": "a",
"á": "a",
"â": "a",
"ã": "a",
"ä": "a",
"å": "a",
"ấ": "a",
"ắ": "a",
"ẳ": "a",
"ẵ": "a",
"ặ": "a",
"æ": "ae",
"ầ": "a",
"ằ": "a",
"ȃ": "a",
"ả": "a",
"ạ": "a",
"ẩ": "a",
"ẫ": "a",
"ậ": "a",
"ç": "c",
"ḉ": "c",
"è": "e",
"é": "e",
"ê": "e",
"ë": "e",
"ế": "e",
"ḗ": "e",
"ề": "e",
"ḕ": "e",
"ḝ": "e",
"ȇ": "e",
"ẻ": "e",
"ẽ": "e",
"ẹ": "e",
"ể": "e",
"ễ": "e",
"ệ": "e",
"ì": "i",
"í": "i",
"î": "i",
"ï": "i",
"ḯ": "i",
"ȋ": "i",
"ỉ": "i",
"ị": "i",
"ð": "d",
"ñ": "n",
"ò": "o",
"ó": "o",
"ô": "o",
"õ": "o",
"ö": "o",
"ø": "o",
"ố": "o",
"ṍ": "o",
"ṓ": "o",
"ȏ": "o",
"ỏ": "o",
"ọ": "o",
"ổ": "o",
"ỗ": "o",
"ộ": "o",
"ờ": "o",
"ở": "o",
"ỡ": "o",
"ớ": "o",
"ợ": "o",
"ù": "u",
"ú": "u",
"û": "u",
"ü": "u",
"ủ": "u",
"ụ": "u",
"ử": "u",
"ữ": "u",
"ự": "u",
"ý": "y",
"ÿ": "y",
"Ā": "A",
"ā": "a",
"Ă": "A",
"ă": "a",
"Ą": "A",
"ą": "a",
"Ć": "C",
"ć": "c",
"Ĉ": "C",
"ĉ": "c",
"Ċ": "C",
"ċ": "c",
"Č": "C",
"č": "c",
"C̆": "C",
"c̆": "c",
"Ď": "D",
"ď": "d",
"Đ": "D",
"đ": "d",
"Ē": "E",
"ē": "e",
"Ĕ": "E",
"ĕ": "e",
"Ė": "E",
"ė": "e",
"Ę": "E",
"ę": "e",
"Ě": "E",
"ě": "e",
"Ĝ": "G",
"Ǵ": "G",
"ĝ": "g",
"ǵ": "g",
"Ğ": "G",
"ğ": "g",
"Ġ": "G",
"ġ": "g",
"Ģ": "G",
"ģ": "g",
"Ĥ": "H",
"ĥ": "h",
"Ħ": "H",
"ħ": "h",
"Ḫ": "H",
"ḫ": "h",
"Ĩ": "I",
"ĩ": "i",
"Ī": "I",
"ī": "i",
"Ĭ": "I",
"ĭ": "i",
"Į": "I",
"į": "i",
"İ": "I",
"ı": "i",
"IJ": "IJ",
"ij": "ij",
"Ĵ": "J",
"ĵ": "j",
"Ķ": "K",
"ķ": "k",
"Ḱ": "K",
"ḱ": "k",
"K̆": "K",
"k̆": "k",
"Ĺ": "L",
"ĺ": "l",
"Ļ": "L",
"ļ": "l",
"Ľ": "L",
"ľ": "l",
"Ŀ": "L",
"ŀ": "l",
"Ł": "l",
"ł": "l",
"Ḿ": "M",
"ḿ": "m",
"M̆": "M",
"m̆": "m",
"Ń": "N",
"ń": "n",
"Ņ": "N",
"ņ": "n",
"Ň": "N",
"ň": "n",
"ʼn": "n",
"N̆": "N",
"n̆": "n",
"Ō": "O",
"ō": "o",
"Ŏ": "O",
"ŏ": "o",
"Ő": "O",
"ő": "o",
"Œ": "OE",
"œ": "oe",
"P̆": "P",
"p̆": "p",
"Ŕ": "R",
"ŕ": "r",
"Ŗ": "R",
"ŗ": "r",
"Ř": "R",
"ř": "r",
"R̆": "R",
"r̆": "r",
"Ȓ": "R",
"ȓ": "r",
"Ś": "S",
"ś": "s",
"Ŝ": "S",
"ŝ": "s",
"Ş": "S",
"Ș": "S",
"ș": "s",
"ş": "s",
"Š": "S",
"š": "s",
"Ţ": "T",
"ţ": "t",
"ț": "t",
"Ț": "T",
"Ť": "T",
"ť": "t",
"Ŧ": "T",
"ŧ": "t",
"T̆": "T",
"t̆": "t",
"Ũ": "U",
"ũ": "u",
"Ū": "U",
"ū": "u",
"Ŭ": "U",
"ŭ": "u",
"Ů": "U",
"ů": "u",
"Ű": "U",
"ű": "u",
"Ų": "U",
"ų": "u",
"Ȗ": "U",
"ȗ": "u",
"V̆": "V",
"v̆": "v",
"Ŵ": "W",
"ŵ": "w",
"Ẃ": "W",
"ẃ": "w",
"X̆": "X",
"x̆": "x",
"Ŷ": "Y",
"ŷ": "y",
"Ÿ": "Y",
"Y̆": "Y",
"y̆": "y",
"Ź": "Z",
"ź": "z",
"Ż": "Z",
"ż": "z",
"Ž": "Z",
"ž": "z",
"ſ": "s",
"ƒ": "f",
"Ơ": "O",
"ơ": "o",
"Ư": "U",
"ư": "u",
"Ǎ": "A",
"ǎ": "a",
"Ǐ": "I",
"ǐ": "i",
"Ǒ": "O",
"ǒ": "o",
"Ǔ": "U",
"ǔ": "u",
"Ǖ": "U",
"ǖ": "u",
"Ǘ": "U",
"ǘ": "u",
"Ǚ": "U",
"ǚ": "u",
"Ǜ": "U",
"ǜ": "u",
"Ứ": "U",
"ứ": "u",
"Ṹ": "U",
"ṹ": "u",
"Ǻ": "A",
"ǻ": "a",
"Ǽ": "AE",
"ǽ": "ae",
"Ǿ": "O",
"ǿ": "o",
"Þ": "TH",
"þ": "th",
"Ṕ": "P",
"ṕ": "p",
"Ṥ": "S",
"ṥ": "s",
"X́": "X",
"x́": "x",
"Ѓ": "Г",
"ѓ": "г",
"Ќ": "К",
"ќ": "к",
"A̋": "A",
"a̋": "a",
"E̋": "E",
"e̋": "e",
"I̋": "I",
"i̋": "i",
"Ǹ": "N",
"ǹ": "n",
"Ồ": "O",
"ồ": "o",
"Ṑ": "O",
"ṑ": "o",
"Ừ": "U",
"ừ": "u",
"Ẁ": "W",
"ẁ": "w",
"Ỳ": "Y",
"ỳ": "y",
"Ȁ": "A",
"ȁ": "a",
"Ȅ": "E",
"ȅ": "e",
"Ȉ": "I",
"ȉ": "i",
"Ȍ": "O",
"ȍ": "o",
"Ȑ": "R",
"ȑ": "r",
"Ȕ": "U",
"ȕ": "u",
"B̌": "B",
"b̌": "b",
"Č̣": "C",
"č̣": "c",
"Ê̌": "E",
"ê̌": "e",
"F̌": "F",
"f̌": "f",
"Ǧ": "G",
"ǧ": "g",
"Ȟ": "H",
"ȟ": "h",
"J̌": "J",
"ǰ": "j",
"Ǩ": "K",
"ǩ": "k",
"M̌": "M",
"m̌": "m",
"P̌": "P",
"p̌": "p",
"Q̌": "Q",
"q̌": "q",
"Ř̩": "R",
"ř̩": "r",
"Ṧ": "S",
"ṧ": "s",
"V̌": "V",
"v̌": "v",
"W̌": "W",
"w̌": "w",
"X̌": "X",
"x̌": "x",
"Y̌": "Y",
"y̌": "y",
"A̧": "A",
"a̧": "a",
"B̧": "B",
"b̧": "b",
"Ḑ": "D",
"ḑ": "d",
"Ȩ": "E",
"ȩ": "e",
"Ɛ̧": "E",
"ɛ̧": "e",
"Ḩ": "H",
"ḩ": "h",
"I̧": "I",
"i̧": "i",
"Ɨ̧": "I",
"ɨ̧": "i",
"M̧": "M",
"m̧": "m",
"O̧": "O",
"o̧": "o",
"Q̧": "Q",
"q̧": "q",
"U̧": "U",
"u̧": "u",
"X̧": "X",
"x̧": "x",
"Z̧": "Z",
"z̧": "z",
"й":"и",
"Й":"И",
"ё":"е",
"Ё":"Е",
};
var chars = Object.keys(characterMap).join('|');
var allAccents = new RegExp(chars, 'g');
var firstAccent = new RegExp(chars, '');
function matcher(match) {
return characterMap[match];
}
var removeAccents = function(string) {
return string.replace(allAccents, matcher);
};
var hasAccents = function(string) {
return !!string.match(firstAccent);
};
module.exports = removeAccents;
module.exports.has = hasAccents;
module.exports.remove = removeAccents;
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/create fake namespace object */
/******/ (() => {
/******/ var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
/******/ var leafPrototypes;
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 16: return value when it's Promise-like
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = this(value);
/******/ if(mode & 8) return value;
/******/ if(typeof value === 'object' && value) {
/******/ if((mode & 4) && value.__esModule) return value;
/******/ if((mode & 16) && typeof value.then === 'function') return value;
/******/ }
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ var def = {};
/******/ leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
/******/ for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
/******/ Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
/******/ }
/******/ def['default'] = () => (value);
/******/ __webpack_require__.d(ns, def);
/******/ return ns;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = (exports) => {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/nonce */
/******/ (() => {
/******/ __webpack_require__.nc = undefined;
/******/ })();
/******/
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
(() => {
"use strict";
// ESM COMPAT FLAG
__webpack_require__.r(__webpack_exports__);
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
AlignmentMatrixControl: () => (/* reexport */ alignment_matrix_control_default),
AnglePickerControl: () => (/* reexport */ angle_picker_control_default),
Animate: () => (/* reexport */ animate_default),
Autocomplete: () => (/* reexport */ Autocomplete),
BaseControl: () => (/* reexport */ base_control_default),
BlockQuotation: () => (/* reexport */ external_wp_primitives_namespaceObject.BlockQuotation),
BorderBoxControl: () => (/* reexport */ border_box_control_component_component_default),
BorderControl: () => (/* reexport */ border_control_component_component_default),
BoxControl: () => (/* reexport */ box_control_default),
Button: () => (/* reexport */ button_default),
ButtonGroup: () => (/* reexport */ button_group_default),
Card: () => (/* reexport */ card_component_component_default),
CardBody: () => (/* reexport */ card_body_component_component_default),
CardDivider: () => (/* reexport */ card_divider_component_component_default),
CardFooter: () => (/* reexport */ card_footer_component_component_default),
CardHeader: () => (/* reexport */ card_header_component_component_default),
CardMedia: () => (/* reexport */ card_media_component_component_default),
CheckboxControl: () => (/* reexport */ checkbox_control_default),
Circle: () => (/* reexport */ external_wp_primitives_namespaceObject.Circle),
ClipboardButton: () => (/* reexport */ ClipboardButton),
ColorIndicator: () => (/* reexport */ color_indicator_default),
ColorPalette: () => (/* reexport */ color_palette_default),
ColorPicker: () => (/* reexport */ LegacyAdapter),
ComboboxControl: () => (/* reexport */ combobox_control_default),
Composite: () => (/* reexport */ composite_Composite),
CustomGradientPicker: () => (/* reexport */ custom_gradient_picker_default),
CustomSelectControl: () => (/* reexport */ custom_select_control_default),
Dashicon: () => (/* reexport */ dashicon_default),
DatePicker: () => (/* reexport */ date_default),
DateTimePicker: () => (/* reexport */ date_time_date_time_default),
Disabled: () => (/* reexport */ disabled_default),
Draggable: () => (/* reexport */ draggable_default),
DropZone: () => (/* reexport */ drop_zone_default),
DropZoneProvider: () => (/* reexport */ DropZoneProvider),
Dropdown: () => (/* reexport */ dropdown_default),
DropdownMenu: () => (/* reexport */ dropdown_menu_default),
DuotonePicker: () => (/* reexport */ duotone_picker_default),
DuotoneSwatch: () => (/* reexport */ duotone_swatch_default),
ExternalLink: () => (/* reexport */ external_link_default),
Fill: () => (/* reexport */ slot_fill_Fill),
Flex: () => (/* reexport */ flex_component_component_default),
FlexBlock: () => (/* reexport */ flex_block_component_component_default),
FlexItem: () => (/* reexport */ flex_item_component_component_default),
FocalPointPicker: () => (/* reexport */ focal_point_picker_default),
FocusReturnProvider: () => (/* reexport */ with_focus_return_Provider),
FocusableIframe: () => (/* reexport */ FocusableIframe),
FontSizePicker: () => (/* reexport */ font_size_picker_default),
FormFileUpload: () => (/* reexport */ form_file_upload_default),
FormToggle: () => (/* reexport */ form_toggle_default),
FormTokenField: () => (/* reexport */ form_token_field_default),
G: () => (/* reexport */ external_wp_primitives_namespaceObject.G),
GradientPicker: () => (/* reexport */ gradient_picker_default),
Guide: () => (/* reexport */ guide_default),
GuidePage: () => (/* reexport */ GuidePage),
HorizontalRule: () => (/* reexport */ external_wp_primitives_namespaceObject.HorizontalRule),
Icon: () => (/* reexport */ icon_icon_default),
IconButton: () => (/* reexport */ deprecated_default),
IsolatedEventContainer: () => (/* reexport */ isolated_event_container_default),
KeyboardShortcuts: () => (/* reexport */ keyboard_shortcuts_default),
Line: () => (/* reexport */ external_wp_primitives_namespaceObject.Line),
MenuGroup: () => (/* reexport */ menu_group_default),
MenuItem: () => (/* reexport */ menu_item_default),
MenuItemsChoice: () => (/* reexport */ menu_items_choice_default),
Modal: () => (/* reexport */ modal_default),
NavigableMenu: () => (/* reexport */ menu_menu_default),
Navigator: () => (/* reexport */ navigator_Navigator),
Notice: () => (/* reexport */ notice_default),
NoticeList: () => (/* reexport */ list_default),
Panel: () => (/* reexport */ panel_default),
PanelBody: () => (/* reexport */ body_default),
PanelHeader: () => (/* reexport */ header_default),
PanelRow: () => (/* reexport */ row_default),
Path: () => (/* reexport */ external_wp_primitives_namespaceObject.Path),
Placeholder: () => (/* reexport */ placeholder_default),
Polygon: () => (/* reexport */ external_wp_primitives_namespaceObject.Polygon),
Popover: () => (/* reexport */ popover_default),
ProgressBar: () => (/* reexport */ progress_bar_default),
QueryControls: () => (/* reexport */ query_controls_default),
RadioControl: () => (/* reexport */ radio_control_default),
RangeControl: () => (/* reexport */ range_control_default),
Rect: () => (/* reexport */ external_wp_primitives_namespaceObject.Rect),
ResizableBox: () => (/* reexport */ resizable_box_default),
ResponsiveWrapper: () => (/* reexport */ responsive_wrapper_default),
SVG: () => (/* reexport */ external_wp_primitives_namespaceObject.SVG),
SandBox: () => (/* reexport */ sandbox_default),
ScrollLock: () => (/* reexport */ scroll_lock_default),
SearchControl: () => (/* reexport */ search_control_default),
SelectControl: () => (/* reexport */ select_control_default),
Slot: () => (/* reexport */ slot_fill_Slot),
SlotFillProvider: () => (/* reexport */ Provider),
Snackbar: () => (/* reexport */ snackbar_default),
SnackbarList: () => (/* reexport */ list_list_default),
Spinner: () => (/* reexport */ spinner_default),
TabPanel: () => (/* reexport */ tab_panel_default),
TabbableContainer: () => (/* reexport */ tabbable_default),
TextControl: () => (/* reexport */ text_control_default),
TextHighlight: () => (/* reexport */ text_highlight_default),
TextareaControl: () => (/* reexport */ textarea_control_default),
TimePicker: () => (/* reexport */ time_default),
Tip: () => (/* reexport */ tip_tip_default),
ToggleControl: () => (/* reexport */ toggle_control_default),
Toolbar: () => (/* reexport */ toolbar_default),
ToolbarButton: () => (/* reexport */ toolbar_button_default),
ToolbarDropdownMenu: () => (/* reexport */ toolbar_dropdown_menu_default),
ToolbarGroup: () => (/* reexport */ toolbar_group_default),
ToolbarItem: () => (/* reexport */ toolbar_item_default),
Tooltip: () => (/* reexport */ tooltip_default),
TreeSelect: () => (/* reexport */ tree_select_default),
VisuallyHidden: () => (/* reexport */ component_component_default),
__experimentalAlignmentMatrixControl: () => (/* reexport */ alignment_matrix_control_default),
__experimentalApplyValueToSides: () => (/* reexport */ applyValueToSides),
__experimentalBorderBoxControl: () => (/* reexport */ border_box_control_component_component_default),
__experimentalBorderControl: () => (/* reexport */ border_control_component_component_default),
__experimentalBoxControl: () => (/* reexport */ box_control_default),
__experimentalConfirmDialog: () => (/* reexport */ confirm_dialog_component_component_default),
__experimentalDimensionControl: () => (/* reexport */ dimension_control_default),
__experimentalDivider: () => (/* reexport */ divider_component_component_default),
__experimentalDropdownContentWrapper: () => (/* reexport */ dropdown_content_wrapper_default),
__experimentalElevation: () => (/* reexport */ elevation_component_component_default),
__experimentalGrid: () => (/* reexport */ grid_component_component_default),
__experimentalHStack: () => (/* reexport */ h_stack_component_component_default),
__experimentalHasSplitBorders: () => (/* reexport */ hasSplitBorders),
__experimentalHeading: () => (/* reexport */ heading_component_component_default),
__experimentalInputControl: () => (/* reexport */ input_control_default),
__experimentalInputControlPrefixWrapper: () => (/* reexport */ input_prefix_wrapper_default),
__experimentalInputControlSuffixWrapper: () => (/* reexport */ input_suffix_wrapper_default),
__experimentalIsDefinedBorder: () => (/* reexport */ isDefinedBorder),
__experimentalIsEmptyBorder: () => (/* reexport */ isEmptyBorder),
__experimentalItem: () => (/* reexport */ item_component_component_default),
__experimentalItemGroup: () => (/* reexport */ item_group_component_component_default),
__experimentalNavigation: () => (/* reexport */ navigation_default),
__experimentalNavigationBackButton: () => (/* reexport */ back_button_default),
__experimentalNavigationGroup: () => (/* reexport */ group_default),
__experimentalNavigationItem: () => (/* reexport */ item_item_default),
__experimentalNavigationMenu: () => (/* reexport */ navigation_menu_menu_default),
__experimentalNavigatorBackButton: () => (/* reexport */ legacy_NavigatorBackButton),
__experimentalNavigatorButton: () => (/* reexport */ legacy_NavigatorButton),
__experimentalNavigatorProvider: () => (/* reexport */ NavigatorProvider),
__experimentalNavigatorScreen: () => (/* reexport */ legacy_NavigatorScreen),
__experimentalNavigatorToParentButton: () => (/* reexport */ legacy_NavigatorToParentButton),
__experimentalNumberControl: () => (/* reexport */ number_control_default),
__experimentalPaletteEdit: () => (/* reexport */ palette_edit_default),
__experimentalParseQuantityAndUnitFromRawValue: () => (/* reexport */ parseQuantityAndUnitFromRawValue),
__experimentalRadio: () => (/* reexport */ radio_default),
__experimentalRadioGroup: () => (/* reexport */ radio_group_default),
__experimentalScrollable: () => (/* reexport */ scrollable_component_component_default),
__experimentalSpacer: () => (/* reexport */ spacer_component_component_default),
__experimentalStyleProvider: () => (/* reexport */ style_provider_default),
__experimentalSurface: () => (/* reexport */ surface_component_component_default),
__experimentalText: () => (/* reexport */ text_component_component_default),
__experimentalToggleGroupControl: () => (/* reexport */ toggle_group_control_component_component_default),
__experimentalToggleGroupControlOption: () => (/* reexport */ toggle_group_control_option_component_component_default),
__experimentalToggleGroupControlOptionIcon: () => (/* reexport */ toggle_group_control_option_icon_component_component_default),
__experimentalToolbarContext: () => (/* reexport */ toolbar_context_default),
__experimentalToolsPanel: () => (/* reexport */ tools_panel_component_component_default),
__experimentalToolsPanelContext: () => (/* reexport */ ToolsPanelContext),
__experimentalToolsPanelItem: () => (/* reexport */ tools_panel_item_component_component_default),
__experimentalTreeGrid: () => (/* reexport */ tree_grid_default),
__experimentalTreeGridCell: () => (/* reexport */ cell_default),
__experimentalTreeGridItem: () => (/* reexport */ tree_grid_item_item_default),
__experimentalTreeGridRow: () => (/* reexport */ row_row_default),
__experimentalTruncate: () => (/* reexport */ truncate_component_component_default),
__experimentalUnitControl: () => (/* reexport */ unit_control_default),
__experimentalUseCustomUnits: () => (/* reexport */ useCustomUnits),
__experimentalUseNavigator: () => (/* reexport */ useNavigator),
__experimentalUseSlot: () => (/* reexport */ useSlot),
__experimentalUseSlotFills: () => (/* reexport */ useSlotFills),
__experimentalVStack: () => (/* reexport */ v_stack_component_component_default),
__experimentalView: () => (/* reexport */ component_default),
__experimentalZStack: () => (/* reexport */ z_stack_component_component_default),
__unstableAnimatePresence: () => (/* reexport */ AnimatePresence),
__unstableComposite: () => (/* reexport */ legacy_Composite),
__unstableCompositeGroup: () => (/* reexport */ legacy_CompositeGroup),
__unstableCompositeItem: () => (/* reexport */ legacy_CompositeItem),
__unstableDisclosureContent: () => (/* reexport */ disclosure_DisclosureContent),
__unstableGetAnimateClassName: () => (/* reexport */ getAnimateClassName),
__unstableMotion: () => (/* reexport */ motion),
__unstableUseAutocompleteProps: () => (/* reexport */ useAutocompleteProps),
__unstableUseCompositeState: () => (/* reexport */ useCompositeState),
__unstableUseNavigateRegions: () => (/* reexport */ useNavigateRegions),
createSlotFill: () => (/* reexport */ createSlotFill),
navigateRegions: () => (/* reexport */ navigate_regions_default),
privateApis: () => (/* reexport */ privateApis),
useBaseControlProps: () => (/* reexport */ useBaseControlProps),
useNavigator: () => (/* reexport */ useNavigator),
withConstrainedTabbing: () => (/* reexport */ with_constrained_tabbing_default),
withFallbackStyles: () => (/* reexport */ with_fallback_styles_default),
withFilters: () => (/* reexport */ withFilters),
withFocusOutside: () => (/* reexport */ with_focus_outside_default),
withFocusReturn: () => (/* reexport */ with_focus_return_default),
withNotices: () => (/* reexport */ with_notices_default),
withSpokenMessages: () => (/* reexport */ with_spoken_messages_default)
});
// NAMESPACE OBJECT: ./node_modules/@wordpress/components/build-module/text/styles.js
var text_styles_namespaceObject = {};
__webpack_require__.r(text_styles_namespaceObject);
__webpack_require__.d(text_styles_namespaceObject, {
Text: () => (Text),
block: () => (styles_block),
destructive: () => (destructive),
highlighterText: () => (highlighterText),
muted: () => (muted),
positive: () => (positive),
upperCase: () => (upperCase)
});
// NAMESPACE OBJECT: ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control-option-base/styles.js
var toggle_group_control_option_base_styles_namespaceObject = {};
__webpack_require__.r(toggle_group_control_option_base_styles_namespaceObject);
__webpack_require__.d(toggle_group_control_option_base_styles_namespaceObject, {
Rp: () => (ButtonContentView),
y0: () => (LabelView),
uG: () => (buttonView),
eh: () => (labelBlock)
});
// NAMESPACE OBJECT: ./node_modules/react-day-picker/dist/esm/components/custom-components.js
var custom_components_namespaceObject = {};
__webpack_require__.r(custom_components_namespaceObject);
__webpack_require__.d(custom_components_namespaceObject, {
Button: () => (Button_Button),
CaptionLabel: () => (CaptionLabel),
Chevron: () => (Chevron),
Day: () => (Day_Day),
DayButton: () => (DayButton_DayButton),
Dropdown: () => (Dropdown_Dropdown),
DropdownNav: () => (DropdownNav),
Footer: () => (Footer_Footer),
Month: () => (Month_Month),
MonthCaption: () => (MonthCaption),
MonthGrid: () => (MonthGrid),
Months: () => (Months),
MonthsDropdown: () => (MonthsDropdown),
Nav: () => (Nav),
NextMonthButton: () => (NextMonthButton),
Option: () => (Option_Option),
PreviousMonthButton: () => (PreviousMonthButton),
Root: () => (Root_Root),
Select: () => (Select_Select),
Week: () => (Week),
WeekNumber: () => (WeekNumber),
WeekNumberHeader: () => (WeekNumberHeader),
Weekday: () => (Weekday),
Weekdays: () => (Weekdays),
Weeks: () => (Weeks),
YearsDropdown: () => (YearsDropdown)
});
// NAMESPACE OBJECT: ./node_modules/react-day-picker/dist/esm/formatters/index.js
var esm_formatters_namespaceObject = {};
__webpack_require__.r(esm_formatters_namespaceObject);
__webpack_require__.d(esm_formatters_namespaceObject, {
formatCaption: () => (formatCaption),
formatDay: () => (formatDay),
formatMonthCaption: () => (formatMonthCaption),
formatMonthDropdown: () => (formatMonthDropdown),
formatWeekNumber: () => (formatWeekNumber),
formatWeekNumberHeader: () => (formatWeekNumberHeader),
formatWeekdayName: () => (formatWeekdayName),
formatYearCaption: () => (formatYearCaption),
formatYearDropdown: () => (formatYearDropdown)
});
// NAMESPACE OBJECT: ./node_modules/react-day-picker/dist/esm/labels/index.js
var labels_namespaceObject = {};
__webpack_require__.r(labels_namespaceObject);
__webpack_require__.d(labels_namespaceObject, {
labelCaption: () => (labelCaption),
labelDay: () => (labelDay),
labelDayButton: () => (labelDayButton),
labelGrid: () => (labelGrid),
labelGridcell: () => (labelGridcell),
labelMonthDropdown: () => (labelMonthDropdown),
labelNav: () => (labelNav),
labelNext: () => (labelNext),
labelPrevious: () => (labelPrevious),
labelWeekNumber: () => (labelWeekNumber),
labelWeekNumberHeader: () => (labelWeekNumberHeader),
labelWeekday: () => (labelWeekday),
labelYearDropdown: () => (labelYearDropdown)
});
;// external ["wp","primitives"]
const external_wp_primitives_namespaceObject = window["wp"]["primitives"];
;// ./node_modules/clsx/dist/clsx.mjs
function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f)}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}/* harmony default export */ const dist_clsx = (clsx);
;// external ["wp","i18n"]
const external_wp_i18n_namespaceObject = window["wp"]["i18n"];
;// external ["wp","compose"]
const external_wp_compose_namespaceObject = window["wp"]["compose"];
;// external ["wp","element"]
const external_wp_element_namespaceObject = window["wp"]["element"];
;// ./node_modules/@ariakit/react-core/esm/__chunks/3YLGPPWQ.js
"use client";
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var _3YLGPPWQ_spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (__hasOwnProp.call(b, prop))
__defNormalProp(a, prop, b[prop]);
if (__getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(b)) {
if (__propIsEnum.call(b, prop))
__defNormalProp(a, prop, b[prop]);
}
return a;
};
var _3YLGPPWQ_spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && __getOwnPropSymbols)
for (var prop of __getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
;// ./node_modules/@ariakit/core/esm/__chunks/3YLGPPWQ.js
"use client";
var _3YLGPPWQ_defProp = Object.defineProperty;
var _3YLGPPWQ_defProps = Object.defineProperties;
var _3YLGPPWQ_getOwnPropDescs = Object.getOwnPropertyDescriptors;
var _3YLGPPWQ_getOwnPropSymbols = Object.getOwnPropertySymbols;
var _3YLGPPWQ_hasOwnProp = Object.prototype.hasOwnProperty;
var _3YLGPPWQ_propIsEnum = Object.prototype.propertyIsEnumerable;
var _3YLGPPWQ_defNormalProp = (obj, key, value) => key in obj ? _3YLGPPWQ_defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var _chunks_3YLGPPWQ_spreadValues = (a, b) => {
for (var prop in b || (b = {}))
if (_3YLGPPWQ_hasOwnProp.call(b, prop))
_3YLGPPWQ_defNormalProp(a, prop, b[prop]);
if (_3YLGPPWQ_getOwnPropSymbols)
for (var prop of _3YLGPPWQ_getOwnPropSymbols(b)) {
if (_3YLGPPWQ_propIsEnum.call(b, prop))
_3YLGPPWQ_defNormalProp(a, prop, b[prop]);
}
return a;
};
var _chunks_3YLGPPWQ_spreadProps = (a, b) => _3YLGPPWQ_defProps(a, _3YLGPPWQ_getOwnPropDescs(b));
var _3YLGPPWQ_objRest = (source, exclude) => {
var target = {};
for (var prop in source)
if (_3YLGPPWQ_hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
target[prop] = source[prop];
if (source != null && _3YLGPPWQ_getOwnPropSymbols)
for (var prop of _3YLGPPWQ_getOwnPropSymbols(source)) {
if (exclude.indexOf(prop) < 0 && _3YLGPPWQ_propIsEnum.call(source, prop))
target[prop] = source[prop];
}
return target;
};
;// ./node_modules/@ariakit/core/esm/__chunks/PBFD2E7P.js
"use client";
// src/utils/misc.ts
function PBFD2E7P_noop(..._) {
}
function shallowEqual(a, b) {
if (a === b) return true;
if (!a) return false;
if (!b) return false;
if (typeof a !== "object") return false;
if (typeof b !== "object") return false;
const aKeys = Object.keys(a);
const bKeys = Object.keys(b);
const { length } = aKeys;
if (bKeys.length !== length) return false;
for (const key of aKeys) {
if (a[key] !== b[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 isObject(arg) {
return typeof arg === "object" && arg != null;
}
function isEmpty(arg) {
if (Array.isArray(arg)) return !arg.length;
if (isObject(arg)) return !Object.keys(arg).length;
if (arg == null) return true;
if (arg === "") return true;
return false;
}
function isInteger(arg) {
if (typeof arg === "number") {
return Math.floor(arg) === arg;
}
return String(Math.floor(Number(arg))) === arg;
}
function PBFD2E7P_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 cx(...args) {
return args.filter(Boolean).join(" ") || void 0;
}
function normalizeString(str) {
return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
}
function omit(object, keys) {
const result = _chunks_3YLGPPWQ_spreadValues({}, object);
for (const key of keys) {
if (PBFD2E7P_hasOwnProperty(result, key)) {
delete result[key];
}
}
return result;
}
function pick(object, paths) {
const result = {};
for (const key of paths) {
if (PBFD2E7P_hasOwnProperty(object, key)) {
result[key] = object[key];
}
}
return result;
}
function identity(value) {
return value;
}
function beforePaint(cb = PBFD2E7P_noop) {
const raf = requestAnimationFrame(cb);
return () => cancelAnimationFrame(raf);
}
function afterPaint(cb = PBFD2E7P_noop) {
let raf = requestAnimationFrame(() => {
raf = requestAnimationFrame(cb);
});
return () => cancelAnimationFrame(raf);
}
function invariant(condition, message) {
if (condition) return;
if (typeof message !== "string") throw new Error("Invariant failed");
throw new Error(message);
}
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;
}
// EXTERNAL MODULE: external "React"
var external_React_ = __webpack_require__(1609);
var external_React_namespaceObject = /*#__PURE__*/__webpack_require__.t(external_React_, 2);
var external_React_default = /*#__PURE__*/__webpack_require__.n(external_React_);
;// ./node_modules/@ariakit/react-core/esm/__chunks/SK3NAZA3.js
"use client";
// src/utils/misc.ts
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,external_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 = _3YLGPPWQ_spreadValues({}, element.props);
return props.ref || element.ref;
}
function mergeProps(base, overrides) {
const props = _3YLGPPWQ_spreadValues({}, base);
for (const key in overrides) {
if (!PBFD2E7P_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] ? _3YLGPPWQ_spreadValues(_3YLGPPWQ_spreadValues({}, 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/DTR5TSDJ.js
"use client";
// src/utils/dom.ts
var canUseDOM = checkIsBrowser();
function checkIsBrowser() {
var _a;
return typeof window !== "undefined" && !!((_a = window.document) == null ? void 0 : _a.createElement);
}
function getDocument(node) {
if (!node) return document;
if ("self" in node) return node.document;
return node.ownerDocument || document;
}
function getWindow(node) {
if (!node) return self;
if ("self" in node) return node.self;
return getDocument(node).defaultView || window;
}
function getActiveElement(node, activeDescendant = false) {
const { activeElement } = getDocument(node);
if (!(activeElement == null ? void 0 : activeElement.nodeName)) {
return null;
}
if (isFrame(activeElement) && activeElement.contentDocument) {
return getActiveElement(
activeElement.contentDocument.body,
activeDescendant
);
}
if (activeDescendant) {
const id = activeElement.getAttribute("aria-activedescendant");
if (id) {
const element = getDocument(activeElement).getElementById(id);
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 scrollIntoViewIfNeeded(element, arg) {
if (isPartiallyHidden(element) && "scrollIntoView" in element) {
element.scrollIntoView(arg);
}
}
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 isPartiallyHidden(element) {
const elementRect = element.getBoundingClientRect();
const scroller = getScrollingElement(element);
if (!scroller) return false;
const scrollerRect = scroller.getBoundingClientRect();
const isHTML = scroller.tagName === "HTML";
const scrollerTop = isHTML ? scrollerRect.top + scroller.scrollTop : scrollerRect.top;
const scrollerBottom = isHTML ? scroller.clientHeight : scrollerRect.bottom;
const scrollerLeft = isHTML ? scrollerRect.left + scroller.scrollLeft : scrollerRect.left;
const scrollerRight = isHTML ? scroller.clientWidth : scrollerRect.right;
const top = elementRect.top < scrollerTop;
const left = elementRect.left < scrollerLeft;
const bottom = elementRect.bottom > scrollerBottom;
const right = elementRect.right > scrollerRight;
return top || left || bottom || right;
}
function setSelectionRange(element, ...args) {
if (/text|search|password|tel|url/i.test(element.type)) {
element.setSelectionRange(...args);
}
}
function sortBasedOnDOMPosition(items, getElement) {
const pairs = items.map((item, index) => [index, item]);
let isOrderDifferent = false;
pairs.sort(([indexA, a], [indexB, b]) => {
const elementA = getElement(a);
const elementB = getElement(b);
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(([_, item]) => item);
}
return items;
}
function isElementPreceding(a, b) {
return Boolean(
b.compareDocumentPosition(a) & Node.DOCUMENT_POSITION_PRECEDING
);
}
;// ./node_modules/@ariakit/core/esm/__chunks/QAGXQEUG.js
"use client";
// src/utils/platform.ts
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
"use client";
// src/utils/events.ts
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 = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, eventInit), { bubbles: true });
element.dispatchEvent(new FocusEvent("focusout", bubbleInit));
return defaultAllowed;
}
function fireFocusEvent(element, eventInit) {
const event = new FocusEvent("focus", eventInit);
const defaultAllowed = element.dispatchEvent(event);
const bubbleInit = __spreadProps(__spreadValues({}, eventInit), { bubbles: true });
element.dispatchEvent(new FocusEvent("focusin", 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 getInputType(event) {
const nativeEvent = "nativeEvent" in event ? event.nativeEvent : event;
if (!nativeEvent) return;
if (!("inputType" in nativeEvent)) return;
if (typeof nativeEvent.inputType !== "string") return;
return nativeEvent.inputType;
}
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, options, scope = window) {
const children = [];
try {
scope.document.addEventListener(type, listener, options);
for (const frame of Array.from(scope.frames)) {
children.push(addGlobalEventListener(type, listener, options, frame));
}
} catch (e) {
}
const removeEventListener = () => {
try {
scope.document.removeEventListener(type, listener, options);
} catch (e) {
}
for (const remove of children) {
remove();
}
};
return removeEventListener;
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/ABQUS43J.js
"use client";
// src/utils/hooks.ts
var _React = _3YLGPPWQ_spreadValues({}, external_React_namespaceObject);
var useReactId = _React.useId;
var useReactDeferredValue = _React.useDeferredValue;
var useReactInsertionEffect = _React.useInsertionEffect;
var useSafeLayoutEffect = canUseDOM ? external_React_.useLayoutEffect : external_React_.useEffect;
function useInitialValue(value) {
const [initialValue] = (0,external_React_.useState)(value);
return initialValue;
}
function useLazyValue(init) {
const ref = useRef();
if (ref.current === void 0) {
ref.current = init();
}
return ref.current;
}
function useLiveRef(value) {
const ref = (0,external_React_.useRef)(value);
useSafeLayoutEffect(() => {
ref.current = value;
});
return ref;
}
function usePreviousValue(value) {
const [previousValue, setPreviousValue] = useState(value);
if (value !== previousValue) {
setPreviousValue(value);
}
return previousValue;
}
function useEvent(callback) {
const ref = (0,external_React_.useRef)(() => {
throw new Error("Cannot call an event handler while rendering.");
});
if (useReactInsertionEffect) {
useReactInsertionEffect(() => {
ref.current = callback;
});
} else {
ref.current = callback;
}
return (0,external_React_.useCallback)((...args) => {
var _a;
return (_a = ref.current) == null ? void 0 : _a.call(ref, ...args);
}, []);
}
function useTransactionState(callback) {
const [state, setState] = (0,external_React_.useState)(null);
useSafeLayoutEffect(() => {
if (state == null) return;
if (!callback) return;
let prevState = null;
callback((prev) => {
prevState = prev;
return state;
});
return () => {
callback(prevState);
};
}, [state, callback]);
return [state, setState];
}
function useMergeRefs(...refs) {
return (0,external_React_.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 [id, setId] = (0,external_React_.useState)(defaultId);
useSafeLayoutEffect(() => {
if (defaultId || id) return;
const random = Math.random().toString(36).slice(2, 8);
setId(`id-${random}`);
}, [defaultId, id]);
return defaultId || id;
}
function useDeferredValue(value) {
if (useReactDeferredValue) {
return useReactDeferredValue(value);
}
const [deferredValue, setDeferredValue] = useState(value);
useEffect(() => {
const raf = requestAnimationFrame(() => setDeferredValue(value));
return () => cancelAnimationFrame(raf);
}, [value]);
return deferredValue;
}
function useTagName(refOrElement, type) {
const stringOrUndefined = (type2) => {
if (typeof type2 !== "string") return;
return type2;
};
const [tagName, setTagName] = (0,external_React_.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, defaultValue) {
const initialValue = useInitialValue(defaultValue);
const [attribute, setAttribute] = (0,external_React_.useState)(initialValue);
(0,external_React_.useEffect)(() => {
const element = refOrElement && "current" in refOrElement ? refOrElement.current : refOrElement;
if (!element) return;
const callback = () => {
const value = element.getAttribute(attributeName);
setAttribute(value == null ? initialValue : value);
};
const observer = new MutationObserver(callback);
observer.observe(element, { attributeFilter: [attributeName] });
callback();
return () => observer.disconnect();
}, [refOrElement, attributeName, initialValue]);
return attribute;
}
function useUpdateEffect(effect, deps) {
const mounted = (0,external_React_.useRef)(false);
(0,external_React_.useEffect)(() => {
if (mounted.current) {
return effect();
}
mounted.current = true;
}, deps);
(0,external_React_.useEffect)(
() => () => {
mounted.current = false;
},
[]
);
}
function useUpdateLayoutEffect(effect, deps) {
const mounted = useRef(false);
useSafeLayoutEffect(() => {
if (mounted.current) {
return effect();
}
mounted.current = true;
}, deps);
useSafeLayoutEffect(
() => () => {
mounted.current = false;
},
[]
);
}
function useForceUpdate() {
return (0,external_React_.useReducer)(() => [], []);
}
function useBooleanEvent(booleanOrCallback) {
return useEvent(
typeof booleanOrCallback === "function" ? booleanOrCallback : () => booleanOrCallback
);
}
function useWrapElement(props, callback, deps = []) {
const wrapElement = (0,external_React_.useCallback)(
(element) => {
if (props.wrapElement) {
element = props.wrapElement(element);
}
return callback(element);
},
[...deps, props.wrapElement]
);
return _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { wrapElement });
}
function usePortalRef(portalProp = false, portalRefProp) {
const [portalNode, setPortalNode] = (0,external_React_.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,external_React_.useMemo)(() => {
return Object.assign(() => {
}, _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, parent), { [key]: value }));
}, [parent, key, value]);
return [parent == null ? void 0 : parent[key], { onLoadedMetadataCapture }];
}
function useIsMouseMoving() {
(0,external_React_.useEffect)(() => {
addGlobalEventListener("mousemove", setMouseMoving, true);
addGlobalEventListener("mousedown", resetMouseMoving, true);
addGlobalEventListener("mouseup", resetMouseMoving, true);
addGlobalEventListener("keydown", resetMouseMoving, true);
addGlobalEventListener("scroll", resetMouseMoving, 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 || "production" === "test";
}
function setMouseMoving(event) {
if (!hasMouseMovement(event)) return;
mouseMoving = true;
}
function resetMouseMoving() {
mouseMoving = false;
}
;// ./node_modules/@ariakit/core/esm/__chunks/BCALMBPZ.js
"use client";
// src/utils/store.ts
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 = Symbol();
let destroy = PBFD2E7P_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 = 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 (!PBFD2E7P_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 cleanups = stores.map(init);
destroy = chain(...desyncs, ...teardowns, ...cleanups);
return maybeDestroy;
};
const sub = (keys, listener, set = listeners) => {
set.add(listener);
listenerKeys.set(listener, keys);
return () => {
var _a;
(_a = disposables.get(listener)) == null ? void 0 : _a();
disposables.delete(listener);
listenerKeys.delete(listener);
set.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 (!PBFD2E7P_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 = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, state), { [key]: nextValue });
const thisUpdate = Symbol();
lastUpdate = thisUpdate;
updatedKeys.add(key);
const run = (listener, prev, uKeys) => {
var _a2;
const keys = listenerKeys.get(listener);
const updated = (k) => uKeys ? uKeys.has(k) : k === key;
if (!keys || keys.some(updated)) {
(_a2 = disposables.get(listener)) == null ? void 0 : _a2();
disposables.set(listener, listener(state, prev));
}
};
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) {
const initialState = stores.reduce((state, store2) => {
var _a;
const nextState = (_a = store2 == null ? void 0 : store2.getState) == null ? void 0 : _a.call(store2);
if (!nextState) return state;
return Object.assign(state, nextState);
}, {});
const store = createStore(initialState, ...stores);
return Object.assign({}, ...stores, store);
}
function throwOnConflictingProps(props, store) {
if (true) 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) => PBFD2E7P_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
`
);
}
// EXTERNAL MODULE: ./node_modules/use-sync-external-store/shim/index.js
var shim = __webpack_require__(422);
;// ./node_modules/@ariakit/react-core/esm/__chunks/YV4JVR4I.js
"use client";
// src/utils/store.tsx
var { useSyncExternalStore } = shim;
var noopSubscribe = () => () => {
};
function useStoreState(store, keyOrSelector = identity) {
const storeSubscribe = external_React_.useCallback(
(callback) => {
if (!store) return noopSubscribe();
return subscribe(store, null, callback);
},
[store]
);
const getSnapshot = () => {
const key = typeof keyOrSelector === "string" ? keyOrSelector : null;
const selector = typeof keyOrSelector === "function" ? keyOrSelector : null;
const state = store == null ? void 0 : store.getState();
if (selector) return selector(state);
if (!state) return;
if (!key) return;
if (!PBFD2E7P_hasOwnProperty(state, key)) return;
return state[key];
};
return useSyncExternalStore(storeSubscribe, getSnapshot, getSnapshot);
}
function useStoreStateObject(store, object) {
const objRef = external_React_.useRef(
{}
);
const storeSubscribe = external_React_.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 (!PBFD2E7P_hasOwnProperty(state, keyOrSelector)) continue;
const value = state[keyOrSelector];
if (value !== obj[prop]) {
obj[prop] = value;
updated = true;
}
}
}
if (updated) {
objRef.current = _3YLGPPWQ_spreadValues({}, obj);
}
return objRef.current;
};
return useSyncExternalStore(storeSubscribe, getSnapshot, getSnapshot);
}
function useStoreProps(store, props, key, setKey) {
const value = PBFD2E7P_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, prev) => {
const { value: value2, setValue: setValue2 } = propsRef.current;
if (!setValue2) return;
if (state[key] === prev[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 YV4JVR4I_useStore(createStore, props) {
const [store, setStore] = external_React_.useState(() => createStore(props));
useSafeLayoutEffect(() => init(store), [store]);
const useState2 = external_React_.useCallback(
(keyOrSelector) => useStoreState(store, keyOrSelector),
[store]
);
const memoizedStore = external_React_.useMemo(
() => _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, store), { useState: useState2 }),
[store, useState2]
);
const updateStore = useEvent(() => {
setStore((store2) => createStore(_3YLGPPWQ_spreadValues(_3YLGPPWQ_spreadValues({}, props), store2.getState())));
});
return [memoizedStore, updateStore];
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/C3IKGW5T.js
"use client";
// src/collection/collection-store.ts
function useCollectionStoreProps(store, update, props) {
useUpdateEffect(update, [props.store]);
useStoreProps(store, props, "items", "setItems");
return store;
}
function useCollectionStore(props = {}) {
const [store, update] = useStore(Core.createCollectionStore, props);
return useCollectionStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/core/esm/__chunks/CYQWQL4J.js
"use client";
// src/collection/collection-store.ts
function getCommonParent(items) {
var _a;
const firstItem = items.find((item) => !!item.element);
const lastItem = [...items].reverse().find((item) => !!item.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((item) => [item.id, item]));
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, (i) => i.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 item of state.renderedItems) {
if (!item.element) continue;
observer.observe(item.element);
}
return () => {
cancelAnimationFrame(raf);
observer.disconnect();
};
});
});
const mergeItem = (item, setItems, canDeleteFromMap = false) => {
let prevItem;
setItems((items2) => {
const index = items2.findIndex(({ id }) => id === item.id);
const nextItems = items2.slice();
if (index !== -1) {
prevItem = items2[index];
const nextItem = _chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, prevItem), item);
nextItems[index] = nextItem;
itemsMap.set(item.id, nextItem);
} else {
nextItems.push(item);
itemsMap.set(item.id, item);
}
return nextItems;
});
const unmergeItem = () => {
setItems((items2) => {
if (!prevItem) {
if (canDeleteFromMap) {
itemsMap.delete(item.id);
}
return items2.filter(({ id }) => id !== item.id);
}
const index = items2.findIndex(({ id }) => id === item.id);
if (index === -1) return items2;
const nextItems = items2.slice();
nextItems[index] = prevItem;
itemsMap.set(item.id, prevItem);
return nextItems;
});
};
return unmergeItem;
};
const registerItem = (item) => mergeItem(
item,
(getItems) => privateStore.setState("items", getItems),
true
);
return _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, collection), {
registerItem,
renderItem: (item) => chain(
registerItem(item),
mergeItem(
item,
(getItems) => privateStore.setState("renderedItems", getItems)
)
),
item: (id) => {
if (!id) return null;
let item = itemsMap.get(id);
if (!item) {
const { items: items2 } = privateStore.getState();
item = items2.find((item2) => item2.id === id);
if (item) {
itemsMap.set(id, item);
}
}
return item || null;
},
// @ts-expect-error Internal
__unstablePrivateStore: privateStore
});
}
;// ./node_modules/@ariakit/core/esm/__chunks/7PRQYBBV.js
"use client";
// src/utils/array.ts
function toArray(arg) {
if (Array.isArray(arg)) {
return arg;
}
return typeof arg !== "undefined" ? [arg] : [];
}
function addItemToArray(array, item, index = -1) {
if (!(index in array)) {
return [...array, item];
}
return [...array.slice(0, index), item, ...array.slice(index)];
}
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/core/esm/__chunks/AJZ4BYF3.js
"use client";
// src/composite/composite-store.ts
var NULL_ITEM = { id: null };
function findFirstEnabledItem(items, excludeId) {
return items.find((item) => {
if (excludeId) {
return !item.disabled && item.id !== excludeId;
}
return !item.disabled;
});
}
function getEnabledItems(items, excludeId) {
return items.filter((item) => {
if (excludeId) {
return !item.disabled && item.id !== excludeId;
}
return !item.disabled;
});
}
function getItemsInRow(items, rowId) {
return items.filter((item) => item.rowId === rowId);
}
function flipItems(items, activeId, shouldInsertNullItem = false) {
const index = items.findIndex((item) => item.id === activeId);
return [
...items.slice(index + 1),
...shouldInsertNullItem ? [NULL_ITEM] : [],
...items.slice(0, index)
];
}
function groupItemsByRows(items) {
const rows = [];
for (const item of items) {
const row = rows.find((currentRow) => {
var _a;
return ((_a = currentRow[0]) == null ? void 0 : _a.rowId) === item.rowId;
});
if (row) {
row.push(item);
} else {
rows.push([item]);
}
}
return rows;
}
function getMaxRowLength(array) {
let maxLength = 0;
for (const { length } of array) {
if (length > maxLength) {
maxLength = length;
}
}
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 i = 0; i < maxLength; i += 1) {
const item = row[i];
if (!item || focusShift && item.disabled) {
const isFirst = i === 0;
const previousItem = isFirst && focusShift ? findFirstEnabledItem(row) : row[i - 1];
row[i] = previousItem && activeId !== previousItem.id && focusShift ? previousItem : createEmptyItem(previousItem == null ? void 0 : previousItem.rowId);
}
}
}
return rows;
}
function verticalizeItems(items) {
const rows = groupItemsByRows(items);
const maxLength = getMaxRowLength(rows);
const verticalized = [];
for (let i = 0; i < maxLength; i += 1) {
for (const row of rows) {
const item = row[i];
if (item) {
verticalized.push(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, item), {
// 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: item.rowId ? `${i}` : 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 = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 = findFirstEnabledItem(state.renderedItems)) == null ? void 0 : _a2.id;
});
})
);
const getNextId = (direction = "next", options = {}) => {
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 = defaultState.rtl
} = options;
const isVerticalDirection = direction === "up" || direction === "down";
const isNextDirection = direction === "next" || direction === "down";
const canReverse = isNextDirection ? rtl && !isVerticalDirection : !rtl || isVerticalDirection;
const canShift = focusShift && !skip;
let items = !isVerticalDirection ? renderedItems : flatten2DArray(
normalizeRows(groupItemsByRows(renderedItems), activeId2, canShift)
);
items = canReverse ? reverseArray(items) : items;
items = isVerticalDirection ? verticalizeItems(items) : items;
if (activeId2 == null) {
return (_a2 = findFirstEnabledItem(items)) == null ? void 0 : _a2.id;
}
const activeItem = items.find((item) => item.id === activeId2);
if (!activeItem) {
return (_b = findFirstEnabledItem(items)) == null ? void 0 : _b.id;
}
const isGrid = items.some((item) => item.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 = isGrid && focusWrap && (isVerticalDirection ? focusWrap !== "horizontal" : focusWrap !== "vertical");
const hasNullItem = isNextDirection ? (!isGrid || isVerticalDirection) && canLoop && includesBaseElement : isVerticalDirection ? includesBaseElement : false;
if (canLoop) {
const loopItems = canWrap && !hasNullItem ? items : getItemsInRow(items, activeItem.rowId);
const sortedItems = flipItems(loopItems, activeId2, hasNullItem);
const nextItem2 = findFirstEnabledItem(sortedItems, activeId2);
return nextItem2 == null ? void 0 : nextItem2.id;
}
if (canWrap) {
const nextItem2 = findFirstEnabledItem(
// 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 = findFirstEnabledItem(nextItemsInRow, activeId2);
if (!nextItem && hasNullItem) {
return null;
}
return nextItem == null ? void 0 : nextItem.id;
};
return _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, collection), composite), {
setBaseElement: (element) => composite.setState("baseElement", element),
setActiveId: (id) => composite.setState("activeId", id),
move: (id) => {
if (id === void 0) return;
composite.setState("activeId", id);
composite.setState("moves", (moves) => moves + 1);
},
first: () => {
var _a2;
return (_a2 = findFirstEnabledItem(composite.getState().renderedItems)) == null ? void 0 : _a2.id;
},
last: () => {
var _a2;
return (_a2 = findFirstEnabledItem(reverseArray(composite.getState().renderedItems))) == null ? void 0 : _a2.id;
},
next: (options) => {
if (options !== void 0 && typeof options === "number") {
options = { skip: options };
}
return getNextId("next", options);
},
previous: (options) => {
if (options !== void 0 && typeof options === "number") {
options = { skip: options };
}
return getNextId("previous", options);
},
down: (options) => {
if (options !== void 0 && typeof options === "number") {
options = { skip: options };
}
return getNextId("down", options);
},
up: (options) => {
if (options !== void 0 && typeof options === "number") {
options = { skip: options };
}
return getNextId("up", options);
}
});
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/4CMBR7SL.js
"use client";
// src/composite/composite-store.ts
function useCompositeStoreOptions(props) {
const id = useId(props.id);
return _3YLGPPWQ_spreadValues({ id }, 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] = YV4JVR4I_useStore(createCompositeStore, props);
return useCompositeStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/5VQZOHHZ.js
"use client";
// src/composite/utils.ts
var _5VQZOHHZ_NULL_ITEM = { id: null };
function _5VQZOHHZ_flipItems(items, activeId, shouldInsertNullItem = false) {
const index = items.findIndex((item) => item.id === activeId);
return [
...items.slice(index + 1),
...shouldInsertNullItem ? [_5VQZOHHZ_NULL_ITEM] : [],
...items.slice(0, index)
];
}
function _5VQZOHHZ_findFirstEnabledItem(items, excludeId) {
return items.find((item) => {
if (excludeId) {
return !item.disabled && item.id !== excludeId;
}
return !item.disabled;
});
}
function getEnabledItem(store, id) {
if (!id) return null;
return store.item(id) || null;
}
function _5VQZOHHZ_groupItemsByRows(items) {
const rows = [];
for (const item of items) {
const row = rows.find((currentRow) => {
var _a;
return ((_a = currentRow[0]) == null ? void 0 : _a.rowId) === item.rowId;
});
if (row) {
row.push(item);
} else {
rows.push([item]);
}
}
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 = 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 item = store.item(element.id);
if (!item) return false;
if (exclude && item.element === exclude) return false;
return true;
}
;// external "ReactJSXRuntime"
const external_ReactJSXRuntime_namespaceObject = window["ReactJSXRuntime"];
;// ./node_modules/@ariakit/react-core/esm/__chunks/LMDWO4NN.js
"use client";
// src/utils/system.tsx
function forwardRef2(render) {
const Role = external_React_.forwardRef((props, ref) => render(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { ref })));
Role.displayName = render.displayName || render.name;
return Role;
}
function memo2(Component, propsAreEqual) {
return external_React_.memo(Component, propsAreEqual);
}
function LMDWO4NN_createElement(Type, props) {
const _a = props, { wrapElement, render } = _a, rest = __objRest(_a, ["wrapElement", "render"]);
const mergedRef = useMergeRefs(props.ref, getRefProperty(render));
let element;
if (external_React_.isValidElement(render)) {
const renderProps = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, render.props), { ref: mergedRef });
element = external_React_.cloneElement(render, mergeProps(rest, renderProps));
} else if (render) {
element = render(rest);
} else {
element = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Type, _3YLGPPWQ_spreadValues({}, rest));
}
if (wrapElement) {
return wrapElement(element);
}
return element;
}
function createHook(useProps) {
const useRole = (props = {}) => {
return useProps(props);
};
useRole.displayName = useProps.name;
return useRole;
}
function createStoreContext(providers = [], scopedProviders = []) {
const context = external_React_.createContext(void 0);
const scopedContext = external_React_.createContext(void 0);
const useContext2 = () => external_React_.useContext(context);
const useScopedContext = (onlyScoped = false) => {
const scoped = external_React_.useContext(scopedContext);
const store = useContext2();
if (onlyScoped) return scoped;
return scoped || store;
};
const useProviderContext = () => {
const scoped = external_React_.useContext(scopedContext);
const store = useContext2();
if (scoped && scoped === store) return;
return store;
};
const ContextProvider = (props) => {
return providers.reduceRight(
(children, Provider) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { children })),
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(context.Provider, _3YLGPPWQ_spreadValues({}, props))
);
};
const ScopedContextProvider = (props) => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ContextProvider, _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { children: scopedProviders.reduceRight(
(children, Provider) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Provider, _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { children })),
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(scopedContext.Provider, _3YLGPPWQ_spreadValues({}, props))
) }));
};
return {
context,
scopedContext,
useContext: useContext2,
useScopedContext,
useProviderContext,
ContextProvider,
ScopedContextProvider
};
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/VDHZ5F7K.js
"use client";
// src/collection/collection-context.tsx
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/P7GR5CS5.js
"use client";
// src/composite/composite-context.tsx
var P7GR5CS5_ctx = createStoreContext(
[CollectionContextProvider],
[CollectionScopedContextProvider]
);
var useCompositeContext = P7GR5CS5_ctx.useContext;
var useCompositeScopedContext = P7GR5CS5_ctx.useScopedContext;
var useCompositeProviderContext = P7GR5CS5_ctx.useProviderContext;
var CompositeContextProvider = P7GR5CS5_ctx.ContextProvider;
var CompositeScopedContextProvider = P7GR5CS5_ctx.ScopedContextProvider;
var CompositeItemContext = (0,external_React_.createContext)(
void 0
);
var CompositeRowContext = (0,external_React_.createContext)(
void 0
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/SWN3JYXT.js
"use client";
// src/focusable/focusable-context.tsx
var FocusableContext = (0,external_React_.createContext)(true);
;// ./node_modules/@ariakit/core/esm/utils/focus.js
"use client";
// src/utils/focus.ts
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 elements = Array.from(
container.querySelectorAll(selector)
);
if (includeContainer) {
elements.unshift(container);
}
const focusableElements = elements.filter(isFocusable);
focusableElements.forEach((element, i) => {
if (isFrame(element) && element.contentDocument) {
const frameBody = element.contentDocument.body;
focusableElements.splice(i, 1, ...getAllFocusableIn(frameBody));
}
});
return focusableElements;
}
function getAllFocusable(includeBody) {
return getAllFocusableIn(document.body, includeBody);
}
function getFirstFocusableIn(container, includeContainer) {
const [first] = getAllFocusableIn(container, includeContainer);
return first || null;
}
function getFirstFocusable(includeBody) {
return getFirstFocusableIn(document.body, includeBody);
}
function getAllTabbableIn(container, includeContainer, fallbackToFocusable) {
const elements = Array.from(
container.querySelectorAll(selector)
);
const tabbableElements = elements.filter(isTabbable);
if (includeContainer && isTabbable(container)) {
tabbableElements.unshift(container);
}
tabbableElements.forEach((element, i) => {
if (isFrame(element) && element.contentDocument) {
const frameBody = element.contentDocument.body;
const allFrameTabbable = getAllTabbableIn(
frameBody,
false,
fallbackToFocusable
);
tabbableElements.splice(i, 1, ...allFrameTabbable);
}
});
if (!tabbableElements.length && fallbackToFocusable) {
return elements;
}
return tabbableElements;
}
function getAllTabbable(fallbackToFocusable) {
return getAllTabbableIn(document.body, false, fallbackToFocusable);
}
function getFirstTabbableIn(container, includeContainer, fallbackToFocusable) {
const [first] = getAllTabbableIn(
container,
includeContainer,
fallbackToFocusable
);
return first || null;
}
function getFirstTabbable(fallbackToFocusable) {
return getFirstTabbableIn(document.body, false, fallbackToFocusable);
}
function getLastTabbableIn(container, includeContainer, fallbackToFocusable) {
const allTabbable = getAllTabbableIn(
container,
includeContainer,
fallbackToFocusable
);
return allTabbable[allTabbable.length - 1] || null;
}
function getLastTabbable(fallbackToFocusable) {
return getLastTabbableIn(document.body, false, fallbackToFocusable);
}
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 elements = 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 elements) {
restoreTabIndex(element);
}
}
function focusIntoView(element, options) {
if (!("scrollIntoView" in element)) {
element.focus();
} else {
element.focus({ preventScroll: true });
element.scrollIntoView(_chunks_3YLGPPWQ_spreadValues({ block: "nearest", inline: "nearest" }, options));
}
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/LVA2YJMS.js
"use client";
// src/focusable/focusable.tsx
var TagName = "div";
var isSafariBrowser = isSafari();
var alwaysFocusVisibleInputTypes = [
"text",
"search",
"url",
"tel",
"email",
"password",
"number",
"date",
"month",
"week",
"time",
"datetime",
"datetime-local"
];
var safariFocusAncestorSymbol = 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 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(_a) {
var _b = _a, {
focusable = true,
accessibleWhenDisabled,
autoFocus,
onFocusVisible
} = _b, props = __objRest(_b, [
"focusable",
"accessibleWhenDisabled",
"autoFocus",
"onFocusVisible"
]);
const ref = (0,external_React_.useRef)(null);
(0,external_React_.useEffect)(() => {
if (!focusable) return;
addGlobalEventListener("mousedown", onGlobalMouseDown, true);
addGlobalEventListener("keydown", onGlobalKeyDown, true);
}, [focusable]);
if (isSafariBrowser) {
(0,external_React_.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,external_React_.useState)(false);
(0,external_React_.useEffect)(() => {
if (!focusable) return;
if (trulyDisabled && focusVisible) {
setFocusVisible(false);
}
}, [focusable, trulyDisabled, focusVisible]);
(0,external_React_.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 options = { capture: true, once: true };
element.addEventListener("focusin", onFocus, options);
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;
setFocusVisible(false);
});
const autoFocusOnShow = (0,external_React_.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 style = (0,external_React_.useMemo)(() => {
if (trulyDisabled) {
return _3YLGPPWQ_spreadValues({ pointerEvents: "none" }, styleProp);
}
return styleProp;
}, [trulyDisabled, styleProp]);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
"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,
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 LMDWO4NN_createElement(TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/ITI7HKP4.js
"use client";
// src/composite/composite.tsx
var ITI7HKP4_TagName = "div";
function isGrid(items) {
return items.some((item) => !!item.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 _b = event, { view } = _b, eventInit = __objRest(_b, ["view"]);
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 _5VQZOHHZ_findFirstEnabledItem(
flatten2DArray(reverseArray(_5VQZOHHZ_groupItemsByRows(items)))
);
}
function useScheduleFocus(store) {
const [scheduled, setScheduled] = (0,external_React_.useState)(false);
const schedule = (0,external_React_.useCallback)(() => setScheduled(true), []);
const activeItem = store.useState(
(state) => getEnabledItem(store, state.activeId)
);
(0,external_React_.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(_a) {
var _b = _a, {
store,
composite = true,
focusOnMove = composite,
moveOnKeyPress = true
} = _b, props = __objRest(_b, [
"store",
"composite",
"focusOnMove",
"moveOnKeyPress"
]);
const context = useCompositeProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const ref = (0,external_React_.useRef)(null);
const previousElementRef = (0,external_React_.useRef)(null);
const scheduleFocus = useScheduleFocus(store);
const moves = store.useState("moves");
const [, setBaseElement] = useTransactionState(
composite ? store.setBaseElement : null
);
(0,external_React_.useEffect)(() => {
var _a2;
if (!store) return;
if (!moves) return;
if (!composite) return;
if (!focusOnMove) return;
const { activeId: activeId2 } = store.getState();
const itemElement = (_a2 = getEnabledItem(store, activeId2)) == null ? void 0 : _a2.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 _a2;
if (!store) return;
if (!composite) return;
if (!virtualFocus) return;
const previousElement = previousElementRef.current;
previousElementRef.current = null;
if (!previousElement) return;
const activeElement = (_a2 = getEnabledItem(store, activeId)) == null ? void 0 : _a2.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 _a2;
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 = (_a2 = getEnabledItem(store, activeId2)) == null ? void 0 : _a2.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 _a2;
onKeyDownProp == null ? void 0 : onKeyDownProp(event);
if (event.defaultPrevented) return;
if (!store) return;
if (!isSelfTarget(event)) return;
const { orientation, renderedItems, activeId: activeId2 } = store.getState();
const activeItem = getEnabledItem(store, activeId2);
if ((_a2 = activeItem == null ? void 0 : activeItem.element) == null ? void 0 : _a2.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 item = findFirstEnabledItemInTheLastRow(renderedItems);
return item == null ? void 0 : item.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 id = action();
if (id !== void 0) {
if (!moveOnKeyPressProp(event)) return;
event.preventDefault();
store.move(id);
}
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeContextProvider, { value: store, children: element }),
[store]
);
const activeDescendant = store.useState((state) => {
var _a2;
if (!store) return;
if (!composite) return;
if (!state.virtualFocus) return;
return (_a2 = getEnabledItem(store, state.activeId)) == null ? void 0 : _a2.id;
});
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
"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(_3YLGPPWQ_spreadValues({ focusable }, props));
return props;
}
);
var Composite = forwardRef2(function Composite2(props) {
const htmlProps = useComposite(props);
return LMDWO4NN_createElement(ITI7HKP4_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/composite/context.js
const CompositeContext = (0,external_wp_element_namespaceObject.createContext)({});
CompositeContext.displayName = "CompositeContext";
const context_useCompositeContext = () => (0,external_wp_element_namespaceObject.useContext)(CompositeContext);
;// ./node_modules/@ariakit/react-core/esm/__chunks/7HVFURXT.js
"use client";
// src/group/group-label-context.tsx
var GroupLabelContext = (0,external_React_.createContext)(void 0);
;// ./node_modules/@ariakit/react-core/esm/__chunks/36LIF33V.js
"use client";
// src/group/group.tsx
var _36LIF33V_TagName = "div";
var useGroup = createHook(
function useGroup2(props) {
const [labelId, setLabelId] = (0,external_React_.useState)();
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GroupLabelContext.Provider, { value: setLabelId, children: element }),
[]
);
props = _3YLGPPWQ_spreadValues({
role: "group",
"aria-labelledby": labelId
}, props);
return removeUndefinedValues(props);
}
);
var Group = forwardRef2(function Group2(props) {
const htmlProps = useGroup(props);
return LMDWO4NN_createElement(_36LIF33V_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/YORGHBM4.js
"use client";
// src/composite/composite-group.tsx
var YORGHBM4_TagName = "div";
var useCompositeGroup = createHook(
function useCompositeGroup2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
props = useGroup(props);
return props;
}
);
var CompositeGroup = forwardRef2(function CompositeGroup2(props) {
const htmlProps = useCompositeGroup(props);
return LMDWO4NN_createElement(YORGHBM4_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/composite/group.js
const group_CompositeGroup = (0,external_wp_element_namespaceObject.forwardRef)(function CompositeGroup2(props, ref) {
var _props$store;
const context = context_useCompositeContext();
const store = (_props$store = props.store) !== null && _props$store !== void 0 ? _props$store : context.store;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeGroup, {
store,
...props,
ref
});
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/YUOJWFSO.js
"use client";
// src/group/group-label.tsx
var YUOJWFSO_TagName = "div";
var useGroupLabel = createHook(
function useGroupLabel2(props) {
const setLabelId = (0,external_React_.useContext)(GroupLabelContext);
const id = useId(props.id);
useSafeLayoutEffect(() => {
setLabelId == null ? void 0 : setLabelId(id);
return () => setLabelId == null ? void 0 : setLabelId(void 0);
}, [setLabelId, id]);
props = _3YLGPPWQ_spreadValues({
id,
"aria-hidden": true
}, props);
return removeUndefinedValues(props);
}
);
var GroupLabel = forwardRef2(function GroupLabel2(props) {
const htmlProps = useGroupLabel(props);
return LMDWO4NN_createElement(YUOJWFSO_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/SWSPTQMT.js
"use client";
// src/composite/composite-group-label.tsx
var SWSPTQMT_TagName = "div";
var useCompositeGroupLabel = createHook(function useCompositeGroupLabel2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
props = useGroupLabel(props);
return props;
});
var CompositeGroupLabel = forwardRef2(function CompositeGroupLabel2(props) {
const htmlProps = useCompositeGroupLabel(props);
return LMDWO4NN_createElement(SWSPTQMT_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/composite/group-label.js
const group_label_CompositeGroupLabel = (0,external_wp_element_namespaceObject.forwardRef)(function CompositeGroupLabel2(props, ref) {
var _props$store;
const context = context_useCompositeContext();
const store = (_props$store = props.store) !== null && _props$store !== void 0 ? _props$store : context.store;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeGroupLabel, {
store,
...props,
ref
});
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/UQQRIHDV.js
"use client";
// src/composite/composite-hover.tsx
var UQQRIHDV_TagName = "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 symbol = Symbol("composite-hover");
function movingToAnotherItem(event) {
let dest = getMouseDestination(event);
if (!dest) return false;
do {
if (PBFD2E7P_hasOwnProperty(dest, symbol) && dest[symbol]) return true;
dest = dest.parentElement;
} while (dest);
return false;
}
var useCompositeHover = createHook(
function useCompositeHover2(_a) {
var _b = _a, {
store,
focusOnHover = true,
blurOnHoverEnd = !!focusOnHover
} = _b, props = __objRest(_b, [
"store",
"focusOnHover",
"blurOnHoverEnd"
]);
const context = useCompositeContext();
store = store || context;
invariant(
store,
false && 0
);
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 _a2;
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);
(_a2 = store == null ? void 0 : store.getState().baseElement) == null ? void 0 : _a2.focus();
});
const ref = (0,external_React_.useCallback)((element) => {
if (!element) return;
element[symbol] = true;
}, []);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
ref: useMergeRefs(ref, props.ref),
onMouseMove,
onMouseLeave
});
return removeUndefinedValues(props);
}
);
var CompositeHover = memo2(
forwardRef2(function CompositeHover2(props) {
const htmlProps = useCompositeHover(props);
return LMDWO4NN_createElement(UQQRIHDV_TagName, htmlProps);
})
);
;// ./node_modules/@wordpress/components/build-module/composite/hover.js
const hover_CompositeHover = (0,external_wp_element_namespaceObject.forwardRef)(function CompositeHover2(props, ref) {
var _props$store;
const context = context_useCompositeContext();
const store = (_props$store = props.store) !== null && _props$store !== void 0 ? _props$store : context.store;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeHover, {
store,
...props,
ref
});
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/RZ4GPYOB.js
"use client";
// src/collection/collection-item.tsx
var RZ4GPYOB_TagName = "div";
var useCollectionItem = createHook(
function useCollectionItem2(_a) {
var _b = _a, {
store,
shouldRegisterItem = true,
getItem = identity,
element: element
} = _b, props = __objRest(_b, [
"store",
"shouldRegisterItem",
"getItem",
// @ts-expect-error This prop may come from a collection renderer.
"element"
]);
const context = useCollectionContext();
store = store || context;
const id = useId(props.id);
const ref = (0,external_React_.useRef)(element);
(0,external_React_.useEffect)(() => {
const element2 = ref.current;
if (!id) return;
if (!element2) return;
if (!shouldRegisterItem) return;
const item = getItem({ id, element: element2 });
return store == null ? void 0 : store.renderItem(item);
}, [id, shouldRegisterItem, getItem, store]);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
ref: useMergeRefs(ref, props.ref)
});
return removeUndefinedValues(props);
}
);
var CollectionItem = forwardRef2(function CollectionItem2(props) {
const htmlProps = useCollectionItem(props);
return LMDWO4NN_createElement(RZ4GPYOB_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/KUU7WJ55.js
"use client";
// src/command/command.tsx
var KUU7WJ55_TagName = "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 KUU7WJ55_symbol = Symbol("command");
var useCommand = createHook(
function useCommand2(_a) {
var _b = _a, { clickOnEnter = true, clickOnSpace = true } = _b, props = __objRest(_b, ["clickOnEnter", "clickOnSpace"]);
const ref = (0,external_React_.useRef)(null);
const [isNativeButton, setIsNativeButton] = (0,external_React_.useState)(false);
(0,external_React_.useEffect)(() => {
if (!ref.current) return;
setIsNativeButton(isButton(ref.current));
}, []);
const [active, setActive] = (0,external_React_.useState)(false);
const activeRef = (0,external_React_.useRef)(false);
const disabled = disabledFromProps(props);
const [isDuplicate, metadataProps] = useMetadataProps(props, KUU7WJ55_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 _a2 = event, { view } = _a2, eventInit = __objRest(_a2, ["view"]);
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 _a2 = event, { view } = _a2, eventInit = __objRest(_a2, ["view"]);
queueMicrotask(() => fireClickEvent(element, eventInit));
}
}
});
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues(_3YLGPPWQ_spreadValues({
"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 LMDWO4NN_createElement(KUU7WJ55_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/P2CTZE2T.js
"use client";
// src/composite/composite-item.tsx
var P2CTZE2T_TagName = "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, next, pageUp = false) {
var _a;
if (!store) return;
if (!next) return;
const { renderedItems } = store.getState();
const scrollingElement = getScrollingElement(element);
if (!scrollingElement) return;
const nextPageOffset = getNextPageOffset(scrollingElement, pageUp);
let id;
let prevDifference;
for (let i = 0; i < renderedItems.length; i += 1) {
const previousId = id;
id = next(i);
if (!id) break;
if (id === previousId) continue;
const itemElement = (_a = getEnabledItem(store, id)) == 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) {
id = previousId;
}
break;
}
prevDifference = absDifference;
}
return id;
}
function targetIsAnotherItem(event, store) {
if (isSelfTarget(event)) return false;
return isItem(store, event.target);
}
var useCompositeItem = createHook(
function useCompositeItem2(_a) {
var _b = _a, {
store,
rowId: rowIdProp,
preventScrollOnKeyDown = false,
moveOnKeyPress = true,
tabbable = false,
getItem: getItemProp,
"aria-setsize": ariaSetSizeProp,
"aria-posinset": ariaPosInSetProp
} = _b, props = __objRest(_b, [
"store",
"rowId",
"preventScrollOnKeyDown",
"moveOnKeyPress",
"tabbable",
"getItem",
"aria-setsize",
"aria-posinset"
]);
const context = useCompositeContext();
store = store || context;
const id = useId(props.id);
const ref = (0,external_React_.useRef)(null);
const row = (0,external_React_.useContext)(CompositeRowContext);
const disabled = disabledFromProps(props);
const trulyDisabled = disabled && !props.accessibleWhenDisabled;
const {
rowId,
baseElement,
isActiveItem,
ariaSetSize,
ariaPosInSet,
isTabbable
} = 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 === id;
},
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(
(item) => item.rowId === rowId
);
return row.ariaPosInSet + itemsInRow.findIndex((item) => item.id === id);
},
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 item = store == null ? void 0 : store.item(state.activeId);
if (item == null ? void 0 : item.disabled) return true;
if (!(item == null ? void 0 : item.element)) return true;
return state.activeId === id;
}
});
const getItem = (0,external_React_.useCallback)(
(item) => {
var _a2;
const nextItem = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, item), {
id: id || item.id,
rowId,
disabled: !!trulyDisabled,
children: (_a2 = item.element) == null ? void 0 : _a2.textContent
});
if (getItemProp) {
return getItemProp(nextItem);
}
return nextItem;
},
[id, rowId, trulyDisabled, getItemProp]
);
const onFocusProp = props.onFocus;
const hasFocusedComposite = (0,external_React_.useRef)(false);
const onFocus = useEvent((event) => {
onFocusProp == null ? void 0 : onFocusProp(event);
if (event.defaultPrevented) return;
if (isPortalEvent(event)) return;
if (!id) return;
if (!store) return;
if (targetIsAnotherItem(event, store)) return;
const { virtualFocus, baseElement: baseElement2 } = store.getState();
store.setActiveId(id);
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 item = store.item(id);
const isGrid = !!(item == null ? void 0 : item.rowId);
const isVertical = state.orientation !== "horizontal";
const isHorizontal = state.orientation !== "vertical";
const canHomeEnd = () => {
if (isGrid) return true;
if (isHorizontal) return true;
if (!state.baseElement) return true;
if (!isTextField(state.baseElement)) return true;
return false;
};
const keyMap = {
ArrowUp: (isGrid || isVertical) && store.up,
ArrowRight: (isGrid || isHorizontal) && store.next,
ArrowDown: (isGrid || isVertical) && store.down,
ArrowLeft: (isGrid || isHorizontal) && store.previous,
Home: () => {
if (!canHomeEnd()) return;
if (!isGrid || event.ctrlKey) {
return store == null ? void 0 : store.first();
}
return store == null ? void 0 : store.previous(-1);
},
End: () => {
if (!canHomeEnd()) return;
if (!isGrid || 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,external_React_.useMemo)(
() => ({ id, baseElement }),
[id, baseElement]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeItemContext.Provider, { value: providerValue, children: element }),
[providerValue]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
"data-active-item": isActiveItem || void 0
}, props), {
ref: useMergeRefs(ref, props.ref),
tabIndex: isTabbable ? props.tabIndex : -1,
onFocus,
onBlurCapture,
onKeyDown
});
props = useCommand(props);
props = useCollectionItem(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
store
}, props), {
getItem,
shouldRegisterItem: id ? props.shouldRegisterItem : false
}));
return removeUndefinedValues(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
"aria-setsize": ariaSetSize,
"aria-posinset": ariaPosInSet
}));
}
);
var CompositeItem = memo2(
forwardRef2(function CompositeItem2(props) {
const htmlProps = useCompositeItem(props);
return LMDWO4NN_createElement(P2CTZE2T_TagName, htmlProps);
})
);
;// ./node_modules/@wordpress/components/build-module/composite/item.js
const item_CompositeItem = (0,external_wp_element_namespaceObject.forwardRef)(function CompositeItem2(props, ref) {
var _props$store;
const context = context_useCompositeContext();
const store = (_props$store = props.store) !== null && _props$store !== void 0 ? _props$store : context.store;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeItem, {
store,
...props,
ref
});
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/J2LQO3EC.js
"use client";
// src/composite/composite-row.tsx
var J2LQO3EC_TagName = "div";
var useCompositeRow = createHook(
function useCompositeRow2(_a) {
var _b = _a, {
store,
"aria-setsize": ariaSetSize,
"aria-posinset": ariaPosInSet
} = _b, props = __objRest(_b, [
"store",
"aria-setsize",
"aria-posinset"
]);
const context = useCompositeContext();
store = store || context;
invariant(
store,
false && 0
);
const id = useId(props.id);
const baseElement = store.useState(
(state) => state.baseElement || void 0
);
const providerValue = (0,external_React_.useMemo)(
() => ({ id, baseElement, ariaSetSize, ariaPosInSet }),
[id, baseElement, ariaSetSize, ariaPosInSet]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeRowContext.Provider, { value: providerValue, children: element }),
[providerValue]
);
props = _3YLGPPWQ_spreadValues({ id }, props);
return removeUndefinedValues(props);
}
);
var CompositeRow = forwardRef2(function CompositeRow2(props) {
const htmlProps = useCompositeRow(props);
return LMDWO4NN_createElement(J2LQO3EC_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/composite/row.js
const row_CompositeRow = (0,external_wp_element_namespaceObject.forwardRef)(function CompositeRow2(props, ref) {
var _props$store;
const context = context_useCompositeContext();
const store = (_props$store = props.store) !== null && _props$store !== void 0 ? _props$store : context.store;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeRow, {
store,
...props,
ref
});
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/T7VMP3TM.js
"use client";
// src/composite/composite-typeahead.tsx
var T7VMP3TM_TagName = "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 isItem = items.some((item) => item.element === target);
return isItem;
}
function T7VMP3TM_getEnabledItems(items) {
return items.filter((item) => !item.disabled);
}
function itemTextStartsWith(item, text) {
var _a;
const itemText = ((_a = item.element) == null ? void 0 : _a.textContent) || item.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 item && item.value;
if (!itemText) return false;
return normalizeString(itemText).trim().toLowerCase().startsWith(text.toLowerCase());
}
function getSameInitialItems(items, char, activeId) {
if (!activeId) return items;
const activeItem = items.find((item) => item.id === activeId);
if (!activeItem) return items;
if (!itemTextStartsWith(activeItem, char)) return items;
if (chars !== char && itemTextStartsWith(activeItem, chars)) return items;
chars = char;
return _5VQZOHHZ_flipItems(
items.filter((item) => itemTextStartsWith(item, chars)),
activeId
).filter((item) => item.id !== activeId);
}
var useCompositeTypeahead = createHook(function useCompositeTypeahead2(_a) {
var _b = _a, { store, typeahead = true } = _b, props = __objRest(_b, ["store", "typeahead"]);
const context = useCompositeContext();
store = store || context;
invariant(
store,
false && 0
);
const onKeyDownCaptureProp = props.onKeyDownCapture;
const cleanupTimeoutRef = (0,external_React_.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 } = store.getState();
let enabledItems = T7VMP3TM_getEnabledItems(
items.length > renderedItems.length ? items : renderedItems
);
const document = getDocument(event.currentTarget);
const selector = `[data-offscreen-id="${id}"]`;
const offscreenItems = document.querySelectorAll(selector);
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, (i) => i.element);
}
if (!isSelfTargetOrItem(event, enabledItems)) return clearChars();
event.preventDefault();
window.clearTimeout(cleanupTimeoutRef.current);
cleanupTimeoutRef.current = window.setTimeout(() => {
chars = "";
}, 500);
const char = event.key.toLowerCase();
chars += char;
enabledItems = getSameInitialItems(enabledItems, char, activeId);
const item = enabledItems.find((item2) => itemTextStartsWith(item2, chars));
if (item) {
store.move(item.id);
} else {
clearChars();
}
});
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
onKeyDownCapture
});
return removeUndefinedValues(props);
});
var CompositeTypeahead = forwardRef2(function CompositeTypeahead2(props) {
const htmlProps = useCompositeTypeahead(props);
return LMDWO4NN_createElement(T7VMP3TM_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/composite/typeahead.js
const typeahead_CompositeTypeahead = (0,external_wp_element_namespaceObject.forwardRef)(function CompositeTypeahead2(props, ref) {
var _props$store;
const context = context_useCompositeContext();
const store = (_props$store = props.store) !== null && _props$store !== void 0 ? _props$store : context.store;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeTypeahead, {
store,
...props,
ref
});
});
;// ./node_modules/@wordpress/components/build-module/composite/index.js
const composite_Composite = Object.assign((0,external_wp_element_namespaceObject.forwardRef)(function Composite2({
// Composite store props
activeId,
defaultActiveId,
setActiveId,
focusLoop = false,
focusWrap = false,
focusShift = false,
virtualFocus = false,
orientation = "both",
rtl = (0,external_wp_i18n_namespaceObject.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
});
const store = storeProp !== null && storeProp !== void 0 ? storeProp : internalStore;
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
store
}), [store]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Composite, {
disabled,
store,
...props,
ref,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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(group_CompositeGroup, {
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(group_label_CompositeGroupLabel, {
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(item_CompositeItem, {
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(row_CompositeRow, {
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(hover_CompositeHover, {
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(typeahead_CompositeTypeahead, {
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"
})
});
;// ./node_modules/@ariakit/core/esm/__chunks/RCQ5P4YE.js
"use client";
// src/disclosure/disclosure-store.ts
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 _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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/WYCIER3C.js
"use client";
// src/disclosure/disclosure-store.ts
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] = YV4JVR4I_useStore(createDisclosureStore, props);
return useDisclosureStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/core/esm/__chunks/FZZ2AVHF.js
"use client";
// src/dialog/dialog-store.ts
function createDialogStore(props = {}) {
return createDisclosureStore(props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/BM6PGYQY.js
"use client";
// src/dialog/dialog-store.ts
function useDialogStoreProps(store, update, props) {
return useDisclosureStoreProps(store, update, props);
}
function useDialogStore(props = {}) {
const [store, update] = YV4JVR4I_useStore(createDialogStore, props);
return useDialogStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/O2PQ2652.js
"use client";
// src/popover/popover-store.ts
function usePopoverStoreProps(store, update, props) {
useUpdateEffect(update, [props.popover]);
useStoreProps(store, props, "placement");
return useDialogStoreProps(store, update, props);
}
function usePopoverStore(props = {}) {
const [store, update] = useStore(Core.createPopoverStore, props);
return usePopoverStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/FTXTWCCT.js
"use client";
// src/hovercard/hovercard-store.ts
function useHovercardStoreProps(store, update, props) {
useStoreProps(store, props, "timeout");
useStoreProps(store, props, "showTimeout");
useStoreProps(store, props, "hideTimeout");
return usePopoverStoreProps(store, update, props);
}
function useHovercardStore(props = {}) {
const [store, update] = useStore(Core.createHovercardStore, props);
return useHovercardStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/core/esm/__chunks/ME2CUF3F.js
"use client";
// src/popover/popover-store.ts
function createPopoverStore(_a = {}) {
var _b = _a, {
popover: otherPopover
} = _b, props = _3YLGPPWQ_objRest(_b, [
"popover"
]);
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(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, props), { store }));
const placement = defaultValue(
props.placement,
syncState == null ? void 0 : syncState.placement,
"bottom"
);
const initialState = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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: Symbol("rendered")
});
const popover = createStore(initialState, dialog, store);
return _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, dialog), popover), {
setAnchorElement: (element) => popover.setState("anchorElement", element),
setPopoverElement: (element) => popover.setState("popoverElement", element),
setArrowElement: (element) => popover.setState("arrowElement", element),
render: () => popover.setState("rendered", Symbol("rendered"))
});
}
;// ./node_modules/@ariakit/core/esm/__chunks/JTLIIJ4U.js
"use client";
// src/hovercard/hovercard-store.ts
function createHovercardStore(props = {}) {
var _a;
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const popover = createPopoverStore(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, popover), hovercard), {
setAutoFocusOnShow: (value) => hovercard.setState("autoFocusOnShow", value)
});
}
;// ./node_modules/@ariakit/core/esm/tooltip/tooltip-store.js
"use client";
// src/tooltip/tooltip-store.ts
function createTooltipStore(props = {}) {
var _a;
if (false) {}
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
const hovercard = createHovercardStore(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 _chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, hovercard), tooltip);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/YTDK2NGG.js
"use client";
// src/tooltip/tooltip-store.ts
function useTooltipStoreProps(store, update, props) {
useStoreProps(store, props, "type");
useStoreProps(store, props, "skipTimeout");
return useHovercardStoreProps(store, update, props);
}
function useTooltipStore(props = {}) {
const [store, update] = YV4JVR4I_useStore(createTooltipStore, props);
return useTooltipStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/XL7CSKGW.js
"use client";
// src/role/role.tsx
var XL7CSKGW_TagName = "div";
var XL7CSKGW_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 LMDWO4NN_createElement(XL7CSKGW_TagName, props);
}
);
Object.assign(
Role,
XL7CSKGW_elements.reduce((acc, element) => {
acc[element] = forwardRef2(function Role3(props) {
return LMDWO4NN_createElement(element, props);
});
return acc;
}, {})
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/S6EF7IVO.js
"use client";
// src/disclosure/disclosure-context.tsx
var S6EF7IVO_ctx = createStoreContext();
var useDisclosureContext = S6EF7IVO_ctx.useContext;
var useDisclosureScopedContext = S6EF7IVO_ctx.useScopedContext;
var useDisclosureProviderContext = S6EF7IVO_ctx.useProviderContext;
var DisclosureContextProvider = S6EF7IVO_ctx.ContextProvider;
var DisclosureScopedContextProvider = S6EF7IVO_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/__chunks/RS7LB2H4.js
"use client";
// src/dialog/dialog-context.tsx
var RS7LB2H4_ctx = createStoreContext(
[DisclosureContextProvider],
[DisclosureScopedContextProvider]
);
var useDialogContext = RS7LB2H4_ctx.useContext;
var useDialogScopedContext = RS7LB2H4_ctx.useScopedContext;
var useDialogProviderContext = RS7LB2H4_ctx.useProviderContext;
var DialogContextProvider = RS7LB2H4_ctx.ContextProvider;
var DialogScopedContextProvider = RS7LB2H4_ctx.ScopedContextProvider;
var DialogHeadingContext = (0,external_React_.createContext)(void 0);
var DialogDescriptionContext = (0,external_React_.createContext)(void 0);
;// ./node_modules/@ariakit/react-core/esm/__chunks/MTZPJQMC.js
"use client";
// src/popover/popover-context.tsx
var MTZPJQMC_ctx = createStoreContext(
[DialogContextProvider],
[DialogScopedContextProvider]
);
var usePopoverContext = MTZPJQMC_ctx.useContext;
var usePopoverScopedContext = MTZPJQMC_ctx.useScopedContext;
var usePopoverProviderContext = MTZPJQMC_ctx.useProviderContext;
var PopoverContextProvider = MTZPJQMC_ctx.ContextProvider;
var PopoverScopedContextProvider = MTZPJQMC_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/__chunks/EM5CXX6A.js
"use client";
// src/hovercard/hovercard-context.tsx
var EM5CXX6A_ctx = createStoreContext(
[PopoverContextProvider],
[PopoverScopedContextProvider]
);
var useHovercardContext = EM5CXX6A_ctx.useContext;
var useHovercardScopedContext = EM5CXX6A_ctx.useScopedContext;
var useHovercardProviderContext = EM5CXX6A_ctx.useProviderContext;
var HovercardContextProvider = EM5CXX6A_ctx.ContextProvider;
var HovercardScopedContextProvider = EM5CXX6A_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/__chunks/BYC7LY2E.js
"use client";
// src/hovercard/hovercard-anchor.tsx
var BYC7LY2E_TagName = "a";
var useHovercardAnchor = createHook(
function useHovercardAnchor2(_a) {
var _b = _a, { store, showOnHover = true } = _b, props = __objRest(_b, ["store", "showOnHover"]);
const context = useHovercardProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const disabled = disabledFromProps(props);
const showTimeoutRef = (0,external_React_.useRef)(0);
(0,external_React_.useEffect)(() => () => window.clearTimeout(showTimeoutRef.current), []);
(0,external_React_.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,external_React_.useCallback)(
(element) => {
if (!store) return;
const { anchorElement } = store.getState();
if (anchorElement == null ? void 0 : anchorElement.isConnected) return;
store.setAnchorElement(element);
},
[store]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
ref: useMergeRefs(ref, props.ref),
onMouseMove,
onClick
});
props = useFocusable(props);
return props;
}
);
var HovercardAnchor = forwardRef2(function HovercardAnchor2(props) {
const htmlProps = useHovercardAnchor(props);
return LMDWO4NN_createElement(BYC7LY2E_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/F4IYJ42G.js
"use client";
// src/tooltip/tooltip-context.tsx
var F4IYJ42G_ctx = createStoreContext(
[HovercardContextProvider],
[HovercardScopedContextProvider]
);
var useTooltipContext = F4IYJ42G_ctx.useContext;
var useTooltipScopedContext = F4IYJ42G_ctx.useScopedContext;
var useTooltipProviderContext = F4IYJ42G_ctx.useProviderContext;
var TooltipContextProvider = F4IYJ42G_ctx.ContextProvider;
var TooltipScopedContextProvider = F4IYJ42G_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/tooltip/tooltip-anchor.js
"use client";
// src/tooltip/tooltip-anchor.tsx
var tooltip_anchor_TagName = "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(_a) {
var _b = _a, { store, showOnHover = true } = _b, props = __objRest(_b, ["store", "showOnHover"]);
const context = useTooltipProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const canShowOnHoverRef = (0,external_React_.useRef)(false);
(0,external_React_.useEffect)(() => {
return sync(store, ["mounted"], (state) => {
if (state.mounted) return;
canShowOnHoverRef.current = false;
});
}, [store]);
(0,external_React_.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 id = setTimeout(
createRemoveStoreCallback(store),
state.skipTimeout
);
return () => clearTimeout(id);
})
);
}, [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 _a2;
return (_a2 = state.contentElement) == null ? void 0 : _a2.id;
});
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
"aria-labelledby": type === "label" ? contentId : void 0
}, props), {
onMouseEnter,
onFocusVisible,
onBlur
});
props = useHovercardAnchor(_3YLGPPWQ_spreadValues({
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 LMDWO4NN_createElement(tooltip_anchor_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/X7QOZUD3.js
"use client";
// src/hovercard/utils/polygon.ts
function getEventPoint(event) {
return [event.clientX, event.clientY];
}
function isPointInPolygon(point, polygon) {
const [x, y] = point;
let inside = false;
const length = polygon.length;
for (let l = length, i = 0, j = l - 1; i < l; j = i++) {
const [xi, yi] = polygon[i];
const [xj, yj] = polygon[j];
const [, vy] = polygon[j === 0 ? l - 1 : j - 1] || [0, 0];
const where = (yi - yj) * (x - xi) - (xi - xj) * (y - yi);
if (yj < yi) {
if (y >= yj && y < yi) {
if (where === 0) return true;
if (where > 0) {
if (y === yj) {
if (y > vy) {
inside = !inside;
}
} else {
inside = !inside;
}
}
}
} else if (yi < yj) {
if (y > yi && y <= yj) {
if (where === 0) return true;
if (where < 0) {
if (y === yj) {
if (y < vy) {
inside = !inside;
}
} else {
inside = !inside;
}
}
}
} else if (y === yi && (x >= xj && x <= xi || x >= xi && x <= xj)) {
return true;
}
}
return inside;
}
function getEnterPointPlacement(enterPoint, rect) {
const { top, right, bottom, left } = rect;
const [x, y] = enterPoint;
const placementX = x < left ? "left" : x > right ? "right" : null;
const placementY = y < top ? "top" : y > bottom ? "bottom" : null;
return [placementX, placementY];
}
function getElementPolygon(element, enterPoint) {
const rect = element.getBoundingClientRect();
const { top, right, bottom, left } = rect;
const [x, y] = getEnterPointPlacement(enterPoint, rect);
const polygon = [enterPoint];
if (x) {
if (y !== "top") {
polygon.push([x === "left" ? left : right, top]);
}
polygon.push([x === "left" ? right : left, top]);
polygon.push([x === "left" ? right : left, bottom]);
if (y !== "bottom") {
polygon.push([x === "left" ? left : right, bottom]);
}
} else if (y === "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/63XF7ACK.js
"use client";
// src/dialog/utils/is-backdrop.ts
function _63XF7ACK_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((id) => backdrop === id);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/K2ZF5NU7.js
"use client";
// src/dialog/utils/orchestrate.ts
var cleanups = /* @__PURE__ */ new WeakMap();
function orchestrate(element, key, setup) {
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, setup());
return () => {
var _a;
(_a = elementCleanups.get(key)) == null ? void 0 : _a();
elementCleanups.delete(key);
};
}
const cleanup = setup();
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 setup = () => {
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, setup);
}
function setProperty(element, property, value) {
const setup = () => {
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, setup);
}
function assignStyle(element, style) {
if (!element) return () => {
};
const setup = () => {
const prevStyle = element.style.cssText;
Object.assign(element.style, style);
return () => {
element.style.cssText = prevStyle;
};
};
return orchestrate(element, "style", setup);
}
function setCSSProperty(element, property, value) {
if (!element) return () => {
};
const setup = () => {
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, setup);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/AOUGVQZ3.js
"use client";
// src/dialog/utils/walk-tree-outside.ts
var ignoreTags = ["SCRIPT", "STYLE"];
function getSnapshotPropertyName(id) {
return `__ariakit-dialog-snapshot-${id}`;
}
function inSnapshot(id, element) {
const doc = getDocument(element);
const propertyName = getSnapshotPropertyName(id);
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 isValidElement(id, element, ignoredElements) {
if (ignoreTags.includes(element.tagName)) return false;
if (!inSnapshot(id, element)) return false;
return !ignoredElements.some(
(enabledElement) => enabledElement && contains(element, enabledElement)
);
}
function AOUGVQZ3_walkTreeOutside(id, elements, callback, ancestorCallback) {
for (let element of elements) {
if (!(element == null ? void 0 : element.isConnected)) continue;
const hasAncestorAlready = elements.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 (isValidElement(id, child, elements)) {
callback(child, originalElement);
}
}
}
element = element.parentElement;
}
}
}
function createWalkTreeSnapshot(id, elements) {
const { body } = getDocument(elements[0]);
const cleanups = [];
const markElement = (element) => {
cleanups.push(setProperty(element, getSnapshotPropertyName(id), true));
};
AOUGVQZ3_walkTreeOutside(id, elements, markElement);
return chain(setProperty(body, getSnapshotPropertyName(id), true), () => {
for (const cleanup of cleanups) {
cleanup();
}
});
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/2PGBN2Y4.js
"use client";
// src/dialog/utils/mark-tree-outside.ts
function getPropertyName(id = "", ancestor = false) {
return `__ariakit-dialog-${ancestor ? "ancestor" : "outside"}${id ? `-${id}` : ""}`;
}
function markElement(element, id = "") {
return chain(
setProperty(element, getPropertyName(), true),
setProperty(element, getPropertyName(id), true)
);
}
function markAncestor(element, id = "") {
return chain(
setProperty(element, getPropertyName("", true), true),
setProperty(element, getPropertyName(id, true), true)
);
}
function isElementMarked(element, id) {
const ancestorProperty = getPropertyName(id, true);
if (element[ancestorProperty]) return true;
const elementProperty = getPropertyName(id);
do {
if (element[elementProperty]) return true;
if (!element.parentElement) return false;
element = element.parentElement;
} while (true);
}
function markTreeOutside(id, elements) {
const cleanups = [];
const ids = elements.map((el) => el == null ? void 0 : el.id);
AOUGVQZ3_walkTreeOutside(
id,
elements,
(element) => {
if (_63XF7ACK_isBackdrop(element, ...ids)) return;
cleanups.unshift(markElement(element, id));
},
(ancestor, element) => {
const isAnotherDialogAncestor = element.hasAttribute("data-dialog") && element.id !== id;
if (isAnotherDialogAncestor) return;
cleanups.unshift(markAncestor(ancestor, id));
}
);
const restoreAccessibilityTree = () => {
for (const cleanup of cleanups) {
cleanup();
}
};
return restoreAccessibilityTree;
}
;// external "ReactDOM"
const external_ReactDOM_namespaceObject = window["ReactDOM"];
;// ./node_modules/@ariakit/react-core/esm/__chunks/VGCJ63VH.js
"use client";
// src/disclosure/disclosure-content.tsx
var VGCJ63VH_TagName = "div";
function afterTimeout(timeoutMs, cb) {
const timeoutId = setTimeout(cb, timeoutMs);
return () => clearTimeout(timeoutId);
}
function VGCJ63VH_afterPaint(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(_a) {
var _b = _a, { store, alwaysVisible } = _b, props = __objRest(_b, ["store", "alwaysVisible"]);
const context = useDisclosureProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const ref = (0,external_React_.useRef)(null);
const id = useId(props.id);
const [transition, setTransition] = (0,external_React_.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 VGCJ63VH_afterPaint(() => {
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,external_ReactDOM_namespaceObject.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 delay = parseCSSTime(
transitionDelay,
animationDelay,
transitionDelay2,
animationDelay2
);
const duration = parseCSSTime(
transitionDuration,
animationDuration,
transitionDuration2,
animationDuration2
);
const timeout = delay + 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,external_ReactJSXRuntime_namespaceObject.jsx)(DialogScopedContextProvider, { value: store, children: element }),
[store]
);
const hidden = isHidden(mounted, props.hidden, alwaysVisible);
const styleProp = props.style;
const style = (0,external_React_.useMemo)(() => {
if (hidden) {
return _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, styleProp), { display: "none" });
}
return styleProp;
}, [hidden, styleProp]);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
"data-open": open || void 0,
"data-enter": transition === "enter" || void 0,
"data-leave": transition === "leave" || void 0,
hidden
}, props), {
ref: useMergeRefs(id ? store.setContentElement : null, ref, props.ref),
style
});
return removeUndefinedValues(props);
});
var DisclosureContentImpl = forwardRef2(function DisclosureContentImpl2(props) {
const htmlProps = useDisclosureContent(props);
return LMDWO4NN_createElement(VGCJ63VH_TagName, htmlProps);
});
var DisclosureContent = forwardRef2(function DisclosureContent2(_a) {
var _b = _a, {
unmountOnHide
} = _b, props = __objRest(_b, [
"unmountOnHide"
]);
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,external_ReactJSXRuntime_namespaceObject.jsx)(DisclosureContentImpl, _3YLGPPWQ_spreadValues({}, props));
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/63FEHJZV.js
"use client";
// src/dialog/dialog-backdrop.tsx
function DialogBackdrop({
store,
backdrop,
alwaysVisible,
hidden
}) {
const ref = (0,external_React_.useRef)(null);
const disclosure = useDisclosureStore({ disclosure: store });
const contentElement = useStoreState(store, "contentElement");
(0,external_React_.useEffect)(() => {
const backdrop2 = ref.current;
const dialog = contentElement;
if (!backdrop2) return;
if (!dialog) return;
backdrop2.style.zIndex = getComputedStyle(dialog).zIndex;
}, [contentElement]);
useSafeLayoutEffect(() => {
const id = contentElement == null ? void 0 : contentElement.id;
if (!id) return;
const backdrop2 = ref.current;
if (!backdrop2) return;
return markAncestor(backdrop2, id);
}, [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,external_React_.isValidElement)(backdrop)) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Role, _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { render: backdrop }));
}
const Component = typeof backdrop !== "boolean" ? backdrop : "div";
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Role, _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {}) }));
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/IGR4SXG2.js
"use client";
// src/dialog/utils/is-focus-trap.ts
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((id) => attr === id);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/ESSM74HH.js
"use client";
// src/dialog/utils/disable-accessibility-tree-outside.ts
function hideElementFromAccessibilityTree(element) {
return setAttribute(element, "aria-hidden", "true");
}
function disableAccessibilityTreeOutside(id, elements) {
const cleanups = [];
const ids = elements.map((el) => el == null ? void 0 : el.id);
walkTreeOutside(id, elements, (element) => {
if (isBackdrop(element, ...ids)) return;
cleanups.unshift(hideElementFromAccessibilityTree(element));
});
const restoreAccessibilityTree = () => {
for (const cleanup of cleanups) {
cleanup();
}
};
return restoreAccessibilityTree;
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/677M2CI3.js
"use client";
// src/dialog/utils/supports-inert.ts
function supportsInert() {
return "inert" in HTMLElement.prototype;
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/KZAQFFOU.js
"use client";
// src/dialog/utils/disable-tree.ts
function disableTree(element, ignoredElements) {
if (!("style" in element)) return PBFD2E7P_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 PBFD2E7P_noop;
const restoreFocusMethod = orchestrate(element2, "focus", () => {
element2.focus = PBFD2E7P_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(id, elements) {
const cleanups = [];
const ids = elements.map((el) => el == null ? void 0 : el.id);
AOUGVQZ3_walkTreeOutside(
id,
elements,
(element) => {
if (_63XF7ACK_isBackdrop(element, ...ids)) return;
if (isFocusTrap(element, ...ids)) return;
cleanups.unshift(disableTree(element, elements));
},
(element) => {
if (!element.hasAttribute("role")) return;
if (elements.some((el) => el && contains(el, element))) return;
cleanups.unshift(setAttribute(element, "role", "none"));
}
);
const restoreTreeOutside = () => {
for (const cleanup of cleanups) {
cleanup();
}
};
return restoreTreeOutside;
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/YKJECYU7.js
"use client";
// src/dialog/utils/use-root-dialog.ts
function useRootDialog({
attribute,
contentId,
contentElement,
enabled
}) {
const [updated, retry] = useForceUpdate();
const isRootDialog = (0,external_React_.useCallback)(() => {
if (!enabled) return false;
if (!contentElement) return false;
const { body } = getDocument(contentElement);
const id = body.getAttribute(attribute);
return !id || id === contentId;
}, [updated, enabled, contentElement, attribute, contentId]);
(0,external_React_.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,external_ReactDOM_namespaceObject.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/BGQ3KQ5M.js
"use client";
// src/dialog/utils/use-prevent-body-scroll.ts
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,external_React_.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) : 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, scrollY, 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: `${-(scrollY - Math.floor(offsetTop))}px`,
left: `${-(scrollX - Math.floor(offsetLeft))}px`,
right: "0",
[paddingProperty]: `${scrollbarWidth}px`
});
return () => {
restoreStyle();
if (true) {
win.scrollTo({ left: scrollX, top: scrollY, behavior: "instant" });
}
};
};
const isIOS = isApple() && !isMac();
return chain(
setScrollbarWidthProperty(),
isIOS ? setIOSStyle() : setStyle()
);
}, [isRootDialog, contentElement]);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/TOU75OXH.js
"use client";
// src/dialog/utils/use-nested-dialogs.tsx
var NestedDialogsContext = (0,external_React_.createContext)({});
function useNestedDialogs(store) {
const context = (0,external_React_.useContext)(NestedDialogsContext);
const [dialogs, setDialogs] = (0,external_React_.useState)([]);
const add = (0,external_React_.useCallback)(
(dialog) => {
var _a;
setDialogs((dialogs2) => [...dialogs2, dialog]);
return chain((_a = context.add) == null ? void 0 : _a.call(context, dialog), () => {
setDialogs((dialogs2) => dialogs2.filter((d) => d !== 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,external_React_.useMemo)(() => ({ store, add }), [store, add]);
const wrapElement = (0,external_React_.useCallback)(
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NestedDialogsContext.Provider, { value: providerValue, children: element }),
[providerValue]
);
return { wrapElement, nestedDialogs: dialogs };
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/HLTQOHKZ.js
"use client";
// src/dialog/utils/use-previous-mouse-down-ref.ts
function usePreviousMouseDownRef(enabled) {
const previousMouseDownRef = (0,external_React_.useRef)();
(0,external_React_.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/WBDYNH73.js
"use client";
// src/dialog/utils/use-hide-on-interact-outside.ts
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,external_React_.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,external_React_.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(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, 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(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, 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(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
type: "contextmenu",
listener: (event) => {
if (!shouldHideOnInteractOutside(hideOnInteractOutside, event)) return;
store.hide();
}
}));
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/6GXEOXGT.js
"use client";
// src/dialog/utils/prepend-hidden-dismiss.ts
function prependHiddenDismiss(container, onClick) {
const document = getDocument(container);
const button = document.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/ZWYATQFU.js
"use client";
// src/focusable/focusable-container.tsx
var ZWYATQFU_TagName = "div";
var useFocusableContainer = createHook(function useFocusableContainer2(_a) {
var _b = _a, { autoFocusOnShow = true } = _b, props = __objRest(_b, ["autoFocusOnShow"]);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FocusableContext.Provider, { value: autoFocusOnShow, children: element }),
[autoFocusOnShow]
);
return props;
});
var FocusableContainer = forwardRef2(function FocusableContainer2(props) {
const htmlProps = useFocusableContainer(props);
return LMDWO4NN_createElement(ZWYATQFU_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/CZ4GFWYL.js
"use client";
// src/heading/heading-context.tsx
var HeadingContext = (0,external_React_.createContext)(0);
;// ./node_modules/@ariakit/react-core/esm/__chunks/5M6RIVE2.js
"use client";
// src/heading/heading-level.tsx
function HeadingLevel({ level, children }) {
const contextLevel = (0,external_React_.useContext)(HeadingContext);
const nextLevel = Math.max(
Math.min(level || contextLevel + 1, 6),
1
);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(HeadingContext.Provider, { value: nextLevel, children });
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/XX67R432.js
"use client";
// src/visually-hidden/visually-hidden.tsx
var XX67R432_TagName = "span";
var useVisuallyHidden = createHook(
function useVisuallyHidden2(props) {
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
style: _3YLGPPWQ_spreadValues({
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 LMDWO4NN_createElement(XX67R432_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/W3VI7GFU.js
"use client";
// src/focus-trap/focus-trap.tsx
var W3VI7GFU_TagName = "span";
var useFocusTrap = createHook(
function useFocusTrap2(props) {
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
"data-focus-trap": "",
tabIndex: 0,
"aria-hidden": true
}, props), {
style: _3YLGPPWQ_spreadValues({
// 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 LMDWO4NN_createElement(W3VI7GFU_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/AOQQTIBO.js
"use client";
// src/portal/portal-context.tsx
var PortalContext = (0,external_React_.createContext)(null);
;// ./node_modules/@ariakit/react-core/esm/__chunks/O37CNYMR.js
"use client";
// src/portal/portal.tsx
var O37CNYMR_TagName = "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(prefix = "id") {
return `${prefix ? `${prefix}-` : ""}${Math.random().toString(36).slice(2, 8)}`;
}
function queueFocus(element) {
queueMicrotask(() => {
element == null ? void 0 : element.focus();
});
}
var usePortal = createHook(function usePortal2(_a) {
var _b = _a, {
preserveTabOrder,
preserveTabOrderAnchor,
portalElement,
portalRef,
portal = true
} = _b, props = __objRest(_b, [
"preserveTabOrder",
"preserveTabOrderAnchor",
"portalElement",
"portalRef",
"portal"
]);
const ref = (0,external_React_.useRef)(null);
const refProp = useMergeRefs(ref, props.ref);
const context = (0,external_React_.useContext)(PortalContext);
const [portalNode, setPortalNode] = (0,external_React_.useState)(null);
const [anchorPortalNode, setAnchorPortalNode] = (0,external_React_.useState)(
null
);
const outerBeforeRef = (0,external_React_.useRef)(null);
const innerBeforeRef = (0,external_React_.useRef)(null);
const innerAfterRef = (0,external_React_.useRef)(null);
const outerAfterRef = (0,external_React_.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,external_React_.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,external_ReactJSXRuntime_namespaceObject.jsx)(PortalContext.Provider, { value: portalNode || context, children: element });
if (!portal) return element;
if (!portalNode) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
"span",
{
ref: refProp,
id: props.id,
style: { position: "fixed" },
hidden: true
}
);
}
element = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { children: [
preserveTabOrder && portalNode && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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,external_ReactJSXRuntime_namespaceObject.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,external_ReactDOM_namespaceObject.createPortal)(element, portalNode);
}
let preserveTabOrderElement = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { children: [
preserveTabOrder && portalNode && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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,external_ReactJSXRuntime_namespaceObject.jsx)("span", { "aria-owns": portalNode == null ? void 0 : portalNode.id, style: { position: "fixed" } }),
preserveTabOrder && portalNode && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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 _a2;
return (_a2 = getNextTabbable()) == null ? void 0 : _a2.focus();
});
return;
}
queueFocus(nextTabbable);
}
}
}
)
] });
if (anchorPortalNode && preserveTabOrder) {
preserveTabOrderElement = (0,external_ReactDOM_namespaceObject.createPortal)(
preserveTabOrderElement,
anchorPortalNode
);
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { children: [
preserveTabOrderElement,
element
] });
},
[portalNode, context, portal, props.id, preserveTabOrder, anchorPortalNode]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
ref: refProp
});
return props;
});
var Portal = forwardRef2(function Portal2(props) {
const htmlProps = usePortal(props);
return LMDWO4NN_createElement(O37CNYMR_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/JC64G2H7.js
"use client";
// src/dialog/dialog.tsx
var JC64G2H7_TagName = "div";
var JC64G2H7_isSafariBrowser = 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(_a) {
var _b = _a, {
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
} = _b, props = __objRest(_b, [
"store",
"open",
"onClose",
"focusable",
"modal",
"portal",
"backdrop",
"hideOnEscape",
"hideOnInteractOutside",
"getPersistentElements",
"preventBodyScroll",
"autoFocusOnShow",
"autoFocusOnHide",
"initialFocus",
"finalFocus",
"unmountOnHide",
"unstable_treeSnapshotKey"
]);
const context = useDialogProviderContext();
const ref = (0,external_React_.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 id = 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, id, 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 (JC64G2H7_isSafariBrowser) {
(0,external_React_.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 options = { capture: true, once: true };
disclosureElement.addEventListener("focusin", onFocus, options);
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,external_React_.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 _a2, _b2;
const height = (_b2 = (_a2 = win.visualViewport) == null ? void 0 : _a2.height) != null ? _b2 : win.innerHeight;
dialog.style.setProperty("--dialog-viewport-height", `${height}px`);
};
setViewportHeight();
viewport.addEventListener("resize", setViewportHeight);
return () => {
viewport.removeEventListener("resize", setViewportHeight);
};
}, [mounted, domReady]);
(0,external_React_.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 (!id) return;
if (!canTakeTreeSnapshot) return;
const dialog = ref.current;
return createWalkTreeSnapshot(id, [dialog]);
}, [id, canTakeTreeSnapshot, unstable_treeSnapshotKey]);
const getPersistentElementsProp = useEvent(getPersistentElements);
useSafeLayoutEffect(() => {
if (!id) 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(id, allElements),
disableTreeOutside(id, allElements)
);
}
return markTreeOutside(id, [disclosureElement, ...allElements]);
}, [
id,
store,
canTakeTreeSnapshot,
getPersistentElementsProp,
nestedDialogs,
modal,
unstable_treeSnapshotKey
]);
const mayAutoFocusOnShow = !!autoFocusOnShow;
const autoFocusOnShowProp = useBooleanEvent(autoFocusOnShow);
const [autoFocusEnabled, setAutoFocusEnabled] = (0,external_React_.useState)(false);
(0,external_React_.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 (!JC64G2H7_isSafariBrowser) 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,external_React_.useState)(false);
(0,external_React_.useEffect)(() => {
if (!open) return;
setHasOpened(true);
return () => setHasOpened(false);
}, [open]);
const focusOnHide = (0,external_React_.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 selector = `[aria-activedescendant="${element.id}"]`;
const composite = doc.querySelector(selector);
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 selector = `[aria-controls~="${maybeParentDialog.id}"]`;
const control = doc.querySelector(selector);
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();
},
[store, finalFocus, autoFocusOnHideProp]
);
const focusedOnHideRef = (0,external_React_.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,external_React_.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,external_React_.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,external_ReactJSXRuntime_namespaceObject.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,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { children: [
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
DialogBackdrop,
{
store,
backdrop,
hidden: hiddenProp,
alwaysVisible
}
),
element
] });
},
[store, backdrop, hiddenProp, alwaysVisible]
);
const [headingId, setHeadingId] = (0,external_React_.useState)();
const [descriptionId, setDescriptionId] = (0,external_React_.useState)();
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DialogScopedContextProvider, { value: store, children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DialogHeadingContext.Provider, { value: setHeadingId, children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DialogDescriptionContext.Provider, { value: setDescriptionId, children: element }) }) }),
[store]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
"data-dialog": "",
role: "dialog",
tabIndex: focusable ? -1 : void 0,
"aria-labelledby": headingId,
"aria-describedby": descriptionId
}, props), {
ref: useMergeRefs(ref, props.ref)
});
props = useFocusableContainer(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
autoFocusOnShow: autoFocusEnabled
}));
props = useDisclosureContent(_3YLGPPWQ_spreadValues({ store }, props));
props = useFocusable(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { focusable }));
props = usePortal(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({ portal }, props), { portalRef, preserveTabOrder }));
return props;
});
function createDialogComponent(Component, 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,external_ReactJSXRuntime_namespaceObject.jsx)(Component, _3YLGPPWQ_spreadValues({}, props));
});
}
var Dialog = createDialogComponent(
forwardRef2(function Dialog2(props) {
const htmlProps = useDialog(props);
return LMDWO4NN_createElement(JC64G2H7_TagName, htmlProps);
}),
useDialogProviderContext
);
;// ./node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
const floating_ui_utils_sides = (/* unused pure expression or super */ null && (['top', 'right', 'bottom', 'left']));
const alignments = (/* unused pure expression or super */ null && (['start', 'end']));
const floating_ui_utils_placements = /*#__PURE__*/(/* unused pure expression or super */ null && (floating_ui_utils_sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), [])));
const floating_ui_utils_min = Math.min;
const floating_ui_utils_max = Math.max;
const round = Math.round;
const floor = Math.floor;
const createCoords = v => ({
x: v,
y: v
});
const oppositeSideMap = {
left: 'right',
right: 'left',
bottom: 'top',
top: 'bottom'
};
const oppositeAlignmentMap = {
start: 'end',
end: 'start'
};
function clamp(start, value, end) {
return floating_ui_utils_max(start, floating_ui_utils_min(value, end));
}
function floating_ui_utils_evaluate(value, param) {
return typeof value === 'function' ? value(param) : value;
}
function floating_ui_utils_getSide(placement) {
return placement.split('-')[0];
}
function floating_ui_utils_getAlignment(placement) {
return placement.split('-')[1];
}
function getOppositeAxis(axis) {
return axis === 'x' ? 'y' : 'x';
}
function getAxisLength(axis) {
return axis === 'y' ? 'height' : 'width';
}
function floating_ui_utils_getSideAxis(placement) {
return ['top', 'bottom'].includes(floating_ui_utils_getSide(placement)) ? 'y' : 'x';
}
function getAlignmentAxis(placement) {
return getOppositeAxis(floating_ui_utils_getSideAxis(placement));
}
function floating_ui_utils_getAlignmentSides(placement, rects, rtl) {
if (rtl === void 0) {
rtl = false;
}
const alignment = floating_ui_utils_getAlignment(placement);
const alignmentAxis = getAlignmentAxis(placement);
const length = getAxisLength(alignmentAxis);
let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
if (rects.reference[length] > rects.floating[length]) {
mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
}
return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
}
function getExpandedPlacements(placement) {
const oppositePlacement = getOppositePlacement(placement);
return [floating_ui_utils_getOppositeAlignmentPlacement(placement), oppositePlacement, floating_ui_utils_getOppositeAlignmentPlacement(oppositePlacement)];
}
function floating_ui_utils_getOppositeAlignmentPlacement(placement) {
return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
}
function getSideList(side, isStart, rtl) {
const lr = ['left', 'right'];
const rl = ['right', 'left'];
const tb = ['top', 'bottom'];
const bt = ['bottom', 'top'];
switch (side) {
case 'top':
case 'bottom':
if (rtl) return isStart ? rl : lr;
return isStart ? lr : rl;
case 'left':
case 'right':
return isStart ? tb : bt;
default:
return [];
}
}
function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
const alignment = floating_ui_utils_getAlignment(placement);
let list = getSideList(floating_ui_utils_getSide(placement), direction === 'start', rtl);
if (alignment) {
list = list.map(side => side + "-" + alignment);
if (flipAlignment) {
list = list.concat(list.map(floating_ui_utils_getOppositeAlignmentPlacement));
}
}
return list;
}
function getOppositePlacement(placement) {
return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
}
function expandPaddingObject(padding) {
return {
top: 0,
right: 0,
bottom: 0,
left: 0,
...padding
};
}
function floating_ui_utils_getPaddingObject(padding) {
return typeof padding !== 'number' ? expandPaddingObject(padding) : {
top: padding,
right: padding,
bottom: padding,
left: padding
};
}
function floating_ui_utils_rectToClientRect(rect) {
return {
...rect,
top: rect.y,
left: rect.x,
right: rect.x + rect.width,
bottom: rect.y + rect.height
};
}
;// ./node_modules/@floating-ui/core/dist/floating-ui.core.mjs
function computeCoordsFromPlacement(_ref, placement, rtl) {
let {
reference,
floating
} = _ref;
const sideAxis = floating_ui_utils_getSideAxis(placement);
const alignmentAxis = getAlignmentAxis(placement);
const alignLength = getAxisLength(alignmentAxis);
const side = floating_ui_utils_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 (floating_ui_utils_getAlignment(placement)) {
case 'start':
coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
break;
case 'end':
coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
break;
}
return coords;
}
/**
* Computes the `x` and `y` coordinates that will place the floating element
* next to a reference element when it is given a certain positioning strategy.
*
* This export does not have any `platform` interface logic. You will need to
* write one for the platform you are using Floating UI with.
*/
const computePosition = async (reference, floating, config) => {
const {
placement = 'bottom',
strategy = 'absolute',
middleware = [],
platform
} = config;
const validMiddleware = middleware.filter(Boolean);
const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
let rects = await platform.getElementRects({
reference,
floating,
strategy
});
let {
x,
y
} = computeCoordsFromPlacement(rects, placement, rtl);
let statefulPlacement = placement;
let middlewareData = {};
let resetCount = 0;
for (let i = 0; i < validMiddleware.length; i++) {
const {
name,
fn
} = validMiddleware[i];
const {
x: nextX,
y: nextY,
data,
reset
} = await fn({
x,
y,
initialPlacement: placement,
placement: statefulPlacement,
strategy,
middlewareData,
rects,
platform,
elements: {
reference,
floating
}
});
x = nextX != null ? nextX : x;
y = nextY != null ? nextY : y;
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 platform.getElementRects({
reference,
floating,
strategy
}) : reset.rects;
}
({
x,
y
} = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
}
i = -1;
continue;
}
}
return {
x,
y,
placement: statefulPlacement,
strategy,
middlewareData
};
};
/**
* Resolves with an object of overflow side offsets that determine how much the
* element is overflowing a given clipping boundary on each side.
* - positive = overflowing the boundary by that number of pixels
* - negative = how many pixels left before it will overflow
* - 0 = lies flush with the boundary
* @see https://floating-ui.com/docs/detectOverflow
*/
async function detectOverflow(state, options) {
var _await$platform$isEle;
if (options === void 0) {
options = {};
}
const {
x,
y,
platform,
rects,
elements,
strategy
} = state;
const {
boundary = 'clippingAncestors',
rootBoundary = 'viewport',
elementContext = 'floating',
altBoundary = false,
padding = 0
} = floating_ui_utils_evaluate(options, state);
const paddingObject = floating_ui_utils_getPaddingObject(padding);
const altContext = elementContext === 'floating' ? 'reference' : 'floating';
const element = elements[altBoundary ? altContext : elementContext];
const clippingClientRect = floating_ui_utils_rectToClientRect(await platform.getClippingRect({
element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
boundary,
rootBoundary,
strategy
}));
const rect = elementContext === 'floating' ? {
...rects.floating,
x,
y
} : rects.reference;
const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
x: 1,
y: 1
} : {
x: 1,
y: 1
};
const elementClientRect = floating_ui_utils_rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
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
};
}
/**
* Provides data to position an inner element of the floating element so that it
* appears centered to the reference element.
* @see https://floating-ui.com/docs/arrow
*/
const arrow = options => ({
name: 'arrow',
options,
async fn(state) {
const {
x,
y,
placement,
rects,
platform,
elements,
middlewareData
} = state;
// Since `element` is required, we don't Partial<> the type.
const {
element,
padding = 0
} = floating_ui_utils_evaluate(options, state) || {};
if (element == null) {
return {};
}
const paddingObject = floating_ui_utils_getPaddingObject(padding);
const coords = {
x,
y
};
const axis = getAlignmentAxis(placement);
const length = getAxisLength(axis);
const arrowDimensions = await platform.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[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
const startDiff = coords[axis] - rects.reference[axis];
const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
// DOM platform can return `window` as the `offsetParent`.
if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {
clientSize = elements.floating[clientProp] || rects.floating[length];
}
const centerToReference = endDiff / 2 - startDiff / 2;
// If the padding is large enough that it causes the arrow to no longer be
// centered, modify the padding so that it is centered.
const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
const minPadding = floating_ui_utils_min(paddingObject[minProp], largestPossiblePadding);
const maxPadding = floating_ui_utils_min(paddingObject[maxProp], largestPossiblePadding);
// Make sure the arrow doesn't overflow the floating element if the center
// point is outside the floating element's bounds.
const min$1 = minPadding;
const max = clientSize - arrowDimensions[length] - maxPadding;
const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
const offset = clamp(min$1, center, max);
// If the reference is small enough that the arrow's padding causes it to
// to point to nothing for an aligned placement, adjust the offset of the
// floating element itself. To ensure `shift()` continues to take action,
// a single reset is performed when this is true.
const shouldAddOffset = !middlewareData.arrow && floating_ui_utils_getAlignment(placement) != null && center != offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
return {
[axis]: coords[axis] + alignmentOffset,
data: {
[axis]: offset,
centerOffset: center - offset - alignmentOffset,
...(shouldAddOffset && {
alignmentOffset
})
},
reset: shouldAddOffset
};
}
});
function getPlacementList(alignment, autoAlignment, allowedPlacements) {
const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);
return allowedPlacementsSortedByAlignment.filter(placement => {
if (alignment) {
return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);
}
return true;
});
}
/**
* Optimizes the visibility of the floating element by choosing the placement
* that has the most space available automatically, without needing to specify a
* preferred placement. Alternative to `flip`.
* @see https://floating-ui.com/docs/autoPlacement
*/
const autoPlacement = function (options) {
if (options === void 0) {
options = {};
}
return {
name: 'autoPlacement',
options,
async fn(state) {
var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
const {
rects,
middlewareData,
placement,
platform,
elements
} = state;
const {
crossAxis = false,
alignment,
allowedPlacements = placements,
autoAlignment = true,
...detectOverflowOptions
} = evaluate(options, state);
const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
const overflow = await detectOverflow(state, detectOverflowOptions);
const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
const currentPlacement = placements$1[currentIndex];
if (currentPlacement == null) {
return {};
}
const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
// Make `computeCoords` start from the right place.
if (placement !== currentPlacement) {
return {
reset: {
placement: placements$1[0]
}
};
}
const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {
placement: currentPlacement,
overflows: currentOverflows
}];
const nextPlacement = placements$1[currentIndex + 1];
// There are more placements to check.
if (nextPlacement) {
return {
data: {
index: currentIndex + 1,
overflows: allOverflows
},
reset: {
placement: nextPlacement
}
};
}
const placementsSortedByMostSpace = allOverflows.map(d => {
const alignment = getAlignment(d.placement);
return [d.placement, alignment && crossAxis ?
// Check along the mainAxis and main crossAxis side.
d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :
// Check only the mainAxis.
d.overflows[0], d.overflows];
}).sort((a, b) => a[1] - b[1]);
const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,
// Aligned placements should not check their opposite crossAxis
// side.
getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));
const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
if (resetPlacement !== placement) {
return {
data: {
index: currentIndex + 1,
overflows: allOverflows
},
reset: {
placement: resetPlacement
}
};
}
return {};
}
};
};
/**
* Optimizes the visibility of the floating element by flipping the `placement`
* in order to keep it in view when the preferred placement(s) will overflow the
* clipping boundary. Alternative to `autoPlacement`.
* @see https://floating-ui.com/docs/flip
*/
const flip = function (options) {
if (options === void 0) {
options = {};
}
return {
name: 'flip',
options,
async fn(state) {
var _middlewareData$arrow, _middlewareData$flip;
const {
placement,
middlewareData,
rects,
initialPlacement,
platform,
elements
} = state;
const {
mainAxis: checkMainAxis = true,
crossAxis: checkCrossAxis = true,
fallbackPlacements: specifiedFallbackPlacements,
fallbackStrategy = 'bestFit',
fallbackAxisSideDirection = 'none',
flipAlignment = true,
...detectOverflowOptions
} = floating_ui_utils_evaluate(options, state);
// If a reset by the arrow was caused due to an alignment offset being
// added, we should skip any logic now since `flip()` has already done its
// work.
// https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643
if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
return {};
}
const side = floating_ui_utils_getSide(placement);
const isBasePlacement = floating_ui_utils_getSide(initialPlacement) === initialPlacement;
const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {
fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
}
const placements = [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 sides = floating_ui_utils_getAlignmentSides(placement, rects, rtl);
overflows.push(overflow[sides[0]], overflow[sides[1]]);
}
overflowsData = [...overflowsData, {
placement,
overflows
}];
// One or more sides is overflowing.
if (!overflows.every(side => side <= 0)) {
var _middlewareData$flip2, _overflowsData$filter;
const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
const nextPlacement = placements[nextIndex];
if (nextPlacement) {
// Try next placement and re-run the lifecycle.
return {
data: {
index: nextIndex,
overflows: overflowsData
},
reset: {
placement: nextPlacement
}
};
}
// First, find the candidates that fit on the mainAxis side of overflow,
// then find the placement that fits the best on the main crossAxis side.
let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
// Otherwise fallback.
if (!resetPlacement) {
switch (fallbackStrategy) {
case 'bestFit':
{
var _overflowsData$map$so;
const placement = (_overflowsData$map$so = overflowsData.map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
if (placement) {
resetPlacement = placement;
}
break;
}
case 'initialPlacement':
resetPlacement = initialPlacement;
break;
}
}
if (placement !== resetPlacement) {
return {
reset: {
placement: resetPlacement
}
};
}
}
return {};
}
};
};
function getSideOffsets(overflow, rect) {
return {
top: overflow.top - rect.height,
right: overflow.right - rect.width,
bottom: overflow.bottom - rect.height,
left: overflow.left - rect.width
};
}
function isAnySideFullyClipped(overflow) {
return sides.some(side => overflow[side] >= 0);
}
/**
* Provides data to hide the floating element in applicable situations, such as
* when it is not in the same clipping context as the reference element.
* @see https://floating-ui.com/docs/hide
*/
const hide = function (options) {
if (options === void 0) {
options = {};
}
return {
name: 'hide',
options,
async fn(state) {
const {
rects
} = state;
const {
strategy = 'referenceHidden',
...detectOverflowOptions
} = evaluate(options, state);
switch (strategy) {
case 'referenceHidden':
{
const overflow = await detectOverflow(state, {
...detectOverflowOptions,
elementContext: 'reference'
});
const offsets = getSideOffsets(overflow, rects.reference);
return {
data: {
referenceHiddenOffsets: offsets,
referenceHidden: isAnySideFullyClipped(offsets)
}
};
}
case 'escaped':
{
const overflow = await detectOverflow(state, {
...detectOverflowOptions,
altBoundary: true
});
const offsets = getSideOffsets(overflow, rects.floating);
return {
data: {
escapedOffsets: offsets,
escaped: isAnySideFullyClipped(offsets)
}
};
}
default:
{
return {};
}
}
}
};
};
function getBoundingRect(rects) {
const minX = min(...rects.map(rect => rect.left));
const minY = min(...rects.map(rect => rect.top));
const maxX = max(...rects.map(rect => rect.right));
const maxY = max(...rects.map(rect => rect.bottom));
return {
x: minX,
y: minY,
width: maxX - minX,
height: maxY - minY
};
}
function getRectsByLine(rects) {
const sortedRects = rects.slice().sort((a, b) => a.y - b.y);
const groups = [];
let prevRect = null;
for (let i = 0; i < sortedRects.length; i++) {
const rect = sortedRects[i];
if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {
groups.push([rect]);
} else {
groups[groups.length - 1].push(rect);
}
prevRect = rect;
}
return groups.map(rect => rectToClientRect(getBoundingRect(rect)));
}
/**
* Provides improved positioning for inline reference elements that can span
* over multiple lines, such as hyperlinks or range selections.
* @see https://floating-ui.com/docs/inline
*/
const inline = function (options) {
if (options === void 0) {
options = {};
}
return {
name: 'inline',
options,
async fn(state) {
const {
placement,
elements,
rects,
platform,
strategy
} = state;
// A MouseEvent's client{X,Y} coords can be up to 2 pixels off a
// ClientRect's bounds, despite the event listener being triggered. A
// padding of 2 seems to handle this issue.
const {
padding = 2,
x,
y
} = evaluate(options, state);
const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);
const clientRects = getRectsByLine(nativeClientRects);
const fallback = rectToClientRect(getBoundingRect(nativeClientRects));
const paddingObject = getPaddingObject(padding);
function getBoundingClientRect() {
// There are two rects and they are disjoined.
if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {
// Find the first rect in which the point is fully inside.
return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;
}
// There are 2 or more connected rects.
if (clientRects.length >= 2) {
if (getSideAxis(placement) === 'y') {
const firstRect = clientRects[0];
const lastRect = clientRects[clientRects.length - 1];
const isTop = getSide(placement) === 'top';
const top = firstRect.top;
const bottom = lastRect.bottom;
const left = isTop ? firstRect.left : lastRect.left;
const right = isTop ? firstRect.right : lastRect.right;
const width = right - left;
const height = bottom - top;
return {
top,
bottom,
left,
right,
width,
height,
x: left,
y: top
};
}
const isLeftSide = getSide(placement) === 'left';
const maxRight = max(...clientRects.map(rect => rect.right));
const minLeft = min(...clientRects.map(rect => rect.left));
const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);
const top = measureRects[0].top;
const bottom = measureRects[measureRects.length - 1].bottom;
const left = minLeft;
const right = maxRight;
const width = right - left;
const height = bottom - top;
return {
top,
bottom,
left,
right,
width,
height,
x: left,
y: top
};
}
return fallback;
}
const resetRects = await platform.getElementRects({
reference: {
getBoundingClientRect
},
floating: elements.floating,
strategy
});
if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {
return {
reset: {
rects: resetRects
}
};
}
return {};
}
};
};
// For type backwards-compatibility, the `OffsetOptions` type was also
// Derivable.
async function convertValueToCoords(state, options) {
const {
placement,
platform,
elements
} = state;
const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
const side = floating_ui_utils_getSide(placement);
const alignment = floating_ui_utils_getAlignment(placement);
const isVertical = floating_ui_utils_getSideAxis(placement) === 'y';
const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
const crossAxisMulti = rtl && isVertical ? -1 : 1;
const rawValue = floating_ui_utils_evaluate(options, state);
// eslint-disable-next-line prefer-const
let {
mainAxis,
crossAxis,
alignmentAxis
} = typeof rawValue === 'number' ? {
mainAxis: rawValue,
crossAxis: 0,
alignmentAxis: null
} : {
mainAxis: 0,
crossAxis: 0,
alignmentAxis: null,
...rawValue
};
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
};
}
/**
* Modifies the placement by translating the floating element along the
* specified axes.
* A number (shorthand for `mainAxis` or distance), or an axes configuration
* object may be passed.
* @see https://floating-ui.com/docs/offset
*/
const offset = function (options) {
if (options === void 0) {
options = 0;
}
return {
name: 'offset',
options,
async fn(state) {
const {
x,
y
} = state;
const diffCoords = await convertValueToCoords(state, options);
return {
x: x + diffCoords.x,
y: y + diffCoords.y,
data: diffCoords
};
}
};
};
/**
* Optimizes the visibility of the floating element by shifting it in order to
* keep it in view when it will overflow the clipping boundary.
* @see https://floating-ui.com/docs/shift
*/
const shift = function (options) {
if (options === void 0) {
options = {};
}
return {
name: 'shift',
options,
async fn(state) {
const {
x,
y,
placement
} = state;
const {
mainAxis: checkMainAxis = true,
crossAxis: checkCrossAxis = false,
limiter = {
fn: _ref => {
let {
x,
y
} = _ref;
return {
x,
y
};
}
},
...detectOverflowOptions
} = floating_ui_utils_evaluate(options, state);
const coords = {
x,
y
};
const overflow = await detectOverflow(state, detectOverflowOptions);
const crossAxis = floating_ui_utils_getSideAxis(floating_ui_utils_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 min = mainAxisCoord + overflow[minSide];
const max = mainAxisCoord - overflow[maxSide];
mainAxisCoord = clamp(min, mainAxisCoord, max);
}
if (checkCrossAxis) {
const minSide = crossAxis === 'y' ? 'top' : 'left';
const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
const min = crossAxisCoord + overflow[minSide];
const max = crossAxisCoord - overflow[maxSide];
crossAxisCoord = clamp(min, crossAxisCoord, max);
}
const limitedCoords = limiter.fn({
...state,
[mainAxis]: mainAxisCoord,
[crossAxis]: crossAxisCoord
});
return {
...limitedCoords,
data: {
x: limitedCoords.x - x,
y: limitedCoords.y - y
}
};
}
};
};
/**
* Built-in `limiter` that will stop `shift()` at a certain point.
*/
const limitShift = function (options) {
if (options === void 0) {
options = {};
}
return {
options,
fn(state) {
const {
x,
y,
placement,
rects,
middlewareData
} = state;
const {
offset = 0,
mainAxis: checkMainAxis = true,
crossAxis: checkCrossAxis = true
} = floating_ui_utils_evaluate(options, state);
const coords = {
x,
y
};
const crossAxis = floating_ui_utils_getSideAxis(placement);
const mainAxis = getOppositeAxis(crossAxis);
let mainAxisCoord = coords[mainAxis];
let crossAxisCoord = coords[crossAxis];
const rawOffset = floating_ui_utils_evaluate(offset, 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 = ['top', 'left'].includes(floating_ui_utils_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
};
}
};
};
/**
* Provides data that allows you to change the size of the floating element —
* for instance, prevent it from overflowing the clipping boundary or match the
* width of the reference element.
* @see https://floating-ui.com/docs/size
*/
const size = function (options) {
if (options === void 0) {
options = {};
}
return {
name: 'size',
options,
async fn(state) {
const {
placement,
rects,
platform,
elements
} = state;
const {
apply = () => {},
...detectOverflowOptions
} = floating_ui_utils_evaluate(options, state);
const overflow = await detectOverflow(state, detectOverflowOptions);
const side = floating_ui_utils_getSide(placement);
const alignment = floating_ui_utils_getAlignment(placement);
const isYAxis = floating_ui_utils_getSideAxis(placement) === 'y';
const {
width,
height
} = rects.floating;
let heightSide;
let widthSide;
if (side === 'top' || side === 'bottom') {
heightSide = side;
widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';
} else {
widthSide = side;
heightSide = alignment === 'end' ? 'top' : 'bottom';
}
const overflowAvailableHeight = height - overflow[heightSide];
const overflowAvailableWidth = width - overflow[widthSide];
const noShift = !state.middlewareData.shift;
let availableHeight = overflowAvailableHeight;
let availableWidth = overflowAvailableWidth;
if (isYAxis) {
const maximumClippingWidth = width - overflow.left - overflow.right;
availableWidth = alignment || noShift ? floating_ui_utils_min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
} else {
const maximumClippingHeight = height - overflow.top - overflow.bottom;
availableHeight = alignment || noShift ? floating_ui_utils_min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
}
if (noShift && !alignment) {
const xMin = floating_ui_utils_max(overflow.left, 0);
const xMax = floating_ui_utils_max(overflow.right, 0);
const yMin = floating_ui_utils_max(overflow.top, 0);
const yMax = floating_ui_utils_max(overflow.bottom, 0);
if (isYAxis) {
availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : floating_ui_utils_max(overflow.left, overflow.right));
} else {
availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : floating_ui_utils_max(overflow.top, overflow.bottom));
}
}
await apply({
...state,
availableWidth,
availableHeight
});
const nextDimensions = await platform.getDimensions(elements.floating);
if (width !== nextDimensions.width || height !== nextDimensions.height) {
return {
reset: {
rects: true
}
};
}
return {};
}
};
};
;// ./node_modules/@floating-ui/dom/node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
/**
* Custom positioning reference element.
* @see https://floating-ui.com/docs/virtual-elements
*/
const dist_floating_ui_utils_sides = (/* unused pure expression or super */ null && (['top', 'right', 'bottom', 'left']));
const floating_ui_utils_alignments = (/* unused pure expression or super */ null && (['start', 'end']));
const dist_floating_ui_utils_placements = /*#__PURE__*/(/* unused pure expression or super */ null && (dist_floating_ui_utils_sides.reduce((acc, side) => acc.concat(side, side + "-" + floating_ui_utils_alignments[0], side + "-" + floating_ui_utils_alignments[1]), [])));
const dist_floating_ui_utils_min = Math.min;
const dist_floating_ui_utils_max = Math.max;
const floating_ui_utils_round = Math.round;
const floating_ui_utils_floor = Math.floor;
const floating_ui_utils_createCoords = v => ({
x: v,
y: v
});
const floating_ui_utils_oppositeSideMap = {
left: 'right',
right: 'left',
bottom: 'top',
top: 'bottom'
};
const floating_ui_utils_oppositeAlignmentMap = {
start: 'end',
end: 'start'
};
function floating_ui_utils_clamp(start, value, end) {
return dist_floating_ui_utils_max(start, dist_floating_ui_utils_min(value, end));
}
function dist_floating_ui_utils_evaluate(value, param) {
return typeof value === 'function' ? value(param) : value;
}
function dist_floating_ui_utils_getSide(placement) {
return placement.split('-')[0];
}
function dist_floating_ui_utils_getAlignment(placement) {
return placement.split('-')[1];
}
function floating_ui_utils_getOppositeAxis(axis) {
return axis === 'x' ? 'y' : 'x';
}
function floating_ui_utils_getAxisLength(axis) {
return axis === 'y' ? 'height' : 'width';
}
function dist_floating_ui_utils_getSideAxis(placement) {
return ['top', 'bottom'].includes(dist_floating_ui_utils_getSide(placement)) ? 'y' : 'x';
}
function floating_ui_utils_getAlignmentAxis(placement) {
return floating_ui_utils_getOppositeAxis(dist_floating_ui_utils_getSideAxis(placement));
}
function dist_floating_ui_utils_getAlignmentSides(placement, rects, rtl) {
if (rtl === void 0) {
rtl = false;
}
const alignment = dist_floating_ui_utils_getAlignment(placement);
const alignmentAxis = floating_ui_utils_getAlignmentAxis(placement);
const length = floating_ui_utils_getAxisLength(alignmentAxis);
let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
if (rects.reference[length] > rects.floating[length]) {
mainAlignmentSide = floating_ui_utils_getOppositePlacement(mainAlignmentSide);
}
return [mainAlignmentSide, floating_ui_utils_getOppositePlacement(mainAlignmentSide)];
}
function floating_ui_utils_getExpandedPlacements(placement) {
const oppositePlacement = floating_ui_utils_getOppositePlacement(placement);
return [dist_floating_ui_utils_getOppositeAlignmentPlacement(placement), oppositePlacement, dist_floating_ui_utils_getOppositeAlignmentPlacement(oppositePlacement)];
}
function dist_floating_ui_utils_getOppositeAlignmentPlacement(placement) {
return placement.replace(/start|end/g, alignment => floating_ui_utils_oppositeAlignmentMap[alignment]);
}
function floating_ui_utils_getSideList(side, isStart, rtl) {
const lr = ['left', 'right'];
const rl = ['right', 'left'];
const tb = ['top', 'bottom'];
const bt = ['bottom', 'top'];
switch (side) {
case 'top':
case 'bottom':
if (rtl) return isStart ? rl : lr;
return isStart ? lr : rl;
case 'left':
case 'right':
return isStart ? tb : bt;
default:
return [];
}
}
function floating_ui_utils_getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
const alignment = dist_floating_ui_utils_getAlignment(placement);
let list = floating_ui_utils_getSideList(dist_floating_ui_utils_getSide(placement), direction === 'start', rtl);
if (alignment) {
list = list.map(side => side + "-" + alignment);
if (flipAlignment) {
list = list.concat(list.map(dist_floating_ui_utils_getOppositeAlignmentPlacement));
}
}
return list;
}
function floating_ui_utils_getOppositePlacement(placement) {
return placement.replace(/left|right|bottom|top/g, side => floating_ui_utils_oppositeSideMap[side]);
}
function floating_ui_utils_expandPaddingObject(padding) {
return {
top: 0,
right: 0,
bottom: 0,
left: 0,
...padding
};
}
function dist_floating_ui_utils_getPaddingObject(padding) {
return typeof padding !== 'number' ? floating_ui_utils_expandPaddingObject(padding) : {
top: padding,
right: padding,
bottom: padding,
left: padding
};
}
function dist_floating_ui_utils_rectToClientRect(rect) {
const {
x,
y,
width,
height
} = rect;
return {
width,
height,
top: y,
left: x,
right: x + width,
bottom: y + height,
x,
y
};
}
;// ./node_modules/@floating-ui/dom/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
function hasWindow() {
return typeof window !== 'undefined';
}
function getNodeName(node) {
if (isNode(node)) {
return (node.nodeName || '').toLowerCase();
}
// Mocked nodes in testing environments may not be instances of Node. By
// returning `#document` an infinite loop won't occur.
// https://github.com/floating-ui/floating-ui/issues/2317
return '#document';
}
function floating_ui_utils_dom_getWindow(node) {
var _node$ownerDocument;
return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
}
function getDocumentElement(node) {
var _ref;
return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
}
function isNode(value) {
if (!hasWindow()) {
return false;
}
return value instanceof Node || value instanceof floating_ui_utils_dom_getWindow(value).Node;
}
function isElement(value) {
if (!hasWindow()) {
return false;
}
return value instanceof Element || value instanceof floating_ui_utils_dom_getWindow(value).Element;
}
function isHTMLElement(value) {
if (!hasWindow()) {
return false;
}
return value instanceof HTMLElement || value instanceof floating_ui_utils_dom_getWindow(value).HTMLElement;
}
function isShadowRoot(value) {
if (!hasWindow() || typeof ShadowRoot === 'undefined') {
return false;
}
return value instanceof ShadowRoot || value instanceof floating_ui_utils_dom_getWindow(value).ShadowRoot;
}
function isOverflowElement(element) {
const {
overflow,
overflowX,
overflowY,
display
} = floating_ui_utils_dom_getComputedStyle(element);
return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);
}
function isTableElement(element) {
return ['table', 'td', 'th'].includes(getNodeName(element));
}
function isTopLayer(element) {
return [':popover-open', ':modal'].some(selector => {
try {
return element.matches(selector);
} catch (e) {
return false;
}
});
}
function isContainingBlock(elementOrCss) {
const webkit = isWebKit();
const css = isElement(elementOrCss) ? floating_ui_utils_dom_getComputedStyle(elementOrCss) : elementOrCss;
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
// https://drafts.csswg.org/css-transforms-2/#individual-transforms
return ['transform', 'translate', 'scale', 'rotate', 'perspective'].some(value => css[value] ? css[value] !== 'none' : false) || (css.containerType ? css.containerType !== 'normal' : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !webkit && (css.filter ? css.filter !== 'none' : false) || ['transform', 'translate', 'scale', 'rotate', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.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');
}
function isLastTraversableNode(node) {
return ['html', 'body', '#document'].includes(getNodeName(node));
}
function floating_ui_utils_dom_getComputedStyle(element) {
return floating_ui_utils_dom_getWindow(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(node) {
if (getNodeName(node) === 'html') {
return node;
}
const result =
// Step into the shadow DOM of the parent of a slotted node.
node.assignedSlot ||
// DOM Element detected.
node.parentNode ||
// ShadowRoot detected.
isShadowRoot(node) && node.host ||
// Fallback.
getDocumentElement(node);
return isShadowRoot(result) ? result.host : result;
}
function getNearestOverflowAncestor(node) {
const parentNode = getParentNode(node);
if (isLastTraversableNode(parentNode)) {
return node.ownerDocument ? node.ownerDocument.body : node.body;
}
if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
return parentNode;
}
return getNearestOverflowAncestor(parentNode);
}
function getOverflowAncestors(node, list, traverseIframes) {
var _node$ownerDocument2;
if (list === void 0) {
list = [];
}
if (traverseIframes === void 0) {
traverseIframes = true;
}
const scrollableAncestor = getNearestOverflowAncestor(node);
const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
const win = floating_ui_utils_dom_getWindow(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 css = floating_ui_utils_dom_getComputedStyle(element);
// In testing environments, the `width` and `height` properties are empty
// strings for SVG elements, returning NaN. Fallback to `0` in this case.
let width = parseFloat(css.width) || 0;
let height = parseFloat(css.height) || 0;
const hasOffset = isHTMLElement(element);
const offsetWidth = hasOffset ? element.offsetWidth : width;
const offsetHeight = hasOffset ? element.offsetHeight : height;
const shouldFallback = floating_ui_utils_round(width) !== offsetWidth || floating_ui_utils_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 floating_ui_utils_createCoords(1);
}
const rect = domElement.getBoundingClientRect();
const {
width,
height,
$
} = getCssDimensions(domElement);
let x = ($ ? floating_ui_utils_round(rect.width) : rect.width) / width;
let y = ($ ? floating_ui_utils_round(rect.height) : rect.height) / height;
// 0, NaN, or Infinity should always fallback to 1.
if (!x || !Number.isFinite(x)) {
x = 1;
}
if (!y || !Number.isFinite(y)) {
y = 1;
}
return {
x,
y
};
}
const noOffsets = /*#__PURE__*/floating_ui_utils_createCoords(0);
function getVisualOffsets(element) {
const win = floating_ui_utils_dom_getWindow(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 !== floating_ui_utils_dom_getWindow(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 scale = floating_ui_utils_createCoords(1);
if (includeScale) {
if (offsetParent) {
if (isElement(offsetParent)) {
scale = getScale(offsetParent);
}
} else {
scale = getScale(element);
}
}
const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : floating_ui_utils_createCoords(0);
let x = (clientRect.left + visualOffsets.x) / scale.x;
let y = (clientRect.top + visualOffsets.y) / scale.y;
let width = clientRect.width / scale.x;
let height = clientRect.height / scale.y;
if (domElement) {
const win = floating_ui_utils_dom_getWindow(domElement);
const offsetWin = offsetParent && isElement(offsetParent) ? floating_ui_utils_dom_getWindow(offsetParent) : offsetParent;
let currentWin = win;
let currentIFrame = currentWin.frameElement;
while (currentIFrame && offsetParent && offsetWin !== currentWin) {
const iframeScale = getScale(currentIFrame);
const iframeRect = currentIFrame.getBoundingClientRect();
const css = floating_ui_utils_dom_getComputedStyle(currentIFrame);
const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
x *= iframeScale.x;
y *= iframeScale.y;
width *= iframeScale.x;
height *= iframeScale.y;
x += left;
y += top;
currentWin = floating_ui_utils_dom_getWindow(currentIFrame);
currentIFrame = currentWin.frameElement;
}
}
return floating_ui_utils_rectToClientRect({
width,
height,
x,
y
});
}
const topLayerSelectors = [':popover-open', ':modal'];
function floating_ui_dom_isTopLayer(floating) {
return topLayerSelectors.some(selector => {
try {
return floating.matches(selector);
} catch (e) {
return false;
}
});
}
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
let {
elements,
rect,
offsetParent,
strategy
} = _ref;
const isFixed = strategy === 'fixed';
const documentElement = getDocumentElement(offsetParent);
const topLayer = elements ? floating_ui_dom_isTopLayer(elements.floating) : false;
if (offsetParent === documentElement || topLayer && isFixed) {
return rect;
}
let scroll = {
scrollLeft: 0,
scrollTop: 0
};
let scale = floating_ui_utils_createCoords(1);
const offsets = floating_ui_utils_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);
scale = getScale(offsetParent);
offsets.x = offsetRect.x + offsetParent.clientLeft;
offsets.y = offsetRect.y + offsetParent.clientTop;
}
}
return {
width: rect.width * scale.x,
height: rect.height * scale.y,
x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
};
}
function getClientRects(element) {
return Array.from(element.getClientRects());
}
function getWindowScrollBarX(element) {
// If <html> has a CSS width greater than the viewport, then this will be
// incorrect for RTL.
return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
}
// Gets the entire size of the scrollable document area, even extending outside
// of the `<html>` and `<body>` rect bounds if horizontally scrollable.
function getDocumentRect(element) {
const html = getDocumentElement(element);
const scroll = getNodeScroll(element);
const body = element.ownerDocument.body;
const width = dist_floating_ui_utils_max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
const height = dist_floating_ui_utils_max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
let x = -scroll.scrollLeft + getWindowScrollBarX(element);
const y = -scroll.scrollTop;
if (floating_ui_utils_dom_getComputedStyle(body).direction === 'rtl') {
x += dist_floating_ui_utils_max(html.clientWidth, body.clientWidth) - width;
}
return {
width,
height,
x,
y
};
}
function getViewportRect(element, strategy) {
const win = floating_ui_utils_dom_getWindow(element);
const html = getDocumentElement(element);
const visualViewport = win.visualViewport;
let width = html.clientWidth;
let height = html.clientHeight;
let x = 0;
let y = 0;
if (visualViewport) {
width = visualViewport.width;
height = visualViewport.height;
const visualViewportBased = isWebKit();
if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {
x = visualViewport.offsetLeft;
y = visualViewport.offsetTop;
}
}
return {
width,
height,
x,
y
};
}
// Returns the inner client rect, subtracting scrollbars if present.
function getInnerBoundingClientRect(element, strategy) {
const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
const top = clientRect.top + element.clientTop;
const left = clientRect.left + element.clientLeft;
const scale = isHTMLElement(element) ? getScale(element) : floating_ui_utils_createCoords(1);
const width = element.clientWidth * scale.x;
const height = element.clientHeight * scale.y;
const x = left * scale.x;
const y = top * scale.y;
return {
width,
height,
x,
y
};
}
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 = {
...clippingAncestor,
x: clippingAncestor.x - visualOffsets.x,
y: clippingAncestor.y - visualOffsets.y
};
}
return floating_ui_utils_rectToClientRect(rect);
}
function hasFixedPositionAncestor(element, stopNode) {
const parentNode = getParentNode(element);
if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
return false;
}
return floating_ui_utils_dom_getComputedStyle(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);
}
// A "clipping ancestor" is an `overflow` element with the characteristic of
// clipping (or hiding) child elements. This returns all clipping ancestors
// of the given element up the tree.
function getClippingElementAncestors(element, cache) {
const cachedResult = cache.get(element);
if (cachedResult) {
return cachedResult;
}
let result = getOverflowAncestors(element, [], false).filter(el => isElement(el) && getNodeName(el) !== 'body');
let currentContainingBlockComputedStyle = null;
const elementIsFixed = floating_ui_utils_dom_getComputedStyle(element).position === 'fixed';
let currentNode = elementIsFixed ? getParentNode(element) : element;
// https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
const computedStyle = floating_ui_utils_dom_getComputedStyle(currentNode);
const currentNodeIsContaining = isContainingBlock(currentNode);
if (!currentNodeIsContaining && computedStyle.position === 'fixed') {
currentContainingBlockComputedStyle = null;
}
const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
if (shouldDropCurrentNode) {
// Drop non-containing blocks.
result = result.filter(ancestor => ancestor !== currentNode);
} else {
// Record last containing block for next iteration.
currentContainingBlockComputedStyle = computedStyle;
}
currentNode = getParentNode(currentNode);
}
cache.set(element, result);
return result;
}
// Gets the maximum area that the element is visible in due to any number of
// clipping ancestors.
function getClippingRect(_ref) {
let {
element,
boundary,
rootBoundary,
strategy
} = _ref;
const elementClippingAncestors = boundary === 'clippingAncestors' ? 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 = dist_floating_ui_utils_max(rect.top, accRect.top);
accRect.right = dist_floating_ui_utils_min(rect.right, accRect.right);
accRect.bottom = dist_floating_ui_utils_min(rect.bottom, accRect.bottom);
accRect.left = dist_floating_ui_utils_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 = floating_ui_utils_createCoords(0);
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) {
offsets.x = getWindowScrollBarX(documentElement);
}
}
const x = rect.left + scroll.scrollLeft - offsets.x;
const y = rect.top + scroll.scrollTop - offsets.y;
return {
x,
y,
width: rect.width,
height: rect.height
};
}
function getTrueOffsetParent(element, polyfill) {
if (!isHTMLElement(element) || floating_ui_utils_dom_getComputedStyle(element).position === 'fixed') {
return null;
}
if (polyfill) {
return polyfill(element);
}
return element.offsetParent;
}
// Gets the closest ancestor positioned element. Handles some edge cases,
// such as table ancestors and cross browser bugs.
function getOffsetParent(element, polyfill) {
const window = floating_ui_utils_dom_getWindow(element);
if (!isHTMLElement(element) || floating_ui_dom_isTopLayer(element)) {
return window;
}
let offsetParent = getTrueOffsetParent(element, polyfill);
while (offsetParent && isTableElement(offsetParent) && floating_ui_utils_dom_getComputedStyle(offsetParent).position === 'static') {
offsetParent = getTrueOffsetParent(offsetParent, polyfill);
}
if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && floating_ui_utils_dom_getComputedStyle(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
return window;
}
return offsetParent || getContainingBlock(element) || window;
}
const getElementRects = async function (data) {
const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
const getDimensionsFn = this.getDimensions;
return {
reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
floating: {
x: 0,
y: 0,
...(await getDimensionsFn(data.floating))
}
};
};
function isRTL(element) {
return floating_ui_utils_dom_getComputedStyle(element).direction === 'rtl';
}
const platform = {
convertOffsetParentRelativeRectToViewportRelativeRect,
getDocumentElement: getDocumentElement,
getClippingRect,
getOffsetParent,
getElementRects,
getClientRects,
getDimensions,
getScale,
isElement: isElement,
isRTL
};
// https://samthor.au/2021/observing-dom/
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 {
left,
top,
width,
height
} = element.getBoundingClientRect();
if (!skip) {
onMove();
}
if (!width || !height) {
return;
}
const insetTop = floating_ui_utils_floor(top);
const insetRight = floating_ui_utils_floor(root.clientWidth - (left + width));
const insetBottom = floating_ui_utils_floor(root.clientHeight - (top + height));
const insetLeft = floating_ui_utils_floor(left);
const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
const options = {
rootMargin,
threshold: dist_floating_ui_utils_max(0, dist_floating_ui_utils_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);
}, 100);
} else {
refresh(false, ratio);
}
}
isFirstUpdate = false;
}
// Older browsers don't support a `document` as the root and will throw an
// error.
try {
io = new IntersectionObserver(handleObserve, {
...options,
// Handle <iframe>s
root: root.ownerDocument
});
} catch (e) {
io = new IntersectionObserver(handleObserve, options);
}
io.observe(element);
}
refresh(true);
return cleanup;
}
/**
* Automatically updates the position of the floating element when necessary.
* Should only be called when the floating element is mounted on the DOM or
* visible on the screen.
* @returns cleanup function that should be invoked when the floating element is
* removed from the DOM or hidden from the screen.
* @see https://floating-ui.com/docs/autoUpdate
*/
function autoUpdate(reference, floating, update, options) {
if (options === void 0) {
options = {};
}
const {
ancestorScroll = true,
ancestorResize = true,
elementResize = typeof ResizeObserver === 'function',
layoutShift = typeof IntersectionObserver === 'function',
animationFrame = false
} = options;
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(_ref => {
let [firstEntry] = _ref;
if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
// Prevent update loops when using the `size` middleware.
// https://github.com/floating-ui/floating-ui/issues/1740
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 && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
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);
}
};
}
/**
* Optimizes the visibility of the floating element by choosing the placement
* that has the most space available automatically, without needing to specify a
* preferred placement. Alternative to `flip`.
* @see https://floating-ui.com/docs/autoPlacement
*/
const floating_ui_dom_autoPlacement = (/* unused pure expression or super */ null && (autoPlacement$1));
/**
* Optimizes the visibility of the floating element by shifting it in order to
* keep it in view when it will overflow the clipping boundary.
* @see https://floating-ui.com/docs/shift
*/
const floating_ui_dom_shift = shift;
/**
* Optimizes the visibility of the floating element by flipping the `placement`
* in order to keep it in view when the preferred placement(s) will overflow the
* clipping boundary. Alternative to `autoPlacement`.
* @see https://floating-ui.com/docs/flip
*/
const floating_ui_dom_flip = flip;
/**
* Provides data that allows you to change the size of the floating element —
* for instance, prevent it from overflowing the clipping boundary or match the
* width of the reference element.
* @see https://floating-ui.com/docs/size
*/
const floating_ui_dom_size = size;
/**
* Provides data to hide the floating element in applicable situations, such as
* when it is not in the same clipping context as the reference element.
* @see https://floating-ui.com/docs/hide
*/
const floating_ui_dom_hide = (/* unused pure expression or super */ null && (hide$1));
/**
* Provides data to position an inner element of the floating element so that it
* appears centered to the reference element.
* @see https://floating-ui.com/docs/arrow
*/
const floating_ui_dom_arrow = arrow;
/**
* Provides improved positioning for inline reference elements that can span
* over multiple lines, such as hyperlinks or range selections.
* @see https://floating-ui.com/docs/inline
*/
const floating_ui_dom_inline = (/* unused pure expression or super */ null && (inline$1));
/**
* Built-in `limiter` that will stop `shift()` at a certain point.
*/
const floating_ui_dom_limitShift = limitShift;
/**
* Computes the `x` and `y` coordinates that will place the floating element
* next to a given reference element.
*/
const floating_ui_dom_computePosition = (reference, floating, options) => {
// This caches the expensive `getClippingElementAncestors` function so that
// multiple lifecycle resets re-use the same result. It only lives for a
// single call. If other functions become expensive, we can add them as well.
const cache = new Map();
const mergedOptions = {
platform,
...options
};
const platformWithCache = {
...mergedOptions.platform,
_c: cache
};
return computePosition(reference, floating, {
...mergedOptions,
platform: platformWithCache
});
};
;// ./node_modules/@ariakit/react-core/esm/__chunks/T6C2RYFI.js
"use client";
// src/popover/popover.tsx
var T6C2RYFI_TagName = "div";
function createDOMRect(x = 0, y = 0, width = 0, height = 0) {
if (typeof DOMRect === "function") {
return new DOMRect(x, y, width, height);
}
const rect = {
x,
y,
width,
height,
top: y,
right: x + width,
bottom: y + height,
left: x
};
return _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, rect), { toJSON: () => rect });
}
function getDOMRect(anchorRect) {
if (!anchorRect) return createDOMRect();
const { x, y, width, height } = anchorRect;
return createDOMRect(x, y, 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(flip2) {
return /^(?:top|bottom|left|right)(?:-(?:start|end))?$/.test(flip2);
}
function roundByDPR(value) {
const dpr = window.devicePixelRatio || 1;
return Math.round(value * dpr) / dpr;
}
function getOffsetMiddleware(arrowElement, props) {
return offset(({ 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),
false && 0
);
return floating_ui_dom_flip({
padding: props.overflowPadding,
fallbackPlacements
});
}
function getShiftMiddleware(props) {
if (!props.slide && !props.overlap) return;
return floating_ui_dom_shift({
mainAxis: props.slide,
crossAxis: props.overlap,
padding: props.overflowPadding,
limiter: floating_ui_dom_limitShift()
});
}
function getSizeMiddleware(props) {
return floating_ui_dom_size({
padding: props.overflowPadding,
apply({ elements, availableWidth, availableHeight, rects }) {
const wrapper = elements.floating;
const referenceWidth = Math.round(rects.reference.width);
availableWidth = Math.floor(availableWidth);
availableHeight = Math.floor(availableHeight);
wrapper.style.setProperty(
"--popover-anchor-width",
`${referenceWidth}px`
);
wrapper.style.setProperty(
"--popover-available-width",
`${availableWidth}px`
);
wrapper.style.setProperty(
"--popover-available-height",
`${availableHeight}px`
);
if (props.sameWidth) {
wrapper.style.width = `${referenceWidth}px`;
}
if (props.fitViewport) {
wrapper.style.maxWidth = `${availableWidth}px`;
wrapper.style.maxHeight = `${availableHeight}px`;
}
}
});
}
function getArrowMiddleware(arrowElement, props) {
if (!arrowElement) return;
return floating_ui_dom_arrow({
element: arrowElement,
padding: props.arrowPadding
});
}
var usePopover = createHook(
function usePopover2(_a) {
var _b = _a, {
store,
modal = false,
portal = !!modal,
preserveTabOrder = true,
autoFocusOnShow = true,
wrapperProps,
fixed = false,
flip: flip2 = true,
shift: shift2 = 0,
slide = true,
overlap = false,
sameWidth = false,
fitViewport = false,
gutter,
arrowPadding = 4,
overflowPadding = 8,
getAnchorRect,
updatePosition
} = _b, props = __objRest(_b, [
"store",
"modal",
"portal",
"preserveTabOrder",
"autoFocusOnShow",
"wrapperProps",
"fixed",
"flip",
"shift",
"slide",
"overlap",
"sameWidth",
"fitViewport",
"gutter",
"arrowPadding",
"overflowPadding",
"getAnchorRect",
"updatePosition"
]);
const context = usePopoverProviderContext();
store = store || context;
invariant(
store,
false && 0
);
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,external_React_.useRef)(null);
const [positioned, setPositioned] = (0,external_React_.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 arrow2 = arrowElement || defaultArrowElementRef.current;
const middleware = [
getOffsetMiddleware(arrow2, { gutter, shift: shift2 }),
getFlipMiddleware({ flip: flip2, overflowPadding }),
getShiftMiddleware({ slide, shift: shift2, overlap, overflowPadding }),
getArrowMiddleware(arrow2, { arrowPadding }),
getSizeMiddleware({
sameWidth,
fitViewport,
overflowPadding
})
];
const pos = await floating_ui_dom_computePosition(anchor, popoverElement, {
placement,
strategy: fixed ? "fixed" : "absolute",
middleware
});
store == null ? void 0 : store.setState("currentPlacement", pos.placement);
setPositioned(true);
const x = roundByDPR(pos.x);
const y = roundByDPR(pos.y);
Object.assign(popoverElement.style, {
top: "0",
left: "0",
transform: `translate3d(${x}px,${y}px,0)`
});
if (arrow2 && pos.middlewareData.arrow) {
const { x: arrowX, y: arrowY } = pos.middlewareData.arrow;
const side = pos.placement.split("-")[0];
const centerX = arrow2.clientWidth / 2;
const centerY = arrow2.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(arrow2.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,
flip2,
shift2,
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 position = fixed ? "fixed" : "absolute";
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
"div",
_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, wrapperProps), {
style: _3YLGPPWQ_spreadValues({
// https://floating-ui.com/docs/computeposition#initial-layout
position,
top: 0,
left: 0,
width: "max-content"
}, wrapperProps == null ? void 0 : wrapperProps.style),
ref: store == null ? void 0 : store.setPopoverElement,
children: element
})
),
[store, position, wrapperProps]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PopoverScopedContextProvider, { value: store, children: element }),
[store]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
// 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: _3YLGPPWQ_spreadValues({
position: "relative"
}, props.style)
});
props = useDialog(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
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 LMDWO4NN_createElement(T6C2RYFI_TagName, htmlProps);
}),
usePopoverProviderContext
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/KQKDTOT4.js
"use client";
// src/hovercard/hovercard.tsx
var KQKDTOT4_TagName = "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(_a) {
var _b = _a, {
store
} = _b, props = __objRest(_b, [
"store"
]);
const [autoFocusOnHide, setAutoFocusOnHide] = (0,external_React_.useState)(false);
const mounted = store.useState("mounted");
(0,external_React_.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,external_React_.useRef)(null);
(0,external_React_.useEffect)(() => {
return sync(store, ["anchorElement"], (state) => {
finalFocusRef.current = state.anchorElement;
});
}, []);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
autoFocusOnHide,
finalFocus: finalFocusRef
}, props), {
onFocus
});
return props;
}
var NestedHovercardContext = (0,external_React_.createContext)(null);
var useHovercard = createHook(
function useHovercard2(_a) {
var _b = _a, {
store,
modal = false,
portal = !!modal,
hideOnEscape = true,
hideOnHoverOutside = true,
disablePointerEventsOnApproach = !!hideOnHoverOutside
} = _b, props = __objRest(_b, [
"store",
"modal",
"portal",
"hideOnEscape",
"hideOnHoverOutside",
"disablePointerEventsOnApproach"
]);
const context = useHovercardProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const ref = (0,external_React_.useRef)(null);
const [nestedHovercards, setNestedHovercards] = (0,external_React_.useState)([]);
const hideTimeoutRef = (0,external_React_.useRef)(0);
const enterPointRef = (0,external_React_.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,external_React_.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,external_React_.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,external_React_.useEffect)(() => {
if (!domReady) return;
if (open) return;
store == null ? void 0 : store.setAutoFocusOnShow(false);
}, [store, domReady, open]);
const openRef = useLiveRef(open);
(0,external_React_.useEffect)(() => {
if (!domReady) return;
return () => {
if (!openRef.current) {
store == null ? void 0 : store.setAutoFocusOnShow(false);
}
};
}, [store, domReady]);
const registerOnParent = (0,external_React_.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,external_React_.useCallback)(
(element) => {
setNestedHovercards((prevElements) => [...prevElements, element]);
const parentUnregister = registerOnParent == null ? void 0 : registerOnParent(element);
return () => {
setNestedHovercards(
(prevElements) => prevElements.filter((item) => item !== element)
);
parentUnregister == null ? void 0 : parentUnregister();
};
},
[registerOnParent]
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(HovercardScopedContextProvider, { value: store, children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NestedHovercardContext.Provider, { value: registerNestedHovercard, children: element }) }),
[store, registerNestedHovercard]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
ref: useMergeRefs(ref, props.ref)
});
props = useAutoFocusOnHide(_3YLGPPWQ_spreadValues({ store }, props));
const autoFocusOnShow = store.useState(
(state) => modal || state.autoFocusOnShow
);
props = usePopover(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
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 LMDWO4NN_createElement(KQKDTOT4_TagName, htmlProps);
}),
useHovercardProviderContext
);
;// ./node_modules/@ariakit/react-core/esm/tooltip/tooltip.js
"use client";
// src/tooltip/tooltip.tsx
var tooltip_TagName = "div";
var useTooltip = createHook(
function useTooltip2(_a) {
var _b = _a, {
store,
portal = true,
gutter = 8,
preserveTabOrder = false,
hideOnHoverOutside = true,
hideOnInteractOutside = true
} = _b, props = __objRest(_b, [
"store",
"portal",
"gutter",
"preserveTabOrder",
"hideOnHoverOutside",
"hideOnInteractOutside"
]);
const context = useTooltipProviderContext();
store = store || context;
invariant(
store,
false && 0
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TooltipScopedContextProvider, { value: store, children: element }),
[store]
);
const role = store.useState(
(state) => state.type === "description" ? "tooltip" : "none"
);
props = _3YLGPPWQ_spreadValues({ role }, props);
props = useHovercard(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, 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 LMDWO4NN_createElement(tooltip_TagName, htmlProps);
}),
useTooltipProviderContext
);
;// external ["wp","deprecated"]
const external_wp_deprecated_namespaceObject = window["wp"]["deprecated"];
var external_wp_deprecated_default = /*#__PURE__*/__webpack_require__.n(external_wp_deprecated_namespaceObject);
;// ./node_modules/@wordpress/components/build-module/shortcut/index.js
function Shortcut(props) {
const {
shortcut,
className
} = 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,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className,
"aria-label": ariaLabel,
children: displayText
});
}
var shortcut_default = Shortcut;
;// ./node_modules/@wordpress/components/build-module/popover/utils.js
const POSITION_TO_PLACEMENT = {
bottom: "bottom",
top: "top",
"middle left": "left",
"middle right": "right",
"bottom left": "bottom-end",
"bottom center": "bottom",
"bottom right": "bottom-start",
"top left": "top-end",
"top center": "top",
"top right": "top-start",
"middle left left": "left",
"middle left right": "left",
"middle left bottom": "left-end",
"middle left top": "left-start",
"middle right left": "right",
"middle right right": "right",
"middle right bottom": "right-end",
"middle right top": "right-start",
"bottom left left": "bottom-end",
"bottom left right": "bottom-end",
"bottom left bottom": "bottom-end",
"bottom left top": "bottom-end",
"bottom center left": "bottom",
"bottom center right": "bottom",
"bottom center bottom": "bottom",
"bottom center top": "bottom",
"bottom right left": "bottom-start",
"bottom right right": "bottom-start",
"bottom right bottom": "bottom-start",
"bottom right top": "bottom-start",
"top left left": "top-end",
"top left right": "top-end",
"top left bottom": "top-end",
"top left top": "top-end",
"top center left": "top",
"top center right": "top",
"top center bottom": "top",
"top center top": "top",
"top right left": "top-start",
"top right right": "top-start",
"top right bottom": "top-start",
"top right top": "top-start",
// `middle`/`middle center [corner?]` positions are associated to a fallback
// `bottom` placement because there aren't any corresponding placement values.
middle: "bottom",
"middle center": "bottom",
"middle center bottom": "bottom",
"middle center left": "bottom",
"middle center right": "bottom",
"middle center top": "bottom"
};
const positionToPlacement = (position) => {
var _POSITION_TO_PLACEMEN;
return (_POSITION_TO_PLACEMEN = POSITION_TO_PLACEMENT[position]) !== null && _POSITION_TO_PLACEMEN !== void 0 ? _POSITION_TO_PLACEMEN : "bottom";
};
const PLACEMENT_TO_ANIMATION_ORIGIN = {
top: {
originX: 0.5,
originY: 1
},
// open from bottom, center
"top-start": {
originX: 0,
originY: 1
},
// open from bottom, left
"top-end": {
originX: 1,
originY: 1
},
// open from bottom, right
right: {
originX: 0,
originY: 0.5
},
// open from middle, left
"right-start": {
originX: 0,
originY: 0
},
// open from top, left
"right-end": {
originX: 0,
originY: 1
},
// open from bottom, left
bottom: {
originX: 0.5,
originY: 0
},
// open from top, center
"bottom-start": {
originX: 0,
originY: 0
},
// open from top, left
"bottom-end": {
originX: 1,
originY: 0
},
// open from top, right
left: {
originX: 1,
originY: 0.5
},
// open from middle, right
"left-start": {
originX: 1,
originY: 0
},
// open from top, right
"left-end": {
originX: 1,
originY: 1
},
// open from bottom, right
overlay: {
originX: 0.5,
originY: 0.5
}
// open from center, center
};
const placementToMotionAnimationProps = (placement) => {
const translateProp = placement.startsWith("top") || placement.startsWith("bottom") ? "translateY" : "translateX";
const translateDirection = placement.startsWith("top") || placement.startsWith("left") ? 1 : -1;
return {
style: PLACEMENT_TO_ANIMATION_ORIGIN[placement],
initial: {
opacity: 0,
scale: 0,
[translateProp]: `${2 * translateDirection}em`
},
animate: {
opacity: 1,
scale: 1,
[translateProp]: 0
},
transition: {
duration: 0.1,
ease: [0, 0, 0.2, 1]
}
};
};
function isTopBottom(anchorRef) {
return !!anchorRef?.top;
}
function isRef(anchorRef) {
return !!anchorRef?.current;
}
const getReferenceElement = ({
anchor,
anchorRef,
anchorRect,
getAnchorRect,
fallbackReferenceElement
}) => {
var _referenceElement;
let referenceElement = null;
if (anchor) {
referenceElement = anchor;
} else if (isTopBottom(anchorRef)) {
referenceElement = {
getBoundingClientRect() {
const topRect = anchorRef.top.getBoundingClientRect();
const bottomRect = anchorRef.bottom.getBoundingClientRect();
return new window.DOMRect(topRect.x, topRect.y, topRect.width, bottomRect.bottom - topRect.top);
}
};
} else if (isRef(anchorRef)) {
referenceElement = anchorRef.current;
} else if (anchorRef) {
referenceElement = anchorRef;
} else if (anchorRect) {
referenceElement = {
getBoundingClientRect() {
return anchorRect;
}
};
} else if (getAnchorRect) {
referenceElement = {
getBoundingClientRect() {
var _rect$x, _rect$y, _rect$width, _rect$height;
const rect = getAnchorRect(fallbackReferenceElement);
return new window.DOMRect((_rect$x = rect.x) !== null && _rect$x !== void 0 ? _rect$x : rect.left, (_rect$y = rect.y) !== null && _rect$y !== void 0 ? _rect$y : rect.top, (_rect$width = rect.width) !== null && _rect$width !== void 0 ? _rect$width : rect.right - rect.left, (_rect$height = rect.height) !== null && _rect$height !== void 0 ? _rect$height : rect.bottom - rect.top);
}
};
} else if (fallbackReferenceElement) {
referenceElement = fallbackReferenceElement.parentElement;
}
return (_referenceElement = referenceElement) !== null && _referenceElement !== void 0 ? _referenceElement : null;
};
const computePopoverPosition = (c) => c === null || Number.isNaN(c) ? void 0 : Math.round(c);
;// ./node_modules/@wordpress/components/build-module/tooltip/index.js
const TooltipInternalContext = (0,external_wp_element_namespaceObject.createContext)({
isNestedInTooltip: false
});
TooltipInternalContext.displayName = "TooltipInternalContext";
const TOOLTIP_DELAY = 700;
const CONTEXT_VALUE = {
isNestedInTooltip: true
};
function UnforwardedTooltip(props, ref) {
const {
children,
className,
delay = TOOLTIP_DELAY,
hideOnClick = true,
placement,
position,
shortcut,
text,
...restProps
} = props;
const {
isNestedInTooltip
} = (0,external_wp_element_namespaceObject.useContext)(TooltipInternalContext);
const baseId = (0,external_wp_compose_namespaceObject.useInstanceId)(tooltip_Tooltip, "tooltip");
const describedById = text || shortcut ? baseId : void 0;
const isOnlyChild = external_wp_element_namespaceObject.Children.count(children) === 1;
if (!isOnlyChild) {
if (false) {}
}
let computedPlacement;
if (placement !== void 0) {
computedPlacement = placement;
} else if (position !== void 0) {
computedPlacement = positionToPlacement(position);
external_wp_deprecated_default()("`position` prop in wp.components.tooltip", {
since: "6.4",
alternative: "`placement` prop"
});
}
computedPlacement = computedPlacement || "bottom";
const tooltipStore = useTooltipStore({
placement: computedPlacement,
showTimeout: delay
});
const mounted = useStoreState(tooltipStore, "mounted");
if (isNestedInTooltip) {
return isOnlyChild ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Role, {
...restProps,
render: children
}) : children;
}
function addDescribedById(element) {
return describedById && mounted && element.props["aria-describedby"] === void 0 && element.props["aria-label"] !== text ? (0,external_wp_element_namespaceObject.cloneElement)(element, {
"aria-describedby": describedById
}) : element;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(TooltipInternalContext.Provider, {
value: CONTEXT_VALUE,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TooltipAnchor, {
onClick: hideOnClick ? tooltipStore.hide : void 0,
store: tooltipStore,
render: isOnlyChild ? addDescribedById(children) : void 0,
ref,
children: isOnlyChild ? void 0 : children
}), isOnlyChild && (text || shortcut) && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Tooltip, {
...restProps,
className: dist_clsx("components-tooltip", className),
unmountOnHide: true,
gutter: 4,
id: describedById,
overflowPadding: 0.5,
store: tooltipStore,
children: [text, shortcut && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(shortcut_default, {
className: text ? "components-tooltip__shortcut" : "",
shortcut
})]
})]
});
}
const tooltip_Tooltip = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTooltip);
var tooltip_default = tooltip_Tooltip;
;// external ["wp","warning"]
const external_wp_warning_namespaceObject = window["wp"]["warning"];
var external_wp_warning_default = /*#__PURE__*/__webpack_require__.n(external_wp_warning_namespaceObject);
// EXTERNAL MODULE: ./node_modules/deepmerge/dist/cjs.js
var cjs = __webpack_require__(66);
var cjs_default = /*#__PURE__*/__webpack_require__.n(cjs);
// EXTERNAL MODULE: ./node_modules/fast-deep-equal/es6/index.js
var es6 = __webpack_require__(7734);
var es6_default = /*#__PURE__*/__webpack_require__.n(es6);
;// ./node_modules/is-plain-object/dist/is-plain-object.mjs
/*!
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
*
* Copyright (c) 2014-2017, Jon Schlinkert.
* Released under the MIT License.
*/
function is_plain_object_isObject(o) {
return Object.prototype.toString.call(o) === '[object Object]';
}
function isPlainObject(o) {
var ctor,prot;
if (is_plain_object_isObject(o) === false) return false;
// If has modified constructor
ctor = o.constructor;
if (ctor === undefined) return true;
// If has modified prototype
prot = ctor.prototype;
if (is_plain_object_isObject(prot) === false) return false;
// If constructor does not have an Object-specific method
if (prot.hasOwnProperty('isPrototypeOf') === false) {
return false;
}
// Most likely a plain Object
return true;
}
;// ./node_modules/@wordpress/components/build-module/utils/hooks/use-update-effect.js
function use_update_effect_useUpdateEffect(effect, deps) {
const mountedRef = (0,external_wp_element_namespaceObject.useRef)(false);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (mountedRef.current) {
return effect();
}
mountedRef.current = true;
return void 0;
}, deps);
(0,external_wp_element_namespaceObject.useEffect)(() => () => {
mountedRef.current = false;
}, []);
}
var use_update_effect_default = use_update_effect_useUpdateEffect;
;// ./node_modules/@wordpress/components/build-module/context/context-system-provider.js
const ComponentsContext = (0,external_wp_element_namespaceObject.createContext)(
/** @type {Record<string, any>} */
{}
);
ComponentsContext.displayName = "ComponentsContext";
const useComponentsContext = () => (0,external_wp_element_namespaceObject.useContext)(ComponentsContext);
function useContextSystemBridge({
value
}) {
const parentContext = useComponentsContext();
const valueRef = (0,external_wp_element_namespaceObject.useRef)(value);
use_update_effect_default(() => {
if (
// Objects are equivalent.
es6_default()(valueRef.current, value) && // But not the same reference.
valueRef.current !== value
) {
true ? external_wp_warning_default()(`Please memoize your context: ${JSON.stringify(value)}`) : 0;
}
}, [value]);
const config = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cjs_default()(parentContext !== null && parentContext !== void 0 ? parentContext : {}, value !== null && value !== void 0 ? value : {}, {
isMergeableObject: isPlainObject
});
}, [parentContext, value]);
return config;
}
const BaseContextSystemProvider = ({
children,
value
}) => {
const contextValue = useContextSystemBridge({
value
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ComponentsContext.Provider, {
value: contextValue,
children
});
};
const ContextSystemProvider = (0,external_wp_element_namespaceObject.memo)(BaseContextSystemProvider);
;// ./node_modules/@wordpress/components/build-module/context/constants.js
const COMPONENT_NAMESPACE = "data-wp-component";
const CONNECTED_NAMESPACE = "data-wp-c16t";
const CONNECT_STATIC_NAMESPACE = "__contextSystemKey__";
;// ./node_modules/@wordpress/components/build-module/context/utils.js
function getNamespace(componentName) {
return {
[COMPONENT_NAMESPACE]: componentName
};
}
function getConnectedNamespace() {
return {
[CONNECTED_NAMESPACE]: true
};
}
;// ./node_modules/tslib/tslib.es6.mjs
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
}
return __assign.apply(this, arguments);
}
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
var _, done = false;
for (var i = decorators.length - 1; i >= 0; i--) {
var context = {};
for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
for (var p in contextIn.access) context.access[p] = contextIn.access[p];
context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
if (kind === "accessor") {
if (result === void 0) continue;
if (result === null || typeof result !== "object") throw new TypeError("Object expected");
if (_ = accept(result.get)) descriptor.get = _;
if (_ = accept(result.set)) descriptor.set = _;
if (_ = accept(result.init)) initializers.unshift(_);
}
else if (_ = accept(result)) {
if (kind === "field") initializers.unshift(_);
else descriptor[key] = _;
}
}
if (target) Object.defineProperty(target, contextIn.name, descriptor);
done = true;
};
function __runInitializers(thisArg, initializers, value) {
var useValue = arguments.length > 2;
for (var i = 0; i < initializers.length; i++) {
value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
}
return useValue ? value : void 0;
};
function __propKey(x) {
return typeof x === "symbol" ? x : "".concat(x);
};
function __setFunctionName(f, name, prefix) {
if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
};
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
var __setModuleDefault = Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
};
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
function __classPrivateFieldIn(state, receiver) {
if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
return typeof state === "function" ? receiver === state : state.has(receiver);
}
function __addDisposableResource(env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async) inner = dispose;
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
env.stack.push({ value: value, dispose: dispose, async: async });
}
else if (async) {
env.stack.push({ async: true });
}
return value;
}
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
function __disposeResources(env) {
function fail(e) {
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while (r = env.stack.pop()) {
try {
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
}
else s |= 1;
}
catch (e) {
fail(e);
}
}
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
}
function __rewriteRelativeImportExtension(path, preserveJsx) {
if (typeof path === "string" && /^\.\.?\//.test(path)) {
return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
});
}
return path;
}
/* harmony default export */ const tslib_es6 = ({
__extends,
__assign,
__rest,
__decorate,
__param,
__esDecorate,
__runInitializers,
__propKey,
__setFunctionName,
__metadata,
__awaiter,
__generator,
__createBinding,
__exportStar,
__values,
__read,
__spread,
__spreadArrays,
__spreadArray,
__await,
__asyncGenerator,
__asyncDelegator,
__asyncValues,
__makeTemplateObject,
__importStar,
__importDefault,
__classPrivateFieldGet,
__classPrivateFieldSet,
__classPrivateFieldIn,
__addDisposableResource,
__disposeResources,
__rewriteRelativeImportExtension,
});
;// ./node_modules/lower-case/dist.es2015/index.js
/**
* Source: ftp://ftp.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
*/
var SUPPORTED_LOCALE = {
tr: {
regexp: /\u0130|\u0049|\u0049\u0307/g,
map: {
İ: "\u0069",
I: "\u0131",
İ: "\u0069",
},
},
az: {
regexp: /\u0130/g,
map: {
İ: "\u0069",
I: "\u0131",
İ: "\u0069",
},
},
lt: {
regexp: /\u0049|\u004A|\u012E|\u00CC|\u00CD|\u0128/g,
map: {
I: "\u0069\u0307",
J: "\u006A\u0307",
Į: "\u012F\u0307",
Ì: "\u0069\u0307\u0300",
Í: "\u0069\u0307\u0301",
Ĩ: "\u0069\u0307\u0303",
},
},
};
/**
* Localized lower case.
*/
function localeLowerCase(str, locale) {
var lang = SUPPORTED_LOCALE[locale.toLowerCase()];
if (lang)
return lowerCase(str.replace(lang.regexp, function (m) { return lang.map[m]; }));
return lowerCase(str);
}
/**
* Lower case as a function.
*/
function lowerCase(str) {
return str.toLowerCase();
}
;// ./node_modules/no-case/dist.es2015/index.js
// Support camel case ("camelCase" -> "camel Case" and "CAMELCase" -> "CAMEL Case").
var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
// Remove all non-word characters.
var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
/**
* Normalize the string into something other libraries can manipulate easier.
*/
function noCase(input, options) {
if (options === void 0) { options = {}; }
var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
var result = dist_es2015_replace(dist_es2015_replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
var start = 0;
var end = result.length;
// Trim the delimiter from around the output string.
while (result.charAt(start) === "\0")
start++;
while (result.charAt(end - 1) === "\0")
end--;
// Transform each token independently.
return result.slice(start, end).split("\0").map(transform).join(delimiter);
}
/**
* Replace `re` in the input string with the replacement value.
*/
function dist_es2015_replace(input, re, value) {
if (re instanceof RegExp)
return input.replace(re, value);
return re.reduce(function (input, re) { return input.replace(re, value); }, input);
}
;// ./node_modules/dot-case/dist.es2015/index.js
function dotCase(input, options) {
if (options === void 0) { options = {}; }
return noCase(input, __assign({ delimiter: "." }, options));
}
;// ./node_modules/param-case/dist.es2015/index.js
function paramCase(input, options) {
if (options === void 0) { options = {}; }
return dotCase(input, __assign({ delimiter: "-" }, options));
}
;// ./node_modules/memize/dist/index.js
/**
* Memize options object.
*
* @typedef MemizeOptions
*
* @property {number} [maxSize] Maximum size of the cache.
*/
/**
* Internal cache entry.
*
* @typedef MemizeCacheNode
*
* @property {?MemizeCacheNode|undefined} [prev] Previous node.
* @property {?MemizeCacheNode|undefined} [next] Next node.
* @property {Array<*>} args Function arguments for cache
* entry.
* @property {*} val Function result.
*/
/**
* Properties of the enhanced function for controlling cache.
*
* @typedef MemizeMemoizedFunction
*
* @property {()=>void} clear Clear the cache.
*/
/**
* Accepts a function to be memoized, and returns a new memoized function, with
* optional options.
*
* @template {(...args: any[]) => any} F
*
* @param {F} fn Function to memoize.
* @param {MemizeOptions} [options] Options object.
*
* @return {((...args: Parameters<F>) => ReturnType<F>) & MemizeMemoizedFunction} Memoized function.
*/
function memize(fn, options) {
var size = 0;
/** @type {?MemizeCacheNode|undefined} */
var head;
/** @type {?MemizeCacheNode|undefined} */
var tail;
options = options || {};
function memoized(/* ...args */) {
var node = head,
len = arguments.length,
args,
i;
searchCache: while (node) {
// Perform a shallow equality test to confirm that whether the node
// under test is a candidate for the arguments passed. Two arrays
// are shallowly equal if their length matches and each entry is
// strictly equal between the two sets. Avoid abstracting to a
// function which could incur an arguments leaking deoptimization.
// Check whether node arguments match arguments length
if (node.args.length !== arguments.length) {
node = node.next;
continue;
}
// Check whether node arguments match arguments values
for (i = 0; i < len; i++) {
if (node.args[i] !== arguments[i]) {
node = node.next;
continue searchCache;
}
}
// At this point we can assume we've found a match
// Surface matched node to head if not already
if (node !== head) {
// As tail, shift to previous. Must only shift if not also
// head, since if both head and tail, there is no previous.
if (node === tail) {
tail = node.prev;
}
// Adjust siblings to point to each other. If node was tail,
// this also handles new tail's empty `next` assignment.
/** @type {MemizeCacheNode} */ (node.prev).next = node.next;
if (node.next) {
node.next.prev = node.prev;
}
node.next = head;
node.prev = null;
/** @type {MemizeCacheNode} */ (head).prev = node;
head = node;
}
// Return immediately
return node.val;
}
// No cached value found. Continue to insertion phase:
// Create a copy of arguments (avoid leaking deoptimization)
args = new Array(len);
for (i = 0; i < len; i++) {
args[i] = arguments[i];
}
node = {
args: args,
// Generate the result from original function
val: fn.apply(null, args),
};
// Don't need to check whether node is already head, since it would
// have been returned above already if it was
// Shift existing head down list
if (head) {
head.prev = node;
node.next = head;
} else {
// If no head, follows that there's no tail (at initial or reset)
tail = node;
}
// Trim tail if we're reached max size and are pending cache insertion
if (size === /** @type {MemizeOptions} */ (options).maxSize) {
tail = /** @type {MemizeCacheNode} */ (tail).prev;
/** @type {MemizeCacheNode} */ (tail).next = null;
} else {
size++;
}
head = node;
return node.val;
}
memoized.clear = function () {
head = null;
tail = null;
size = 0;
};
// Ignore reason: There's not a clear solution to create an intersection of
// the function with additional properties, where the goal is to retain the
// function signature of the incoming argument and add control properties
// on the return value.
// @ts-ignore
return memoized;
}
;// ./node_modules/@wordpress/components/build-module/context/get-styled-class-name-from-key.js
function getStyledClassName(namespace) {
const kebab = paramCase(namespace);
return `components-${kebab}`;
}
const getStyledClassNameFromKey = memize(getStyledClassName);
;// ./node_modules/@emotion/sheet/dist/emotion-sheet.browser.esm.js
/*
Based off glamor's StyleSheet, thanks Sunil ❤️
high performance StyleSheet for css-in-js systems
- uses multiple style tags behind the scenes for millions of rules
- uses `insertRule` for appending in production for *much* faster performance
// usage
import { StyleSheet } from '@emotion/sheet'
let styleSheet = new StyleSheet({ key: '', container: document.head })
styleSheet.insert('#box { border: 1px solid red; }')
- appends a css rule into the stylesheet
styleSheet.flush()
- empties the stylesheet of all its contents
*/
// $FlowFixMe
function sheetForTag(tag) {
if (tag.sheet) {
// $FlowFixMe
return tag.sheet;
} // this weirdness brought to you by firefox
/* istanbul ignore next */
for (var i = 0; i < document.styleSheets.length; i++) {
if (document.styleSheets[i].ownerNode === tag) {
// $FlowFixMe
return document.styleSheets[i];
}
}
}
function createStyleElement(options) {
var tag = document.createElement('style');
tag.setAttribute('data-emotion', options.key);
if (options.nonce !== undefined) {
tag.setAttribute('nonce', options.nonce);
}
tag.appendChild(document.createTextNode(''));
tag.setAttribute('data-s', '');
return tag;
}
var StyleSheet = /*#__PURE__*/function () {
// Using Node instead of HTMLElement since container may be a ShadowRoot
function StyleSheet(options) {
var _this = this;
this._insertTag = function (tag) {
var before;
if (_this.tags.length === 0) {
if (_this.insertionPoint) {
before = _this.insertionPoint.nextSibling;
} else if (_this.prepend) {
before = _this.container.firstChild;
} else {
before = _this.before;
}
} else {
before = _this.tags[_this.tags.length - 1].nextSibling;
}
_this.container.insertBefore(tag, before);
_this.tags.push(tag);
};
this.isSpeedy = options.speedy === undefined ? "production" === 'production' : options.speedy;
this.tags = [];
this.ctr = 0;
this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets
this.key = options.key;
this.container = options.container;
this.prepend = options.prepend;
this.insertionPoint = options.insertionPoint;
this.before = null;
}
var _proto = StyleSheet.prototype;
_proto.hydrate = function hydrate(nodes) {
nodes.forEach(this._insertTag);
};
_proto.insert = function insert(rule) {
// the max length is how many rules we have per style tag, it's 65000 in speedy mode
// it's 1 in dev because we insert source maps that map a single rule to a location
// and you can only have one source map per style tag
if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
this._insertTag(createStyleElement(this));
}
var tag = this.tags[this.tags.length - 1];
if (false) { var isImportRule; }
if (this.isSpeedy) {
var sheet = sheetForTag(tag);
try {
// this is the ultrafast version, works across browsers
// the big drawback is that the css won't be editable in devtools
sheet.insertRule(rule, sheet.cssRules.length);
} catch (e) {
if (false) {}
}
} else {
tag.appendChild(document.createTextNode(rule));
}
this.ctr++;
};
_proto.flush = function flush() {
// $FlowFixMe
this.tags.forEach(function (tag) {
return tag.parentNode && tag.parentNode.removeChild(tag);
});
this.tags = [];
this.ctr = 0;
if (false) {}
};
return StyleSheet;
}();
;// ./node_modules/stylis/src/Utility.js
/**
* @param {number}
* @return {number}
*/
var abs = Math.abs
/**
* @param {number}
* @return {string}
*/
var Utility_from = String.fromCharCode
/**
* @param {object}
* @return {object}
*/
var Utility_assign = Object.assign
/**
* @param {string} value
* @param {number} length
* @return {number}
*/
function hash (value, length) {
return Utility_charat(value, 0) ^ 45 ? (((((((length << 2) ^ Utility_charat(value, 0)) << 2) ^ Utility_charat(value, 1)) << 2) ^ Utility_charat(value, 2)) << 2) ^ Utility_charat(value, 3) : 0
}
/**
* @param {string} value
* @return {string}
*/
function trim (value) {
return value.trim()
}
/**
* @param {string} value
* @param {RegExp} pattern
* @return {string?}
*/
function Utility_match (value, pattern) {
return (value = pattern.exec(value)) ? value[0] : value
}
/**
* @param {string} value
* @param {(string|RegExp)} pattern
* @param {string} replacement
* @return {string}
*/
function Utility_replace (value, pattern, replacement) {
return value.replace(pattern, replacement)
}
/**
* @param {string} value
* @param {string} search
* @return {number}
*/
function indexof (value, search) {
return value.indexOf(search)
}
/**
* @param {string} value
* @param {number} index
* @return {number}
*/
function Utility_charat (value, index) {
return value.charCodeAt(index) | 0
}
/**
* @param {string} value
* @param {number} begin
* @param {number} end
* @return {string}
*/
function Utility_substr (value, begin, end) {
return value.slice(begin, end)
}
/**
* @param {string} value
* @return {number}
*/
function Utility_strlen (value) {
return value.length
}
/**
* @param {any[]} value
* @return {number}
*/
function Utility_sizeof (value) {
return value.length
}
/**
* @param {any} value
* @param {any[]} array
* @return {any}
*/
function Utility_append (value, array) {
return array.push(value), value
}
/**
* @param {string[]} array
* @param {function} callback
* @return {string}
*/
function Utility_combine (array, callback) {
return array.map(callback).join('')
}
;// ./node_modules/stylis/src/Tokenizer.js
var line = 1
var column = 1
var Tokenizer_length = 0
var position = 0
var character = 0
var characters = ''
/**
* @param {string} value
* @param {object | null} root
* @param {object | null} parent
* @param {string} type
* @param {string[] | string} props
* @param {object[] | string} children
* @param {number} length
*/
function node (value, root, parent, type, props, children, length) {
return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''}
}
/**
* @param {object} root
* @param {object} props
* @return {object}
*/
function Tokenizer_copy (root, props) {
return Utility_assign(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)
}
/**
* @return {number}
*/
function Tokenizer_char () {
return character
}
/**
* @return {number}
*/
function prev () {
character = position > 0 ? Utility_charat(characters, --position) : 0
if (column--, character === 10)
column = 1, line--
return character
}
/**
* @return {number}
*/
function next () {
character = position < Tokenizer_length ? Utility_charat(characters, position++) : 0
if (column++, character === 10)
column = 1, line++
return character
}
/**
* @return {number}
*/
function peek () {
return Utility_charat(characters, position)
}
/**
* @return {number}
*/
function caret () {
return position
}
/**
* @param {number} begin
* @param {number} end
* @return {string}
*/
function slice (begin, end) {
return Utility_substr(characters, begin, end)
}
/**
* @param {number} type
* @return {number}
*/
function token (type) {
switch (type) {
// \0 \t \n \r \s whitespace token
case 0: case 9: case 10: case 13: case 32:
return 5
// ! + , / > @ ~ isolate token
case 33: case 43: case 44: case 47: case 62: case 64: case 126:
// ; { } breakpoint token
case 59: case 123: case 125:
return 4
// : accompanied token
case 58:
return 3
// " ' ( [ opening delimit token
case 34: case 39: case 40: case 91:
return 2
// ) ] closing delimit token
case 41: case 93:
return 1
}
return 0
}
/**
* @param {string} value
* @return {any[]}
*/
function alloc (value) {
return line = column = 1, Tokenizer_length = Utility_strlen(characters = value), position = 0, []
}
/**
* @param {any} value
* @return {any}
*/
function dealloc (value) {
return characters = '', value
}
/**
* @param {number} type
* @return {string}
*/
function delimit (type) {
return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))
}
/**
* @param {string} value
* @return {string[]}
*/
function Tokenizer_tokenize (value) {
return dealloc(tokenizer(alloc(value)))
}
/**
* @param {number} type
* @return {string}
*/
function whitespace (type) {
while (character = peek())
if (character < 33)
next()
else
break
return token(type) > 2 || token(character) > 3 ? '' : ' '
}
/**
* @param {string[]} children
* @return {string[]}
*/
function tokenizer (children) {
while (next())
switch (token(character)) {
case 0: append(identifier(position - 1), children)
break
case 2: append(delimit(character), children)
break
default: append(from(character), children)
}
return children
}
/**
* @param {number} index
* @param {number} count
* @return {string}
*/
function escaping (index, count) {
while (--count && next())
// not 0-9 A-F a-f
if (character < 48 || character > 102 || (character > 57 && character < 65) || (character > 70 && character < 97))
break
return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32))
}
/**
* @param {number} type
* @return {number}
*/
function delimiter (type) {
while (next())
switch (character) {
// ] ) " '
case type:
return position
// " '
case 34: case 39:
if (type !== 34 && type !== 39)
delimiter(character)
break
// (
case 40:
if (type === 41)
delimiter(type)
break
// \
case 92:
next()
break
}
return position
}
/**
* @param {number} type
* @param {number} index
* @return {number}
*/
function commenter (type, index) {
while (next())
// //
if (type + character === 47 + 10)
break
// /*
else if (type + character === 42 + 42 && peek() === 47)
break
return '/*' + slice(index, position - 1) + '*' + Utility_from(type === 47 ? type : next())
}
/**
* @param {number} index
* @return {string}
*/
function identifier (index) {
while (!token(peek()))
next()
return slice(index, position)
}
;// ./node_modules/stylis/src/Enum.js
var Enum_MS = '-ms-'
var Enum_MOZ = '-moz-'
var Enum_WEBKIT = '-webkit-'
var COMMENT = 'comm'
var Enum_RULESET = 'rule'
var Enum_DECLARATION = 'decl'
var PAGE = '@page'
var MEDIA = '@media'
var IMPORT = '@import'
var CHARSET = '@charset'
var VIEWPORT = '@viewport'
var SUPPORTS = '@supports'
var DOCUMENT = '@document'
var NAMESPACE = '@namespace'
var Enum_KEYFRAMES = '@keyframes'
var FONT_FACE = '@font-face'
var COUNTER_STYLE = '@counter-style'
var FONT_FEATURE_VALUES = '@font-feature-values'
;// ./node_modules/stylis/src/Serializer.js
/**
* @param {object[]} children
* @param {function} callback
* @return {string}
*/
function Serializer_serialize (children, callback) {
var output = ''
var length = Utility_sizeof(children)
for (var i = 0; i < length; i++)
output += callback(children[i], i, children, callback) || ''
return output
}
/**
* @param {object} element
* @param {number} index
* @param {object[]} children
* @param {function} callback
* @return {string}
*/
function stringify (element, index, children, callback) {
switch (element.type) {
case IMPORT: case Enum_DECLARATION: return element.return = element.return || element.value
case COMMENT: return ''
case Enum_KEYFRAMES: return element.return = element.value + '{' + Serializer_serialize(element.children, callback) + '}'
case Enum_RULESET: element.value = element.props.join(',')
}
return Utility_strlen(children = Serializer_serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : ''
}
;// ./node_modules/stylis/src/Middleware.js
/**
* @param {function[]} collection
* @return {function}
*/
function middleware (collection) {
var length = Utility_sizeof(collection)
return function (element, index, children, callback) {
var output = ''
for (var i = 0; i < length; i++)
output += collection[i](element, index, children, callback) || ''
return output
}
}
/**
* @param {function} callback
* @return {function}
*/
function rulesheet (callback) {
return function (element) {
if (!element.root)
if (element = element.return)
callback(element)
}
}
/**
* @param {object} element
* @param {number} index
* @param {object[]} children
* @param {function} callback
*/
function prefixer (element, index, children, callback) {
if (element.length > -1)
if (!element.return)
switch (element.type) {
case DECLARATION: element.return = prefix(element.value, element.length, children)
return
case KEYFRAMES:
return serialize([copy(element, {value: replace(element.value, '@', '@' + WEBKIT)})], callback)
case RULESET:
if (element.length)
return combine(element.props, function (value) {
switch (match(value, /(::plac\w+|:read-\w+)/)) {
// :read-(only|write)
case ':read-only': case ':read-write':
return serialize([copy(element, {props: [replace(value, /:(read-\w+)/, ':' + MOZ + '$1')]})], callback)
// :placeholder
case '::placeholder':
return serialize([
copy(element, {props: [replace(value, /:(plac\w+)/, ':' + WEBKIT + 'input-$1')]}),
copy(element, {props: [replace(value, /:(plac\w+)/, ':' + MOZ + '$1')]}),
copy(element, {props: [replace(value, /:(plac\w+)/, MS + 'input-$1')]})
], callback)
}
return ''
})
}
}
/**
* @param {object} element
* @param {number} index
* @param {object[]} children
*/
function namespace (element) {
switch (element.type) {
case RULESET:
element.props = element.props.map(function (value) {
return combine(tokenize(value), function (value, index, children) {
switch (charat(value, 0)) {
// \f
case 12:
return substr(value, 1, strlen(value))
// \0 ( + > ~
case 0: case 40: case 43: case 62: case 126:
return value
// :
case 58:
if (children[++index] === 'global')
children[index] = '', children[++index] = '\f' + substr(children[index], index = 1, -1)
// \s
case 32:
return index === 1 ? '' : value
default:
switch (index) {
case 0: element = value
return sizeof(children) > 1 ? '' : value
case index = sizeof(children) - 1: case 2:
return index === 2 ? value + element + element : value + element
default:
return value
}
}
})
})
}
}
;// ./node_modules/stylis/src/Parser.js
/**
* @param {string} value
* @return {object[]}
*/
function compile (value) {
return dealloc(parse('', null, null, null, [''], value = alloc(value), 0, [0], value))
}
/**
* @param {string} value
* @param {object} root
* @param {object?} parent
* @param {string[]} rule
* @param {string[]} rules
* @param {string[]} rulesets
* @param {number[]} pseudo
* @param {number[]} points
* @param {string[]} declarations
* @return {object}
*/
function parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
var index = 0
var offset = 0
var length = pseudo
var atrule = 0
var property = 0
var previous = 0
var variable = 1
var scanning = 1
var ampersand = 1
var character = 0
var type = ''
var props = rules
var children = rulesets
var reference = rule
var characters = type
while (scanning)
switch (previous = character, character = next()) {
// (
case 40:
if (previous != 108 && Utility_charat(characters, length - 1) == 58) {
if (indexof(characters += Utility_replace(delimit(character), '&', '&\f'), '&\f') != -1)
ampersand = -1
break
}
// " ' [
case 34: case 39: case 91:
characters += delimit(character)
break
// \t \n \r \s
case 9: case 10: case 13: case 32:
characters += whitespace(previous)
break
// \
case 92:
characters += escaping(caret() - 1, 7)
continue
// /
case 47:
switch (peek()) {
case 42: case 47:
Utility_append(comment(commenter(next(), caret()), root, parent), declarations)
break
default:
characters += '/'
}
break
// {
case 123 * variable:
points[index++] = Utility_strlen(characters) * ampersand
// } ; \0
case 125 * variable: case 59: case 0:
switch (character) {
// \0 }
case 0: case 125: scanning = 0
// ;
case 59 + offset:
if (property > 0 && (Utility_strlen(characters) - length))
Utility_append(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration(Utility_replace(characters, ' ', '') + ';', rule, parent, length - 2), declarations)
break
// @ ;
case 59: characters += ';'
// { rule/at-rule
default:
Utility_append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets)
if (character === 123)
if (offset === 0)
parse(characters, root, reference, reference, props, rulesets, length, points, children)
else
switch (atrule === 99 && Utility_charat(characters, 3) === 110 ? 100 : atrule) {
// d m s
case 100: case 109: case 115:
parse(value, reference, reference, rule && Utility_append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children)
break
default:
parse(characters, reference, reference, reference, [''], children, 0, points, children)
}
}
index = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo
break
// :
case 58:
length = 1 + Utility_strlen(characters), property = previous
default:
if (variable < 1)
if (character == 123)
--variable
else if (character == 125 && variable++ == 0 && prev() == 125)
continue
switch (characters += Utility_from(character), character * variable) {
// &
case 38:
ampersand = offset > 0 ? 1 : (characters += '\f', -1)
break
// ,
case 44:
points[index++] = (Utility_strlen(characters) - 1) * ampersand, ampersand = 1
break
// @
case 64:
// -
if (peek() === 45)
characters += delimit(next())
atrule = peek(), offset = length = Utility_strlen(type = characters += identifier(caret())), character++
break
// -
case 45:
if (previous === 45 && Utility_strlen(characters) == 2)
variable = 0
}
}
return rulesets
}
/**
* @param {string} value
* @param {object} root
* @param {object?} parent
* @param {number} index
* @param {number} offset
* @param {string[]} rules
* @param {number[]} points
* @param {string} type
* @param {string[]} props
* @param {string[]} children
* @param {number} length
* @return {object}
*/
function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {
var post = offset - 1
var rule = offset === 0 ? rules : ['']
var size = Utility_sizeof(rule)
for (var i = 0, j = 0, k = 0; i < index; ++i)
for (var x = 0, y = Utility_substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)
if (z = trim(j > 0 ? rule[x] + ' ' + y : Utility_replace(y, /&\f/g, rule[x])))
props[k++] = z
return node(value, root, parent, offset === 0 ? Enum_RULESET : type, props, children, length)
}
/**
* @param {number} value
* @param {object} root
* @param {object?} parent
* @return {object}
*/
function comment (value, root, parent) {
return node(value, root, parent, COMMENT, Utility_from(Tokenizer_char()), Utility_substr(value, 2, -2), 0)
}
/**
* @param {string} value
* @param {object} root
* @param {object?} parent
* @param {number} length
* @return {object}
*/
function declaration (value, root, parent, length) {
return node(value, root, parent, Enum_DECLARATION, Utility_substr(value, 0, length), Utility_substr(value, length + 1, -1), length)
}
;// ./node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js
var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
var previous = 0;
var character = 0;
while (true) {
previous = character;
character = peek(); // &\f
if (previous === 38 && character === 12) {
points[index] = 1;
}
if (token(character)) {
break;
}
next();
}
return slice(begin, position);
};
var toRules = function toRules(parsed, points) {
// pretend we've started with a comma
var index = -1;
var character = 44;
do {
switch (token(character)) {
case 0:
// &\f
if (character === 38 && peek() === 12) {
// this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
// stylis inserts \f after & to know when & where it should replace this sequence with the context selector
// and when it should just concatenate the outer and inner selectors
// it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
points[index] = 1;
}
parsed[index] += identifierWithPointTracking(position - 1, points, index);
break;
case 2:
parsed[index] += delimit(character);
break;
case 4:
// comma
if (character === 44) {
// colon
parsed[++index] = peek() === 58 ? '&\f' : '';
points[index] = parsed[index].length;
break;
}
// fallthrough
default:
parsed[index] += Utility_from(character);
}
} while (character = next());
return parsed;
};
var getRules = function getRules(value, points) {
return dealloc(toRules(alloc(value), points));
}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11
var fixedElements = /* #__PURE__ */new WeakMap();
var compat = function compat(element) {
if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
// negative .length indicates that this rule has been already prefixed
element.length < 1) {
return;
}
var value = element.value,
parent = element.parent;
var isImplicitRule = element.column === parent.column && element.line === parent.line;
while (parent.type !== 'rule') {
parent = parent.parent;
if (!parent) return;
} // short-circuit for the simplest case
if (element.props.length === 1 && value.charCodeAt(0) !== 58
/* colon */
&& !fixedElements.get(parent)) {
return;
} // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
// then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"
if (isImplicitRule) {
return;
}
fixedElements.set(element, true);
var points = [];
var rules = getRules(value, points);
var parentRules = parent.props;
for (var i = 0, k = 0; i < rules.length; i++) {
for (var j = 0; j < parentRules.length; j++, k++) {
element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
}
}
};
var removeLabel = function removeLabel(element) {
if (element.type === 'decl') {
var value = element.value;
if ( // charcode for l
value.charCodeAt(0) === 108 && // charcode for b
value.charCodeAt(2) === 98) {
// this ignores label
element["return"] = '';
element.value = '';
}
}
};
var ignoreFlag = 'emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason';
var isIgnoringComment = function isIgnoringComment(element) {
return element.type === 'comm' && element.children.indexOf(ignoreFlag) > -1;
};
var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
return function (element, index, children) {
if (element.type !== 'rule' || cache.compat) return;
var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g);
if (unsafePseudoClasses) {
var isNested = element.parent === children[0]; // in nested rules comments become children of the "auto-inserted" rule
//
// considering this input:
// .a {
// .b /* comm */ {}
// color: hotpink;
// }
// we get output corresponding to this:
// .a {
// & {
// /* comm */
// color: hotpink;
// }
// .b {}
// }
var commentContainer = isNested ? children[0].children : // global rule at the root level
children;
for (var i = commentContainer.length - 1; i >= 0; i--) {
var node = commentContainer[i];
if (node.line < element.line) {
break;
} // it is quite weird but comments are *usually* put at `column: element.column - 1`
// so we seek *from the end* for the node that is earlier than the rule's `element` and check that
// this will also match inputs like this:
// .a {
// /* comm */
// .b {}
// }
//
// but that is fine
//
// it would be the easiest to change the placement of the comment to be the first child of the rule:
// .a {
// .b { /* comm */ }
// }
// with such inputs we wouldn't have to search for the comment at all
// TODO: consider changing this comment placement in the next major version
if (node.column < element.column) {
if (isIgnoringComment(node)) {
return;
}
break;
}
}
unsafePseudoClasses.forEach(function (unsafePseudoClass) {
console.error("The pseudo class \"" + unsafePseudoClass + "\" is potentially unsafe when doing server-side rendering. Try changing it to \"" + unsafePseudoClass.split('-child')[0] + "-of-type\".");
});
}
};
};
var isImportRule = function isImportRule(element) {
return element.type.charCodeAt(1) === 105 && element.type.charCodeAt(0) === 64;
};
var isPrependedWithRegularRules = function isPrependedWithRegularRules(index, children) {
for (var i = index - 1; i >= 0; i--) {
if (!isImportRule(children[i])) {
return true;
}
}
return false;
}; // use this to remove incorrect elements from further processing
// so they don't get handed to the `sheet` (or anything else)
// as that could potentially lead to additional logs which in turn could be overhelming to the user
var nullifyElement = function nullifyElement(element) {
element.type = '';
element.value = '';
element["return"] = '';
element.children = '';
element.props = '';
};
var incorrectImportAlarm = function incorrectImportAlarm(element, index, children) {
if (!isImportRule(element)) {
return;
}
if (element.parent) {
console.error("`@import` rules can't be nested inside other rules. Please move it to the top level and put it before regular rules. Keep in mind that they can only be used within global styles.");
nullifyElement(element);
} else if (isPrependedWithRegularRules(index, children)) {
console.error("`@import` rules can't be after other rules. Please put your `@import` rules before your other rules.");
nullifyElement(element);
}
};
/* eslint-disable no-fallthrough */
function emotion_cache_browser_esm_prefix(value, length) {
switch (hash(value, length)) {
// color-adjust
case 5103:
return Enum_WEBKIT + 'print-' + value + value;
// animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
case 5737:
case 4201:
case 3177:
case 3433:
case 1641:
case 4457:
case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
case 5572:
case 6356:
case 5844:
case 3191:
case 6645:
case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
case 6391:
case 5879:
case 5623:
case 6135:
case 4599:
case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
case 4215:
case 6389:
case 5109:
case 5365:
case 5621:
case 3829:
return Enum_WEBKIT + value + value;
// appearance, user-select, transform, hyphens, text-size-adjust
case 5349:
case 4246:
case 4810:
case 6968:
case 2756:
return Enum_WEBKIT + value + Enum_MOZ + value + Enum_MS + value + value;
// flex, flex-direction
case 6828:
case 4268:
return Enum_WEBKIT + value + Enum_MS + value + value;
// order
case 6165:
return Enum_WEBKIT + value + Enum_MS + 'flex-' + value + value;
// align-items
case 5187:
return Enum_WEBKIT + value + Utility_replace(value, /(\w+).+(:[^]+)/, Enum_WEBKIT + 'box-$1$2' + Enum_MS + 'flex-$1$2') + value;
// align-self
case 5443:
return Enum_WEBKIT + value + Enum_MS + 'flex-item-' + Utility_replace(value, /flex-|-self/, '') + value;
// align-content
case 4675:
return Enum_WEBKIT + value + Enum_MS + 'flex-line-pack' + Utility_replace(value, /align-content|flex-|-self/, '') + value;
// flex-shrink
case 5548:
return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'shrink', 'negative') + value;
// flex-basis
case 5292:
return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'basis', 'preferred-size') + value;
// flex-grow
case 6060:
return Enum_WEBKIT + 'box-' + Utility_replace(value, '-grow', '') + Enum_WEBKIT + value + Enum_MS + Utility_replace(value, 'grow', 'positive') + value;
// transition
case 4554:
return Enum_WEBKIT + Utility_replace(value, /([^-])(transform)/g, '$1' + Enum_WEBKIT + '$2') + value;
// cursor
case 6187:
return Utility_replace(Utility_replace(Utility_replace(value, /(zoom-|grab)/, Enum_WEBKIT + '$1'), /(image-set)/, Enum_WEBKIT + '$1'), value, '') + value;
// background, background-image
case 5495:
case 3959:
return Utility_replace(value, /(image-set\([^]*)/, Enum_WEBKIT + '$1' + '$`$1');
// justify-content
case 4968:
return Utility_replace(Utility_replace(value, /(.+:)(flex-)?(.*)/, Enum_WEBKIT + 'box-pack:$3' + Enum_MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + Enum_WEBKIT + value + value;
// (margin|padding)-inline-(start|end)
case 4095:
case 3583:
case 4068:
case 2532:
return Utility_replace(value, /(.+)-inline(.+)/, Enum_WEBKIT + '$1$2') + value;
// (min|max)?(width|height|inline-size|block-size)
case 8116:
case 7059:
case 5753:
case 5535:
case 5445:
case 5701:
case 4933:
case 4677:
case 5533:
case 5789:
case 5021:
case 4765:
// stretch, max-content, min-content, fill-available
if (Utility_strlen(value) - 1 - length > 6) switch (Utility_charat(value, length + 1)) {
// (m)ax-content, (m)in-content
case 109:
// -
if (Utility_charat(value, length + 4) !== 45) break;
// (f)ill-available, (f)it-content
case 102:
return Utility_replace(value, /(.+:)(.+)-([^]+)/, '$1' + Enum_WEBKIT + '$2-$3' + '$1' + Enum_MOZ + (Utility_charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
// (s)tretch
case 115:
return ~indexof(value, 'stretch') ? emotion_cache_browser_esm_prefix(Utility_replace(value, 'stretch', 'fill-available'), length) + value : value;
}
break;
// position: sticky
case 4949:
// (s)ticky?
if (Utility_charat(value, length + 1) !== 115) break;
// display: (flex|inline-flex)
case 6444:
switch (Utility_charat(value, Utility_strlen(value) - 3 - (~indexof(value, '!important') && 10))) {
// stic(k)y
case 107:
return Utility_replace(value, ':', ':' + Enum_WEBKIT) + value;
// (inline-)?fl(e)x
case 101:
return Utility_replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + Enum_WEBKIT + (Utility_charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + Enum_WEBKIT + '$2$3' + '$1' + Enum_MS + '$2box$3') + value;
}
break;
// writing-mode
case 5936:
switch (Utility_charat(value, length + 11)) {
// vertical-l(r)
case 114:
return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
// vertical-r(l)
case 108:
return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
// horizontal(-)tb
case 45:
return Enum_WEBKIT + value + Enum_MS + Utility_replace(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
}
return Enum_WEBKIT + value + Enum_MS + value + value;
}
return value;
}
var emotion_cache_browser_esm_prefixer = function prefixer(element, index, children, callback) {
if (element.length > -1) if (!element["return"]) switch (element.type) {
case Enum_DECLARATION:
element["return"] = emotion_cache_browser_esm_prefix(element.value, element.length);
break;
case Enum_KEYFRAMES:
return Serializer_serialize([Tokenizer_copy(element, {
value: Utility_replace(element.value, '@', '@' + Enum_WEBKIT)
})], callback);
case Enum_RULESET:
if (element.length) return Utility_combine(element.props, function (value) {
switch (Utility_match(value, /(::plac\w+|:read-\w+)/)) {
// :read-(only|write)
case ':read-only':
case ':read-write':
return Serializer_serialize([Tokenizer_copy(element, {
props: [Utility_replace(value, /:(read-\w+)/, ':' + Enum_MOZ + '$1')]
})], callback);
// :placeholder
case '::placeholder':
return Serializer_serialize([Tokenizer_copy(element, {
props: [Utility_replace(value, /:(plac\w+)/, ':' + Enum_WEBKIT + 'input-$1')]
}), Tokenizer_copy(element, {
props: [Utility_replace(value, /:(plac\w+)/, ':' + Enum_MOZ + '$1')]
}), Tokenizer_copy(element, {
props: [Utility_replace(value, /:(plac\w+)/, Enum_MS + 'input-$1')]
})], callback);
}
return '';
});
}
};
var defaultStylisPlugins = [emotion_cache_browser_esm_prefixer];
var createCache = function createCache(options) {
var key = options.key;
if (false) {}
if ( key === 'css') {
var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
// document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
// note this very very intentionally targets all style elements regardless of the key to ensure
// that creating a cache works inside of render of a React component
Array.prototype.forEach.call(ssrStyles, function (node) {
// we want to only move elements which have a space in the data-emotion attribute value
// because that indicates that it is an Emotion 11 server-side rendered style elements
// while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
// Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
// so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
// will not result in the Emotion 10 styles being destroyed
var dataEmotionAttribute = node.getAttribute('data-emotion');
if (dataEmotionAttribute.indexOf(' ') === -1) {
return;
}
document.head.appendChild(node);
node.setAttribute('data-s', '');
});
}
var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;
if (false) {}
var inserted = {};
var container;
var nodesToHydrate = [];
{
container = options.container || document.head;
Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
// means that the style elements we're looking at are only Emotion 11 server-rendered style elements
document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
var attrib = node.getAttribute("data-emotion").split(' '); // $FlowFixMe
for (var i = 1; i < attrib.length; i++) {
inserted[attrib[i]] = true;
}
nodesToHydrate.push(node);
});
}
var _insert;
var omnipresentPlugins = [compat, removeLabel];
if (false) {}
{
var currentSheet;
var finalizingPlugins = [stringify, false ? 0 : rulesheet(function (rule) {
currentSheet.insert(rule);
})];
var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));
var stylis = function stylis(styles) {
return Serializer_serialize(compile(styles), serializer);
};
_insert = function insert(selector, serialized, sheet, shouldCache) {
currentSheet = sheet;
if (false) {}
stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);
if (shouldCache) {
cache.inserted[serialized.name] = true;
}
};
}
var cache = {
key: key,
sheet: new StyleSheet({
key: key,
container: container,
nonce: options.nonce,
speedy: options.speedy,
prepend: options.prepend,
insertionPoint: options.insertionPoint
}),
nonce: options.nonce,
inserted: inserted,
registered: {},
insert: _insert
};
cache.sheet.hydrate(nodesToHydrate);
return cache;
};
/* harmony default export */ const emotion_cache_browser_esm = (createCache);
;// ./node_modules/@emotion/hash/dist/emotion-hash.esm.js
/* eslint-disable */
// Inspired by https://github.com/garycourt/murmurhash-js
// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
function murmur2(str) {
// 'm' and 'r' are mixing constants generated offline.
// They're not really 'magic', they just happen to work well.
// const m = 0x5bd1e995;
// const r = 24;
// Initialize the hash
var h = 0; // Mix 4 bytes at a time into the hash
var k,
i = 0,
len = str.length;
for (; len >= 4; ++i, len -= 4) {
k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
k =
/* Math.imul(k, m): */
(k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
k ^=
/* k >>> r: */
k >>> 24;
h =
/* Math.imul(k, m): */
(k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
/* Math.imul(h, m): */
(h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
} // Handle the last few bytes of the input array
switch (len) {
case 3:
h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
case 2:
h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
case 1:
h ^= str.charCodeAt(i) & 0xff;
h =
/* Math.imul(h, m): */
(h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
} // Do a few final mixes of the hash to ensure the last few
// bytes are well-incorporated.
h ^= h >>> 13;
h =
/* Math.imul(h, m): */
(h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
return ((h ^ h >>> 15) >>> 0).toString(36);
}
/* harmony default export */ const emotion_hash_esm = (murmur2);
;// ./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js
var unitlessKeys = {
animationIterationCount: 1,
borderImageOutset: 1,
borderImageSlice: 1,
borderImageWidth: 1,
boxFlex: 1,
boxFlexGroup: 1,
boxOrdinalGroup: 1,
columnCount: 1,
columns: 1,
flex: 1,
flexGrow: 1,
flexPositive: 1,
flexShrink: 1,
flexNegative: 1,
flexOrder: 1,
gridRow: 1,
gridRowEnd: 1,
gridRowSpan: 1,
gridRowStart: 1,
gridColumn: 1,
gridColumnEnd: 1,
gridColumnSpan: 1,
gridColumnStart: 1,
msGridRow: 1,
msGridRowSpan: 1,
msGridColumn: 1,
msGridColumnSpan: 1,
fontWeight: 1,
lineHeight: 1,
opacity: 1,
order: 1,
orphans: 1,
tabSize: 1,
widows: 1,
zIndex: 1,
zoom: 1,
WebkitLineClamp: 1,
// SVG-related properties
fillOpacity: 1,
floodOpacity: 1,
stopOpacity: 1,
strokeDasharray: 1,
strokeDashoffset: 1,
strokeMiterlimit: 1,
strokeOpacity: 1,
strokeWidth: 1
};
/* harmony default export */ const emotion_unitless_esm = (unitlessKeys);
;// ./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js
function memoize(fn) {
var cache = Object.create(null);
return function (arg) {
if (cache[arg] === undefined) cache[arg] = fn(arg);
return cache[arg];
};
}
;// ./node_modules/@emotion/serialize/dist/emotion-serialize.browser.esm.js
var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";
var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key).";
var hyphenateRegex = /[A-Z]|^ms/g;
var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;
var isCustomProperty = function isCustomProperty(property) {
return property.charCodeAt(1) === 45;
};
var isProcessableValue = function isProcessableValue(value) {
return value != null && typeof value !== 'boolean';
};
var processStyleName = /* #__PURE__ */memoize(function (styleName) {
return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
});
var processStyleValue = function processStyleValue(key, value) {
switch (key) {
case 'animation':
case 'animationName':
{
if (typeof value === 'string') {
return value.replace(animationRegex, function (match, p1, p2) {
cursor = {
name: p1,
styles: p2,
next: cursor
};
return p1;
});
}
}
}
if (emotion_unitless_esm[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
return value + 'px';
}
return value;
};
if (false) { var hyphenatedCache, hyphenPattern, msPattern, oldProcessStyleValue, contentValues, contentValuePattern; }
var noComponentSelectorMessage = (/* unused pure expression or super */ null && ('Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.'));
function handleInterpolation(mergedProps, registered, interpolation) {
if (interpolation == null) {
return '';
}
if (interpolation.__emotion_styles !== undefined) {
if (false) {}
return interpolation;
}
switch (typeof interpolation) {
case 'boolean':
{
return '';
}
case 'object':
{
if (interpolation.anim === 1) {
cursor = {
name: interpolation.name,
styles: interpolation.styles,
next: cursor
};
return interpolation.name;
}
if (interpolation.styles !== undefined) {
var next = interpolation.next;
if (next !== undefined) {
// not the most efficient thing ever but this is a pretty rare case
// and there will be very few iterations of this generally
while (next !== undefined) {
cursor = {
name: next.name,
styles: next.styles,
next: cursor
};
next = next.next;
}
}
var styles = interpolation.styles + ";";
if (false) {}
return styles;
}
return createStringFromObject(mergedProps, registered, interpolation);
}
case 'function':
{
if (mergedProps !== undefined) {
var previousCursor = cursor;
var result = interpolation(mergedProps);
cursor = previousCursor;
return handleInterpolation(mergedProps, registered, result);
} else if (false) {}
break;
}
case 'string':
if (false) { var replaced, matched; }
break;
} // finalize string values (regular strings and functions interpolated into css calls)
if (registered == null) {
return interpolation;
}
var cached = registered[interpolation];
return cached !== undefined ? cached : interpolation;
}
function createStringFromObject(mergedProps, registered, obj) {
var string = '';
if (Array.isArray(obj)) {
for (var i = 0; i < obj.length; i++) {
string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
}
} else {
for (var _key in obj) {
var value = obj[_key];
if (typeof value !== 'object') {
if (registered != null && registered[value] !== undefined) {
string += _key + "{" + registered[value] + "}";
} else if (isProcessableValue(value)) {
string += processStyleName(_key) + ":" + processStyleValue(_key, value) + ";";
}
} else {
if (_key === 'NO_COMPONENT_SELECTOR' && "production" !== 'production') {}
if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
for (var _i = 0; _i < value.length; _i++) {
if (isProcessableValue(value[_i])) {
string += processStyleName(_key) + ":" + processStyleValue(_key, value[_i]) + ";";
}
}
} else {
var interpolated = handleInterpolation(mergedProps, registered, value);
switch (_key) {
case 'animation':
case 'animationName':
{
string += processStyleName(_key) + ":" + interpolated + ";";
break;
}
default:
{
if (false) {}
string += _key + "{" + interpolated + "}";
}
}
}
}
}
}
return string;
}
var labelPattern = /label:\s*([^\s;\n{]+)\s*(;|$)/g;
var sourceMapPattern;
if (false) {} // this is the cursor for keyframes
// keyframes are stored on the SerializedStyles object as a linked list
var cursor;
var emotion_serialize_browser_esm_serializeStyles = function serializeStyles(args, registered, mergedProps) {
if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
return args[0];
}
var stringMode = true;
var styles = '';
cursor = undefined;
var strings = args[0];
if (strings == null || strings.raw === undefined) {
stringMode = false;
styles += handleInterpolation(mergedProps, registered, strings);
} else {
if (false) {}
styles += strings[0];
} // we start at 1 since we've already handled the first arg
for (var i = 1; i < args.length; i++) {
styles += handleInterpolation(mergedProps, registered, args[i]);
if (stringMode) {
if (false) {}
styles += strings[i];
}
}
var sourceMap;
if (false) {} // using a global regex with .exec is stateful so lastIndex has to be reset each time
labelPattern.lastIndex = 0;
var identifierName = '';
var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5
while ((match = labelPattern.exec(styles)) !== null) {
identifierName += '-' + // $FlowFixMe we know it's not null
match[1];
}
var name = emotion_hash_esm(styles) + identifierName;
if (false) {}
return {
name: name,
styles: styles,
next: cursor
};
};
;// ./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js
var syncFallback = function syncFallback(create) {
return create();
};
var useInsertionEffect = external_React_['useInsertion' + 'Effect'] ? external_React_['useInsertion' + 'Effect'] : false;
var emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect || syncFallback;
var emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectWithLayoutFallback = (/* unused pure expression or super */ null && (useInsertionEffect || useLayoutEffect));
;// ./node_modules/@emotion/react/dist/emotion-element-6a883da9.browser.esm.js
var emotion_element_6a883da9_browser_esm_hasOwnProperty = {}.hasOwnProperty;
var EmotionCacheContext = /* #__PURE__ */(0,external_React_.createContext)( // we're doing this to avoid preconstruct's dead code elimination in this one case
// because this module is primarily intended for the browser and node
// but it's also required in react native and similar environments sometimes
// and we could have a special build just for that
// but this is much easier and the native packages
// might use a different theme context in the future anyway
typeof HTMLElement !== 'undefined' ? /* #__PURE__ */emotion_cache_browser_esm({
key: 'css'
}) : null);
if (false) {}
var CacheProvider = EmotionCacheContext.Provider;
var __unsafe_useEmotionCache = function useEmotionCache() {
return (0,external_React_.useContext)(EmotionCacheContext);
};
var emotion_element_6a883da9_browser_esm_withEmotionCache = function withEmotionCache(func) {
// $FlowFixMe
return /*#__PURE__*/(0,external_React_.forwardRef)(function (props, ref) {
// the cache will never be null in the browser
var cache = (0,external_React_.useContext)(EmotionCacheContext);
return func(props, cache, ref);
});
};
var emotion_element_6a883da9_browser_esm_ThemeContext = /* #__PURE__ */(0,external_React_.createContext)({});
if (false) {}
var useTheme = function useTheme() {
return useContext(emotion_element_6a883da9_browser_esm_ThemeContext);
};
var getTheme = function getTheme(outerTheme, theme) {
if (typeof theme === 'function') {
var mergedTheme = theme(outerTheme);
if (false) {}
return mergedTheme;
}
if (false) {}
return _extends({}, outerTheme, theme);
};
var createCacheWithTheme = /* #__PURE__ */(/* unused pure expression or super */ null && (weakMemoize(function (outerTheme) {
return weakMemoize(function (theme) {
return getTheme(outerTheme, theme);
});
})));
var ThemeProvider = function ThemeProvider(props) {
var theme = useContext(emotion_element_6a883da9_browser_esm_ThemeContext);
if (props.theme !== theme) {
theme = createCacheWithTheme(theme)(props.theme);
}
return /*#__PURE__*/createElement(emotion_element_6a883da9_browser_esm_ThemeContext.Provider, {
value: theme
}, props.children);
};
function withTheme(Component) {
var componentName = Component.displayName || Component.name || 'Component';
var render = function render(props, ref) {
var theme = useContext(emotion_element_6a883da9_browser_esm_ThemeContext);
return /*#__PURE__*/createElement(Component, _extends({
theme: theme,
ref: ref
}, props));
}; // $FlowFixMe
var WithTheme = /*#__PURE__*/forwardRef(render);
WithTheme.displayName = "WithTheme(" + componentName + ")";
return hoistNonReactStatics(WithTheme, Component);
}
var getLastPart = function getLastPart(functionName) {
// The match may be something like 'Object.createEmotionProps' or
// 'Loader.prototype.render'
var parts = functionName.split('.');
return parts[parts.length - 1];
};
var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
// V8
var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
if (match) return getLastPart(match[1]); // Safari / Firefox
match = /^([A-Za-z0-9$.]+)@/.exec(line);
if (match) return getLastPart(match[1]);
return undefined;
};
var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
// identifiers, thus we only need to replace what is a valid character for JS,
// but not for CSS.
var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
return identifier.replace(/\$/g, '-');
};
var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
if (!stackTrace) return undefined;
var lines = stackTrace.split('\n');
for (var i = 0; i < lines.length; i++) {
var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"
if (!functionName) continue; // If we reach one of these, we have gone too far and should quit
if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
// uppercase letter
if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
}
return undefined;
};
var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
var emotion_element_6a883da9_browser_esm_createEmotionProps = function createEmotionProps(type, props) {
if (false) {}
var newProps = {};
for (var key in props) {
if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key)) {
newProps[key] = props[key];
}
}
newProps[typePropName] = type; // For performance, only call getLabelFromStackTrace in development and when
// the label hasn't already been computed
if (false) { var label; }
return newProps;
};
var Insertion = function Insertion(_ref) {
var cache = _ref.cache,
serialized = _ref.serialized,
isStringTag = _ref.isStringTag;
registerStyles(cache, serialized, isStringTag);
var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
return insertStyles(cache, serialized, isStringTag);
});
return null;
};
var emotion_element_6a883da9_browser_esm_Emotion = /* #__PURE__ */(/* unused pure expression or super */ null && (emotion_element_6a883da9_browser_esm_withEmotionCache(function (props, cache, ref) {
var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
// not passing the registered cache to serializeStyles because it would
// make certain babel optimisations not possible
if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
cssProp = cache.registered[cssProp];
}
var WrappedComponent = props[typePropName];
var registeredStyles = [cssProp];
var className = '';
if (typeof props.className === 'string') {
className = getRegisteredStyles(cache.registered, registeredStyles, props.className);
} else if (props.className != null) {
className = props.className + " ";
}
var serialized = serializeStyles(registeredStyles, undefined, useContext(emotion_element_6a883da9_browser_esm_ThemeContext));
if (false) { var labelFromStack; }
className += cache.key + "-" + serialized.name;
var newProps = {};
for (var key in props) {
if (emotion_element_6a883da9_browser_esm_hasOwnProperty.call(props, key) && key !== 'css' && key !== typePropName && ( true || 0)) {
newProps[key] = props[key];
}
}
newProps.ref = ref;
newProps.className = className;
return /*#__PURE__*/createElement(Fragment, null, /*#__PURE__*/createElement(Insertion, {
cache: cache,
serialized: serialized,
isStringTag: typeof WrappedComponent === 'string'
}), /*#__PURE__*/createElement(WrappedComponent, newProps));
})));
if (false) {}
;// ./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js
var isBrowser = "object" !== 'undefined';
function emotion_utils_browser_esm_getRegisteredStyles(registered, registeredStyles, classNames) {
var rawClassName = '';
classNames.split(' ').forEach(function (className) {
if (registered[className] !== undefined) {
registeredStyles.push(registered[className] + ";");
} else {
rawClassName += className + " ";
}
});
return rawClassName;
}
var emotion_utils_browser_esm_registerStyles = function registerStyles(cache, serialized, isStringTag) {
var className = cache.key + "-" + serialized.name;
if ( // we only need to add the styles to the registered cache if the
// class name could be used further down
// the tree but if it's a string tag, we know it won't
// so we don't have to add it to registered cache.
// this improves memory usage since we can avoid storing the whole style string
(isStringTag === false || // we need to always store it if we're in compat mode and
// in node since emotion-server relies on whether a style is in
// the registered cache to know whether a style is global or not
// also, note that this check will be dead code eliminated in the browser
isBrowser === false ) && cache.registered[className] === undefined) {
cache.registered[className] = serialized.styles;
}
};
var emotion_utils_browser_esm_insertStyles = function insertStyles(cache, serialized, isStringTag) {
emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag);
var className = cache.key + "-" + serialized.name;
if (cache.inserted[serialized.name] === undefined) {
var current = serialized;
do {
var maybeStyles = cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);
current = current.next;
} while (current !== undefined);
}
};
;// ./node_modules/@emotion/css/create-instance/dist/emotion-css-create-instance.esm.js
function insertWithoutScoping(cache, serialized) {
if (cache.inserted[serialized.name] === undefined) {
return cache.insert('', serialized, cache.sheet, true);
}
}
function merge(registered, css, className) {
var registeredStyles = [];
var rawClassName = emotion_utils_browser_esm_getRegisteredStyles(registered, registeredStyles, className);
if (registeredStyles.length < 2) {
return className;
}
return rawClassName + css(registeredStyles);
}
var createEmotion = function createEmotion(options) {
var cache = emotion_cache_browser_esm(options); // $FlowFixMe
cache.sheet.speedy = function (value) {
if (false) {}
this.isSpeedy = value;
};
cache.compat = true;
var css = function css() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var serialized = emotion_serialize_browser_esm_serializeStyles(args, cache.registered, undefined);
emotion_utils_browser_esm_insertStyles(cache, serialized, false);
return cache.key + "-" + serialized.name;
};
var keyframes = function keyframes() {
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
var serialized = emotion_serialize_browser_esm_serializeStyles(args, cache.registered);
var animation = "animation-" + serialized.name;
insertWithoutScoping(cache, {
name: serialized.name,
styles: "@keyframes " + animation + "{" + serialized.styles + "}"
});
return animation;
};
var injectGlobal = function injectGlobal() {
for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
args[_key3] = arguments[_key3];
}
var serialized = emotion_serialize_browser_esm_serializeStyles(args, cache.registered);
insertWithoutScoping(cache, serialized);
};
var cx = function cx() {
for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
args[_key4] = arguments[_key4];
}
return merge(cache.registered, css, classnames(args));
};
return {
css: css,
cx: cx,
injectGlobal: injectGlobal,
keyframes: keyframes,
hydrate: function hydrate(ids) {
ids.forEach(function (key) {
cache.inserted[key] = true;
});
},
flush: function flush() {
cache.registered = {};
cache.inserted = {};
cache.sheet.flush();
},
// $FlowFixMe
sheet: cache.sheet,
cache: cache,
getRegisteredStyles: emotion_utils_browser_esm_getRegisteredStyles.bind(null, cache.registered),
merge: merge.bind(null, cache.registered, css)
};
};
var classnames = function classnames(args) {
var cls = '';
for (var i = 0; i < args.length; i++) {
var arg = args[i];
if (arg == null) continue;
var toAdd = void 0;
switch (typeof arg) {
case 'boolean':
break;
case 'object':
{
if (Array.isArray(arg)) {
toAdd = classnames(arg);
} else {
toAdd = '';
for (var k in arg) {
if (arg[k] && k) {
toAdd && (toAdd += ' ');
toAdd += k;
}
}
}
break;
}
default:
{
toAdd = arg;
}
}
if (toAdd) {
cls && (cls += ' ');
cls += toAdd;
}
}
return cls;
};
/* harmony default export */ const emotion_css_create_instance_esm = (createEmotion);
;// ./node_modules/@emotion/css/dist/emotion-css.esm.js
var _createEmotion = emotion_css_create_instance_esm({
key: 'css'
}),
flush = _createEmotion.flush,
hydrate = _createEmotion.hydrate,
emotion_css_esm_cx = _createEmotion.cx,
emotion_css_esm_merge = _createEmotion.merge,
emotion_css_esm_getRegisteredStyles = _createEmotion.getRegisteredStyles,
injectGlobal = _createEmotion.injectGlobal,
keyframes = _createEmotion.keyframes,
emotion_css_esm_css = _createEmotion.css,
sheet = _createEmotion.sheet,
cache = _createEmotion.cache;
;// ./node_modules/@wordpress/components/build-module/utils/hooks/use-cx.js
const isSerializedStyles = (o) => typeof o !== "undefined" && o !== null && ["name", "styles"].every((p) => typeof o[p] !== "undefined");
const useCx = () => {
const cache = __unsafe_useEmotionCache();
const cx = (0,external_wp_element_namespaceObject.useCallback)((...classNames) => {
if (cache === null) {
throw new Error("The `useCx` hook should be only used within a valid Emotion Cache Context");
}
return emotion_css_esm_cx(...classNames.map((arg) => {
if (isSerializedStyles(arg)) {
emotion_utils_browser_esm_insertStyles(cache, arg, false);
return `${cache.key}-${arg.name}`;
}
return arg;
}));
}, [cache]);
return cx;
};
;// ./node_modules/@wordpress/components/build-module/context/use-context-system.js
function useContextSystem(props, namespace) {
const contextSystemProps = useComponentsContext();
if (typeof namespace === "undefined") {
true ? external_wp_warning_default()("useContextSystem: Please provide a namespace") : 0;
}
const contextProps = contextSystemProps?.[namespace] || {};
const finalComponentProps = {
...getConnectedNamespace(),
...getNamespace(namespace)
};
const {
_overrides: overrideProps,
...otherContextProps
} = contextProps;
const initialMergedProps = Object.entries(otherContextProps).length ? Object.assign({}, otherContextProps, props) : props;
const cx = useCx();
const classes = cx(getStyledClassNameFromKey(namespace), props.className);
const rendered = typeof initialMergedProps.renderChildren === "function" ? initialMergedProps.renderChildren(initialMergedProps) : initialMergedProps.children;
for (const key in initialMergedProps) {
finalComponentProps[key] = initialMergedProps[key];
}
for (const key in overrideProps) {
finalComponentProps[key] = overrideProps[key];
}
if (rendered !== void 0) {
finalComponentProps.children = rendered;
}
finalComponentProps.className = classes;
return finalComponentProps;
}
;// ./node_modules/@wordpress/components/build-module/context/context-connect.js
function contextConnect(Component, namespace) {
return _contextConnect(Component, namespace, {
forwardsRef: true
});
}
function contextConnectWithoutRef(Component, namespace) {
return _contextConnect(Component, namespace);
}
function _contextConnect(Component, namespace, options) {
const WrappedComponent = options?.forwardsRef ? (0,external_wp_element_namespaceObject.forwardRef)(Component) : Component;
if (typeof namespace === "undefined") {
true ? external_wp_warning_default()("contextConnect: Please provide a namespace") : 0;
}
let mergedNamespace = WrappedComponent[CONNECT_STATIC_NAMESPACE] || [namespace];
if (Array.isArray(namespace)) {
mergedNamespace = [...mergedNamespace, ...namespace];
}
if (typeof namespace === "string") {
mergedNamespace = [...mergedNamespace, namespace];
}
return Object.assign(WrappedComponent, {
[CONNECT_STATIC_NAMESPACE]: [...new Set(mergedNamespace)],
displayName: namespace,
selector: `.${getStyledClassNameFromKey(namespace)}`
});
}
function getConnectNamespace(Component) {
if (!Component) {
return [];
}
let namespaces = [];
if (Component[CONNECT_STATIC_NAMESPACE]) {
namespaces = Component[CONNECT_STATIC_NAMESPACE];
}
if (Component.type && Component.type[CONNECT_STATIC_NAMESPACE]) {
namespaces = Component.type[CONNECT_STATIC_NAMESPACE];
}
return namespaces;
}
function hasConnectNamespace(Component, match) {
if (!Component) {
return false;
}
if (typeof match === "string") {
return getConnectNamespace(Component).includes(match);
}
if (Array.isArray(match)) {
return match.some((result) => getConnectNamespace(Component).includes(result));
}
return false;
}
;// ./node_modules/@wordpress/components/build-module/visually-hidden/styles.js
const visuallyHidden = {
border: 0,
clip: "rect(1px, 1px, 1px, 1px)",
WebkitClipPath: "inset( 50% )",
clipPath: "inset( 50% )",
height: "1px",
margin: "-1px",
overflow: "hidden",
padding: 0,
position: "absolute",
width: "1px",
wordWrap: "normal"
};
;// ./node_modules/@babel/runtime/helpers/esm/extends.js
function extends_extends() {
return extends_extends = Object.assign ? Object.assign.bind() : function (n) {
for (var e = 1; e < arguments.length; e++) {
var t = arguments[e];
for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
}
return n;
}, extends_extends.apply(null, arguments);
}
;// ./node_modules/@emotion/styled/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js
var 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|download|draggable|encType|enterKeyHint|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|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)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23
var isPropValid = /* #__PURE__ */memoize(function (prop) {
return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
/* o */
&& prop.charCodeAt(1) === 110
/* n */
&& prop.charCodeAt(2) < 91;
}
/* Z+1 */
);
;// ./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js
var testOmitPropsOnStringTag = isPropValid;
var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
return key !== 'theme';
};
var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
return typeof tag === 'string' && // 96 is one less than the char code
// for "a" so this is checking that
// it's a lowercase character
tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
};
var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
var shouldForwardProp;
if (options) {
var optionsShouldForwardProp = options.shouldForwardProp;
shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
} : optionsShouldForwardProp;
}
if (typeof shouldForwardProp !== 'function' && isReal) {
shouldForwardProp = tag.__emotion_forwardProp;
}
return shouldForwardProp;
};
var emotion_styled_base_browser_esm_ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";
var emotion_styled_base_browser_esm_Insertion = function Insertion(_ref) {
var cache = _ref.cache,
serialized = _ref.serialized,
isStringTag = _ref.isStringTag;
emotion_utils_browser_esm_registerStyles(cache, serialized, isStringTag);
var rules = emotion_use_insertion_effect_with_fallbacks_browser_esm_useInsertionEffectAlwaysWithSyncFallback(function () {
return emotion_utils_browser_esm_insertStyles(cache, serialized, isStringTag);
});
return null;
};
var createStyled = function createStyled(tag, options) {
if (false) {}
var isReal = tag.__emotion_real === tag;
var baseTag = isReal && tag.__emotion_base || tag;
var identifierName;
var targetClassName;
if (options !== undefined) {
identifierName = options.label;
targetClassName = options.target;
}
var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
var shouldUseAs = !defaultShouldForwardProp('as');
return function () {
var args = arguments;
var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];
if (identifierName !== undefined) {
styles.push("label:" + identifierName + ";");
}
if (args[0] == null || args[0].raw === undefined) {
styles.push.apply(styles, args);
} else {
if (false) {}
styles.push(args[0][0]);
var len = args.length;
var i = 1;
for (; i < len; i++) {
if (false) {}
styles.push(args[i], args[0][i]);
}
} // $FlowFixMe: we need to cast StatelessFunctionalComponent to our PrivateStyledComponent class
var Styled = emotion_element_6a883da9_browser_esm_withEmotionCache(function (props, cache, ref) {
var FinalTag = shouldUseAs && props.as || baseTag;
var className = '';
var classInterpolations = [];
var mergedProps = props;
if (props.theme == null) {
mergedProps = {};
for (var key in props) {
mergedProps[key] = props[key];
}
mergedProps.theme = (0,external_React_.useContext)(emotion_element_6a883da9_browser_esm_ThemeContext);
}
if (typeof props.className === 'string') {
className = emotion_utils_browser_esm_getRegisteredStyles(cache.registered, classInterpolations, props.className);
} else if (props.className != null) {
className = props.className + " ";
}
var serialized = emotion_serialize_browser_esm_serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);
className += cache.key + "-" + serialized.name;
if (targetClassName !== undefined) {
className += " " + targetClassName;
}
var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
var newProps = {};
for (var _key in props) {
if (shouldUseAs && _key === 'as') continue;
if ( // $FlowFixMe
finalShouldForwardProp(_key)) {
newProps[_key] = props[_key];
}
}
newProps.className = className;
newProps.ref = ref;
return /*#__PURE__*/(0,external_React_.createElement)(external_React_.Fragment, null, /*#__PURE__*/(0,external_React_.createElement)(emotion_styled_base_browser_esm_Insertion, {
cache: cache,
serialized: serialized,
isStringTag: typeof FinalTag === 'string'
}), /*#__PURE__*/(0,external_React_.createElement)(FinalTag, newProps));
});
Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
Styled.defaultProps = tag.defaultProps;
Styled.__emotion_real = Styled;
Styled.__emotion_base = baseTag;
Styled.__emotion_styles = styles;
Styled.__emotion_forwardProp = shouldForwardProp;
Object.defineProperty(Styled, 'toString', {
value: function value() {
if (targetClassName === undefined && "production" !== 'production') {} // $FlowFixMe: coerce undefined to string
return "." + targetClassName;
}
});
Styled.withComponent = function (nextTag, nextOptions) {
return createStyled(nextTag, extends_extends({}, options, nextOptions, {
shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
})).apply(void 0, styles);
};
return Styled;
};
};
/* harmony default export */ const emotion_styled_base_browser_esm = (createStyled);
;// ./node_modules/@wordpress/components/build-module/view/component.js
const PolymorphicDiv = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e19lxcc00"
} : 0)( true ? "" : 0);
function UnforwardedView({
as,
...restProps
}, ref) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PolymorphicDiv, {
as,
ref,
...restProps
});
}
const View = Object.assign((0,external_wp_element_namespaceObject.forwardRef)(UnforwardedView), {
selector: ".components-view"
});
var component_default = View;
;// ./node_modules/@wordpress/components/build-module/visually-hidden/component.js
function UnconnectedVisuallyHidden(props, forwardedRef) {
const {
style: styleProp,
...contextProps
} = useContextSystem(props, "VisuallyHidden");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
ref: forwardedRef,
...contextProps,
style: {
...visuallyHidden,
...styleProp || {}
}
});
}
const component_VisuallyHidden = contextConnect(UnconnectedVisuallyHidden, "VisuallyHidden");
var component_component_default = component_VisuallyHidden;
;// ./node_modules/@wordpress/components/build-module/alignment-matrix-control/utils.js
const GRID = [["top left", "top center", "top right"], ["center left", "center center", "center right"], ["bottom left", "bottom center", "bottom right"]];
const ALIGNMENT_LABEL = {
"top left": (0,external_wp_i18n_namespaceObject.__)("Top Left"),
"top center": (0,external_wp_i18n_namespaceObject.__)("Top Center"),
"top right": (0,external_wp_i18n_namespaceObject.__)("Top Right"),
"center left": (0,external_wp_i18n_namespaceObject.__)("Center Left"),
"center center": (0,external_wp_i18n_namespaceObject.__)("Center"),
center: (0,external_wp_i18n_namespaceObject.__)("Center"),
"center right": (0,external_wp_i18n_namespaceObject.__)("Center Right"),
"bottom left": (0,external_wp_i18n_namespaceObject.__)("Bottom Left"),
"bottom center": (0,external_wp_i18n_namespaceObject.__)("Bottom Center"),
"bottom right": (0,external_wp_i18n_namespaceObject.__)("Bottom Right")
};
const ALIGNMENTS = GRID.flat();
function normalize(value) {
const normalized = value === "center" ? "center center" : value;
const transformed = normalized?.replace("-", " ");
return ALIGNMENTS.includes(transformed) ? transformed : void 0;
}
function getItemId(prefixId, value) {
const normalized = normalize(value);
if (!normalized) {
return;
}
const id = normalized.replace(" ", "-");
return `${prefixId}-${id}`;
}
function getItemValue(prefixId, id) {
const value = id?.replace(prefixId + "-", "");
return normalize(value);
}
function getAlignmentIndex(alignment = "center") {
const normalized = normalize(alignment);
if (!normalized) {
return void 0;
}
const index = ALIGNMENTS.indexOf(normalized);
return index > -1 ? index : void 0;
}
// EXTERNAL MODULE: ./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js
var hoist_non_react_statics_cjs = __webpack_require__(1880);
;// ./node_modules/@emotion/react/dist/emotion-react.browser.esm.js
var pkg = {
name: "@emotion/react",
version: "11.10.6",
main: "dist/emotion-react.cjs.js",
module: "dist/emotion-react.esm.js",
browser: {
"./dist/emotion-react.esm.js": "./dist/emotion-react.browser.esm.js"
},
exports: {
".": {
module: {
worker: "./dist/emotion-react.worker.esm.js",
browser: "./dist/emotion-react.browser.esm.js",
"default": "./dist/emotion-react.esm.js"
},
"default": "./dist/emotion-react.cjs.js"
},
"./jsx-runtime": {
module: {
worker: "./jsx-runtime/dist/emotion-react-jsx-runtime.worker.esm.js",
browser: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js"
},
"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
},
"./_isolated-hnrs": {
module: {
worker: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.worker.esm.js",
browser: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js"
},
"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
},
"./jsx-dev-runtime": {
module: {
worker: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.worker.esm.js",
browser: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js"
},
"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
},
"./package.json": "./package.json",
"./types/css-prop": "./types/css-prop.d.ts",
"./macro": "./macro.js"
},
types: "types/index.d.ts",
files: [
"src",
"dist",
"jsx-runtime",
"jsx-dev-runtime",
"_isolated-hnrs",
"types/*.d.ts",
"macro.js",
"macro.d.ts",
"macro.js.flow"
],
sideEffects: false,
author: "Emotion Contributors",
license: "MIT",
scripts: {
"test:typescript": "dtslint types"
},
dependencies: {
"@babel/runtime": "^7.18.3",
"@emotion/babel-plugin": "^11.10.6",
"@emotion/cache": "^11.10.5",
"@emotion/serialize": "^1.1.1",
"@emotion/use-insertion-effect-with-fallbacks": "^1.0.0",
"@emotion/utils": "^1.2.0",
"@emotion/weak-memoize": "^0.3.0",
"hoist-non-react-statics": "^3.3.1"
},
peerDependencies: {
react: ">=16.8.0"
},
peerDependenciesMeta: {
"@types/react": {
optional: true
}
},
devDependencies: {
"@definitelytyped/dtslint": "0.0.112",
"@emotion/css": "11.10.6",
"@emotion/css-prettifier": "1.1.1",
"@emotion/server": "11.10.0",
"@emotion/styled": "11.10.6",
"html-tag-names": "^1.1.2",
react: "16.14.0",
"svg-tag-names": "^1.1.1",
typescript: "^4.5.5"
},
repository: "https://github.com/emotion-js/emotion/tree/main/packages/react",
publishConfig: {
access: "public"
},
"umd:main": "dist/emotion-react.umd.min.js",
preconstruct: {
entrypoints: [
"./index.js",
"./jsx-runtime.js",
"./jsx-dev-runtime.js",
"./_isolated-hnrs.js"
],
umdName: "emotionReact",
exports: {
envConditions: [
"browser",
"worker"
],
extra: {
"./types/css-prop": "./types/css-prop.d.ts",
"./macro": "./macro.js"
}
}
}
};
var jsx = function jsx(type, props) {
var args = arguments;
if (props == null || !hasOwnProperty.call(props, 'css')) {
// $FlowFixMe
return createElement.apply(undefined, args);
}
var argsLength = args.length;
var createElementArgArray = new Array(argsLength);
createElementArgArray[0] = Emotion;
createElementArgArray[1] = createEmotionProps(type, props);
for (var i = 2; i < argsLength; i++) {
createElementArgArray[i] = args[i];
} // $FlowFixMe
return createElement.apply(null, createElementArgArray);
};
var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
// initial client-side render from SSR, use place of hydrating tag
var Global = /* #__PURE__ */(/* unused pure expression or super */ null && (withEmotionCache(function (props, cache) {
if (false) {}
var styles = props.styles;
var serialized = serializeStyles([styles], undefined, useContext(ThemeContext));
// but it is based on a constant that will never change at runtime
// it's effectively like having two implementations and switching them out
// so it's not actually breaking anything
var sheetRef = useRef();
useInsertionEffectWithLayoutFallback(function () {
var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675
var sheet = new cache.sheet.constructor({
key: key,
nonce: cache.sheet.nonce,
container: cache.sheet.container,
speedy: cache.sheet.isSpeedy
});
var rehydrating = false; // $FlowFixMe
var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");
if (cache.sheet.tags.length) {
sheet.before = cache.sheet.tags[0];
}
if (node !== null) {
rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s
node.setAttribute('data-emotion', key);
sheet.hydrate([node]);
}
sheetRef.current = [sheet, rehydrating];
return function () {
sheet.flush();
};
}, [cache]);
useInsertionEffectWithLayoutFallback(function () {
var sheetRefCurrent = sheetRef.current;
var sheet = sheetRefCurrent[0],
rehydrating = sheetRefCurrent[1];
if (rehydrating) {
sheetRefCurrent[1] = false;
return;
}
if (serialized.next !== undefined) {
// insert keyframes
insertStyles(cache, serialized.next, true);
}
if (sheet.tags.length) {
// if this doesn't exist then it will be null so the style element will be appended
var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
sheet.before = element;
sheet.flush();
}
cache.insert("", serialized, sheet, false);
}, [cache, serialized.name]);
return null;
})));
if (false) {}
function emotion_react_browser_esm_css() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return emotion_serialize_browser_esm_serializeStyles(args);
}
var emotion_react_browser_esm_keyframes = function keyframes() {
var insertable = emotion_react_browser_esm_css.apply(void 0, arguments);
var name = "animation-" + insertable.name; // $FlowFixMe
return {
name: name,
styles: "@keyframes " + name + "{" + insertable.styles + "}",
anim: 1,
toString: function toString() {
return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
}
};
};
var emotion_react_browser_esm_classnames = function classnames(args) {
var len = args.length;
var i = 0;
var cls = '';
for (; i < len; i++) {
var arg = args[i];
if (arg == null) continue;
var toAdd = void 0;
switch (typeof arg) {
case 'boolean':
break;
case 'object':
{
if (Array.isArray(arg)) {
toAdd = classnames(arg);
} else {
if (false) {}
toAdd = '';
for (var k in arg) {
if (arg[k] && k) {
toAdd && (toAdd += ' ');
toAdd += k;
}
}
}
break;
}
default:
{
toAdd = arg;
}
}
if (toAdd) {
cls && (cls += ' ');
cls += toAdd;
}
}
return cls;
};
function emotion_react_browser_esm_merge(registered, css, className) {
var registeredStyles = [];
var rawClassName = getRegisteredStyles(registered, registeredStyles, className);
if (registeredStyles.length < 2) {
return className;
}
return rawClassName + css(registeredStyles);
}
var emotion_react_browser_esm_Insertion = function Insertion(_ref) {
var cache = _ref.cache,
serializedArr = _ref.serializedArr;
var rules = useInsertionEffectAlwaysWithSyncFallback(function () {
for (var i = 0; i < serializedArr.length; i++) {
var res = insertStyles(cache, serializedArr[i], false);
}
});
return null;
};
var ClassNames = /* #__PURE__ */(/* unused pure expression or super */ null && (withEmotionCache(function (props, cache) {
var hasRendered = false;
var serializedArr = [];
var css = function css() {
if (hasRendered && "production" !== 'production') {}
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
var serialized = serializeStyles(args, cache.registered);
serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`
registerStyles(cache, serialized, false);
return cache.key + "-" + serialized.name;
};
var cx = function cx() {
if (hasRendered && "production" !== 'production') {}
for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
args[_key2] = arguments[_key2];
}
return emotion_react_browser_esm_merge(cache.registered, css, emotion_react_browser_esm_classnames(args));
};
var content = {
css: css,
cx: cx,
theme: useContext(ThemeContext)
};
var ele = props.children(content);
hasRendered = true;
return /*#__PURE__*/createElement(Fragment, null, /*#__PURE__*/createElement(emotion_react_browser_esm_Insertion, {
cache: cache,
serializedArr: serializedArr
}), ele);
})));
if (false) {}
if (false) { var globalKey, globalContext, isTestEnv, emotion_react_browser_esm_isBrowser; }
;// ./node_modules/@wordpress/components/build-module/utils/space.js
const GRID_BASE = "4px";
function space(value) {
if (typeof value === "undefined") {
return void 0;
}
if (!value) {
return "0";
}
const asInt = typeof value === "number" ? value : Number(value);
if (typeof window !== "undefined" && window.CSS?.supports?.("margin", value.toString()) || Number.isNaN(asInt)) {
return value.toString();
}
return `calc(${GRID_BASE} * ${value})`;
}
;// ./node_modules/@wordpress/components/build-module/utils/colors-values.js
const white = "#fff";
const GRAY = {
900: "#1e1e1e",
800: "#2f2f2f",
/** Meets 4.6:1 text contrast against white. */
700: "#757575",
/** Meets 3:1 UI or large text contrast against white. */
600: "#949494",
400: "#ccc",
/** Used for most borders. */
300: "#ddd",
/** Used sparingly for light borders. */
200: "#e0e0e0",
/** Used for light gray backgrounds. */
100: "#f0f0f0"
};
const ALERT = {
yellow: "#f0b849",
red: "#d94f4f",
green: "#4ab866"
};
const THEME = {
accent: `var(--wp-components-color-accent, var(--wp-admin-theme-color, #3858e9))`,
accentDarker10: `var(--wp-components-color-accent-darker-10, var(--wp-admin-theme-color-darker-10, #2145e6))`,
accentDarker20: `var(--wp-components-color-accent-darker-20, var(--wp-admin-theme-color-darker-20, #183ad6))`,
/** Used when placing text on the accent color. */
accentInverted: `var(--wp-components-color-accent-inverted, ${white})`,
background: `var(--wp-components-color-background, ${white})`,
foreground: `var(--wp-components-color-foreground, ${GRAY[900]})`,
/** Used when placing text on the foreground color. */
foregroundInverted: `var(--wp-components-color-foreground-inverted, ${white})`,
gray: {
/** @deprecated Use `COLORS.theme.foreground` instead. */
900: `var(--wp-components-color-foreground, ${GRAY[900]})`,
800: `var(--wp-components-color-gray-800, ${GRAY[800]})`,
700: `var(--wp-components-color-gray-700, ${GRAY[700]})`,
600: `var(--wp-components-color-gray-600, ${GRAY[600]})`,
400: `var(--wp-components-color-gray-400, ${GRAY[400]})`,
300: `var(--wp-components-color-gray-300, ${GRAY[300]})`,
200: `var(--wp-components-color-gray-200, ${GRAY[200]})`,
100: `var(--wp-components-color-gray-100, ${GRAY[100]})`
}
};
const UI = {
background: THEME.background,
backgroundDisabled: THEME.gray[100],
border: THEME.gray[600],
borderHover: THEME.gray[700],
borderFocus: THEME.accent,
borderDisabled: THEME.gray[400],
textDisabled: THEME.gray[600],
// Matches @wordpress/base-styles
darkGrayPlaceholder: `color-mix(in srgb, ${THEME.foreground}, transparent 38%)`,
lightGrayPlaceholder: `color-mix(in srgb, ${THEME.background}, transparent 35%)`
};
const COLORS = Object.freeze({
/**
* The main gray color object.
*
* @deprecated Use semantic aliases in `COLORS.ui` or theme-ready variables in `COLORS.theme.gray`.
*/
gray: GRAY,
// TODO: Stop exporting this when everything is migrated to `theme` or `ui`
/**
* @deprecated Prefer theme-ready variables in `COLORS.theme`.
*/
white,
alert: ALERT,
/**
* Theme-ready variables with fallbacks.
*
* Prefer semantic aliases in `COLORS.ui` when applicable.
*/
theme: THEME,
/**
* Semantic aliases (prefer these over raw variables when applicable).
*/
ui: UI
});
var colors_values_default = (/* unused pure expression or super */ null && (COLORS));
;// ./node_modules/@wordpress/components/build-module/utils/config-values.js
const CONTROL_HEIGHT = "36px";
const CONTROL_PROPS = {
// These values should be shared with TextControl.
controlPaddingX: 12,
controlPaddingXSmall: 8,
controlPaddingXLarge: 12 * 1.3334,
// TODO: Deprecate
controlBoxShadowFocus: `0 0 0 0.5px ${COLORS.theme.accent}`,
controlHeight: CONTROL_HEIGHT,
controlHeightXSmall: `calc( ${CONTROL_HEIGHT} * 0.6 )`,
controlHeightSmall: `calc( ${CONTROL_HEIGHT} * 0.8 )`,
controlHeightLarge: `calc( ${CONTROL_HEIGHT} * 1.2 )`,
controlHeightXLarge: `calc( ${CONTROL_HEIGHT} * 1.4 )`
};
var config_values_default = Object.assign({}, CONTROL_PROPS, {
colorDivider: "rgba(0, 0, 0, 0.1)",
colorScrollbarThumb: "rgba(0, 0, 0, 0.2)",
colorScrollbarThumbHover: "rgba(0, 0, 0, 0.5)",
colorScrollbarTrack: "rgba(0, 0, 0, 0.04)",
elevationIntensity: 1,
radiusXSmall: "1px",
radiusSmall: "2px",
radiusMedium: "4px",
radiusLarge: "8px",
radiusFull: "9999px",
radiusRound: "50%",
borderWidth: "1px",
borderWidthFocus: "1.5px",
borderWidthTab: "4px",
spinnerSize: 16,
fontSize: "13px",
fontSizeH1: "calc(2.44 * 13px)",
fontSizeH2: "calc(1.95 * 13px)",
fontSizeH3: "calc(1.56 * 13px)",
fontSizeH4: "calc(1.25 * 13px)",
fontSizeH5: "13px",
fontSizeH6: "calc(0.8 * 13px)",
fontSizeInputMobile: "16px",
fontSizeMobile: "15px",
fontSizeSmall: "calc(0.92 * 13px)",
fontSizeXSmall: "calc(0.75 * 13px)",
fontLineHeightBase: "1.4",
fontWeight: "normal",
fontWeightHeading: "600",
gridBase: "4px",
cardPaddingXSmall: `${space(2)}`,
cardPaddingSmall: `${space(4)}`,
cardPaddingMedium: `${space(4)} ${space(6)}`,
cardPaddingLarge: `${space(6)} ${space(8)}`,
elevationXSmall: `0 1px 1px rgba(0, 0, 0, 0.03), 0 1px 2px rgba(0, 0, 0, 0.02), 0 3px 3px rgba(0, 0, 0, 0.02), 0 4px 4px rgba(0, 0, 0, 0.01)`,
elevationSmall: `0 1px 2px rgba(0, 0, 0, 0.05), 0 2px 3px rgba(0, 0, 0, 0.04), 0 6px 6px rgba(0, 0, 0, 0.03), 0 8px 8px rgba(0, 0, 0, 0.02)`,
elevationMedium: `0 2px 3px rgba(0, 0, 0, 0.05), 0 4px 5px rgba(0, 0, 0, 0.04), 0 12px 12px rgba(0, 0, 0, 0.03), 0 16px 16px rgba(0, 0, 0, 0.02)`,
elevationLarge: `0 5px 15px rgba(0, 0, 0, 0.08), 0 15px 27px rgba(0, 0, 0, 0.07), 0 30px 36px rgba(0, 0, 0, 0.04), 0 50px 43px rgba(0, 0, 0, 0.02)`,
surfaceBackgroundColor: COLORS.white,
surfaceBackgroundSubtleColor: "#F3F3F3",
surfaceBackgroundTintColor: "#F5F5F5",
surfaceBorderColor: "rgba(0, 0, 0, 0.1)",
surfaceBorderBoldColor: "rgba(0, 0, 0, 0.15)",
surfaceBorderSubtleColor: "rgba(0, 0, 0, 0.05)",
surfaceBackgroundTertiaryColor: COLORS.white,
surfaceColor: COLORS.white,
transitionDuration: "200ms",
transitionDurationFast: "160ms",
transitionDurationFaster: "120ms",
transitionDurationFastest: "100ms",
transitionTimingFunction: "cubic-bezier(0.08, 0.52, 0.52, 1)",
transitionTimingFunctionControl: "cubic-bezier(0.12, 0.8, 0.32, 1)"
});
;// ./node_modules/@wordpress/components/build-module/alignment-matrix-control/styles.js
function _EMOTION_STRINGIFIED_CSS_ERROR__() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const rootBase = ({
size = 92
}) => /* @__PURE__ */ emotion_react_browser_esm_css("direction:ltr;display:grid;grid-template-columns:repeat( 3, 1fr );grid-template-rows:repeat( 3, 1fr );box-sizing:border-box;width:", size, "px;aspect-ratio:1;border-radius:", config_values_default.radiusMedium, ";outline:none;" + ( true ? "" : 0), true ? "" : 0);
var _ref = true ? {
name: "e0dnmk",
styles: "cursor:pointer"
} : 0;
const GridContainer = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1r95csn3"
} : 0)(rootBase, " border:1px solid transparent;", (props) => props.disablePointerEvents ? /* @__PURE__ */ emotion_react_browser_esm_css( true ? "" : 0, true ? "" : 0) : _ref, ";" + ( true ? "" : 0));
const GridRow = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1r95csn2"
} : 0)( true ? {
name: "1fbxn64",
styles: "grid-column:1/-1;box-sizing:border-box;display:grid;grid-template-columns:repeat( 3, 1fr )"
} : 0);
const Cell = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1r95csn1"
} : 0)( true ? {
name: "e2kws5",
styles: "position:relative;display:flex;align-items:center;justify-content:center;box-sizing:border-box;margin:0;padding:0;appearance:none;border:none;outline:none"
} : 0);
const POINT_SIZE = 6;
const Point = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1r95csn0"
} : 0)("display:block;contain:strict;box-sizing:border-box;width:", POINT_SIZE, "px;aspect-ratio:1;margin:auto;color:", COLORS.theme.gray[400], ";border:", POINT_SIZE / 2, "px solid currentColor;", Cell, "[data-active-item] &{color:", COLORS.gray[900], ";transform:scale( calc( 5 / 3 ) );}", Cell, ":not([data-active-item]):hover &{color:", COLORS.theme.accent, ";}", Cell, "[data-focus-visible] &{outline:1px solid ", COLORS.theme.accent, ";outline-offset:1px;}@media not ( prefers-reduced-motion ){transition-property:color,transform;transition-duration:120ms;transition-timing-function:linear;}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/alignment-matrix-control/cell.js
function cell_Cell({
id,
value,
...props
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tooltip_default, {
text: ALIGNMENT_LABEL[value],
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(composite_Composite.Item, {
id,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Cell, {
...props,
role: "gridcell"
}),
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
children: value
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Point, {
role: "presentation"
})]
})
});
}
;// ./node_modules/@wordpress/components/build-module/alignment-matrix-control/icon.js
const BASE_SIZE = 24;
const GRID_CELL_SIZE = 7;
const GRID_PADDING = (BASE_SIZE - 3 * GRID_CELL_SIZE) / 2;
const DOT_SIZE = 2;
const DOT_SIZE_SELECTED = 4;
function AlignmentMatrixControlIcon({
className,
disablePointerEvents = true,
size,
width,
height,
style = {},
value = "center",
...props
}) {
var _ref, _ref2;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: `0 0 ${BASE_SIZE} ${BASE_SIZE}`,
width: (_ref = size !== null && size !== void 0 ? size : width) !== null && _ref !== void 0 ? _ref : BASE_SIZE,
height: (_ref2 = size !== null && size !== void 0 ? size : height) !== null && _ref2 !== void 0 ? _ref2 : BASE_SIZE,
role: "presentation",
className: dist_clsx("component-alignment-matrix-control-icon", className),
style: {
pointerEvents: disablePointerEvents ? "none" : void 0,
...style
},
...props,
children: ALIGNMENTS.map((align, index) => {
const dotSize = getAlignmentIndex(value) === index ? DOT_SIZE_SELECTED : DOT_SIZE;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Rect, {
x: GRID_PADDING + index % 3 * GRID_CELL_SIZE + (GRID_CELL_SIZE - dotSize) / 2,
y: GRID_PADDING + Math.floor(index / 3) * GRID_CELL_SIZE + (GRID_CELL_SIZE - dotSize) / 2,
width: dotSize,
height: dotSize,
fill: "currentColor"
}, align);
})
});
}
var icon_default = AlignmentMatrixControlIcon;
;// ./node_modules/@wordpress/components/build-module/alignment-matrix-control/index.js
function UnforwardedAlignmentMatrixControl({
className,
id,
label = (0,external_wp_i18n_namespaceObject.__)("Alignment Matrix Control"),
defaultValue = "center center",
value,
onChange,
width = 92,
...props
}) {
const baseId = (0,external_wp_compose_namespaceObject.useInstanceId)(UnforwardedAlignmentMatrixControl, "alignment-matrix-control", id);
const setActiveId = (0,external_wp_element_namespaceObject.useCallback)((nextActiveId) => {
const nextValue = getItemValue(baseId, nextActiveId);
if (nextValue) {
onChange?.(nextValue);
}
}, [baseId, onChange]);
const classes = dist_clsx("component-alignment-matrix-control", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(composite_Composite, {
defaultActiveId: getItemId(baseId, defaultValue),
activeId: getItemId(baseId, value),
setActiveId,
rtl: (0,external_wp_i18n_namespaceObject.isRTL)(),
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GridContainer, {
...props,
"aria-label": label,
className: classes,
id: baseId,
role: "grid",
size: width
}),
children: GRID.map((cells, index) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(composite_Composite.Row, {
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GridRow, {
role: "row"
}),
children: cells.map((cell) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(cell_Cell, {
id: getItemId(baseId, cell),
value: cell
}, cell))
}, index))
});
}
const AlignmentMatrixControl = Object.assign(UnforwardedAlignmentMatrixControl, {
/**
* Render an alignment matrix as an icon.
*
* ```jsx
* import { AlignmentMatrixControl } from '@wordpress/components';
*
* <Icon icon={<AlignmentMatrixControl.Icon value="top left" />} />
* ```
*/
Icon: Object.assign(icon_default, {
displayName: "AlignmentMatrixControl.Icon"
})
});
var alignment_matrix_control_default = AlignmentMatrixControl;
;// ./node_modules/@wordpress/components/build-module/animate/index.js
function getDefaultOrigin(type) {
return type === "appear" ? "top" : "left";
}
function getAnimateClassName(options) {
if (options.type === "loading") {
return "components-animate__loading";
}
const {
type,
origin = getDefaultOrigin(type)
} = options;
if (type === "appear") {
const [yAxis, xAxis = "center"] = origin.split(" ");
return dist_clsx("components-animate__appear", {
["is-from-" + xAxis]: xAxis !== "center",
["is-from-" + yAxis]: yAxis !== "middle"
});
}
if (type === "slide-in") {
return dist_clsx("components-animate__slide-in", "is-from-" + origin);
}
return void 0;
}
function Animate({
type,
options = {},
children
}) {
return children({
className: getAnimateClassName({
type,
...options
})
});
}
var animate_default = Animate;
;// ./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs
"use client";
const LayoutGroupContext = (0,external_React_.createContext)({});
;// ./node_modules/framer-motion/dist/es/utils/use-constant.mjs
/**
* Creates a constant value over the lifecycle of a component.
*
* Even if `useMemo` is provided an empty array as its final argument, it doesn't offer
* a guarantee that it won't re-run for performance reasons later on. By using `useConstant`
* you can ensure that initialisers don't execute twice or more.
*/
function useConstant(init) {
const ref = (0,external_React_.useRef)(null);
if (ref.current === null) {
ref.current = init();
}
return ref.current;
}
;// ./node_modules/framer-motion/dist/es/context/PresenceContext.mjs
"use client";
/**
* @public
*/
const PresenceContext_PresenceContext = (0,external_React_.createContext)(null);
;// ./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs
"use client";
/**
* @public
*/
const MotionConfigContext = (0,external_React_.createContext)({
transformPagePoint: (p) => p,
isStatic: false,
reducedMotion: "never",
});
;// ./node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.mjs
"use client";
/**
* Measurement functionality has to be within a separate component
* to leverage snapshot lifecycle.
*/
class PopChildMeasure extends external_React_.Component {
getSnapshotBeforeUpdate(prevProps) {
const element = this.props.childRef.current;
if (element && prevProps.isPresent && !this.props.isPresent) {
const size = this.props.sizeRef.current;
size.height = element.offsetHeight || 0;
size.width = element.offsetWidth || 0;
size.top = element.offsetTop;
size.left = element.offsetLeft;
}
return null;
}
/**
* Required with getSnapshotBeforeUpdate to stop React complaining.
*/
componentDidUpdate() { }
render() {
return this.props.children;
}
}
function PopChild({ children, isPresent }) {
const id = (0,external_React_.useId)();
const ref = (0,external_React_.useRef)(null);
const size = (0,external_React_.useRef)({
width: 0,
height: 0,
top: 0,
left: 0,
});
const { nonce } = (0,external_React_.useContext)(MotionConfigContext);
/**
* We create and inject a style block so we can apply this explicit
* sizing in a non-destructive manner by just deleting the style block.
*
* We can't apply size via render as the measurement happens
* in getSnapshotBeforeUpdate (post-render), likewise if we apply the
* styles directly on the DOM node, we might be overwriting
* styles set via the style prop.
*/
(0,external_React_.useInsertionEffect)(() => {
const { width, height, top, left } = size.current;
if (isPresent || !ref.current || !width || !height)
return;
ref.current.dataset.motionPopId = id;
const style = document.createElement("style");
if (nonce)
style.nonce = nonce;
document.head.appendChild(style);
if (style.sheet) {
style.sheet.insertRule(`
[data-motion-pop-id="${id}"] {
position: absolute !important;
width: ${width}px !important;
height: ${height}px !important;
top: ${top}px !important;
left: ${left}px !important;
}
`);
}
return () => {
document.head.removeChild(style);
};
}, [isPresent]);
return ((0,external_ReactJSXRuntime_namespaceObject.jsx)(PopChildMeasure, { isPresent: isPresent, childRef: ref, sizeRef: size, children: external_React_.cloneElement(children, { ref }) }));
}
;// ./node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.mjs
"use client";
const PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, }) => {
const presenceChildren = useConstant(newChildrenMap);
const id = (0,external_React_.useId)();
const memoizedOnExitComplete = (0,external_React_.useCallback)((childId) => {
presenceChildren.set(childId, true);
for (const isComplete of presenceChildren.values()) {
if (!isComplete)
return; // can stop searching when any is incomplete
}
onExitComplete && onExitComplete();
}, [presenceChildren, onExitComplete]);
const context = (0,external_React_.useMemo)(() => ({
id,
initial,
isPresent,
custom,
onExitComplete: memoizedOnExitComplete,
register: (childId) => {
presenceChildren.set(childId, false);
return () => presenceChildren.delete(childId);
},
}),
/**
* If the presence of a child affects the layout of the components around it,
* we want to make a new context value to ensure they get re-rendered
* so they can detect that layout change.
*/
presenceAffectsLayout
? [Math.random(), memoizedOnExitComplete]
: [isPresent, memoizedOnExitComplete]);
(0,external_React_.useMemo)(() => {
presenceChildren.forEach((_, key) => presenceChildren.set(key, false));
}, [isPresent]);
/**
* If there's no `motion` components to fire exit animations, we want to remove this
* component immediately.
*/
external_React_.useEffect(() => {
!isPresent &&
!presenceChildren.size &&
onExitComplete &&
onExitComplete();
}, [isPresent]);
if (mode === "popLayout") {
children = (0,external_ReactJSXRuntime_namespaceObject.jsx)(PopChild, { isPresent: isPresent, children: children });
}
return ((0,external_ReactJSXRuntime_namespaceObject.jsx)(PresenceContext_PresenceContext.Provider, { value: context, children: children }));
};
function newChildrenMap() {
return new Map();
}
;// ./node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs
/**
* When a component is the child of `AnimatePresence`, it can use `usePresence`
* to access information about whether it's still present in the React tree.
*
* ```jsx
* import { usePresence } from "framer-motion"
*
* export const Component = () => {
* const [isPresent, safeToRemove] = usePresence()
*
* useEffect(() => {
* !isPresent && setTimeout(safeToRemove, 1000)
* }, [isPresent])
*
* return <div />
* }
* ```
*
* If `isPresent` is `false`, it means that a component has been removed the tree, but
* `AnimatePresence` won't really remove it until `safeToRemove` has been called.
*
* @public
*/
function usePresence(subscribe = true) {
const context = (0,external_React_.useContext)(PresenceContext_PresenceContext);
if (context === null)
return [true, null];
const { isPresent, onExitComplete, register } = context;
// It's safe to call the following hooks conditionally (after an early return) because the context will always
// either be null or non-null for the lifespan of the component.
const id = (0,external_React_.useId)();
(0,external_React_.useEffect)(() => {
if (subscribe)
register(id);
}, [subscribe]);
const safeToRemove = (0,external_React_.useCallback)(() => subscribe && onExitComplete && onExitComplete(id), [id, onExitComplete, subscribe]);
return !isPresent && onExitComplete ? [false, safeToRemove] : [true];
}
/**
* Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.
* There is no `safeToRemove` function.
*
* ```jsx
* import { useIsPresent } from "framer-motion"
*
* export const Component = () => {
* const isPresent = useIsPresent()
*
* useEffect(() => {
* !isPresent && console.log("I've been removed!")
* }, [isPresent])
*
* return <div />
* }
* ```
*
* @public
*/
function useIsPresent() {
return isPresent(useContext(PresenceContext));
}
function isPresent(context) {
return context === null ? true : context.isPresent;
}
;// ./node_modules/framer-motion/dist/es/components/AnimatePresence/utils.mjs
const getChildKey = (child) => child.key || "";
function onlyElements(children) {
const filtered = [];
// We use forEach here instead of map as map mutates the component key by preprending `.$`
external_React_.Children.forEach(children, (child) => {
if ((0,external_React_.isValidElement)(child))
filtered.push(child);
});
return filtered;
}
;// ./node_modules/framer-motion/dist/es/utils/is-browser.mjs
const is_browser_isBrowser = typeof window !== "undefined";
;// ./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs
const useIsomorphicLayoutEffect = is_browser_isBrowser ? external_React_.useLayoutEffect : external_React_.useEffect;
;// ./node_modules/framer-motion/dist/es/components/AnimatePresence/index.mjs
"use client";
/**
* `AnimatePresence` enables the animation of components that have been removed from the tree.
*
* When adding/removing more than a single child, every child **must** be given a unique `key` prop.
*
* Any `motion` components that have an `exit` property defined will animate out when removed from
* the tree.
*
* ```jsx
* import { motion, AnimatePresence } from 'framer-motion'
*
* export const Items = ({ items }) => (
* <AnimatePresence>
* {items.map(item => (
* <motion.div
* key={item.id}
* initial={{ opacity: 0 }}
* animate={{ opacity: 1 }}
* exit={{ opacity: 0 }}
* />
* ))}
* </AnimatePresence>
* )
* ```
*
* You can sequence exit animations throughout a tree using variants.
*
* If a child contains multiple `motion` components with `exit` props, it will only unmount the child
* once all `motion` components have finished animating out. Likewise, any components using
* `usePresence` all need to call `safeToRemove`.
*
* @public
*/
const AnimatePresence = ({ children, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = "sync", propagate = false, }) => {
const [isParentPresent, safeToRemove] = usePresence(propagate);
/**
* Filter any children that aren't ReactElements. We can only track components
* between renders with a props.key.
*/
const presentChildren = (0,external_React_.useMemo)(() => onlyElements(children), [children]);
/**
* Track the keys of the currently rendered children. This is used to
* determine which children are exiting.
*/
const presentKeys = propagate && !isParentPresent ? [] : presentChildren.map(getChildKey);
/**
* If `initial={false}` we only want to pass this to components in the first render.
*/
const isInitialRender = (0,external_React_.useRef)(true);
/**
* A ref containing the currently present children. When all exit animations
* are complete, we use this to re-render the component with the latest children
* *committed* rather than the latest children *rendered*.
*/
const pendingPresentChildren = (0,external_React_.useRef)(presentChildren);
/**
* Track which exiting children have finished animating out.
*/
const exitComplete = useConstant(() => new Map());
/**
* Save children to render as React state. To ensure this component is concurrent-safe,
* we check for exiting children via an effect.
*/
const [diffedChildren, setDiffedChildren] = (0,external_React_.useState)(presentChildren);
const [renderedChildren, setRenderedChildren] = (0,external_React_.useState)(presentChildren);
useIsomorphicLayoutEffect(() => {
isInitialRender.current = false;
pendingPresentChildren.current = presentChildren;
/**
* Update complete status of exiting children.
*/
for (let i = 0; i < renderedChildren.length; i++) {
const key = getChildKey(renderedChildren[i]);
if (!presentKeys.includes(key)) {
if (exitComplete.get(key) !== true) {
exitComplete.set(key, false);
}
}
else {
exitComplete.delete(key);
}
}
}, [renderedChildren, presentKeys.length, presentKeys.join("-")]);
const exitingChildren = [];
if (presentChildren !== diffedChildren) {
let nextChildren = [...presentChildren];
/**
* Loop through all the currently rendered components and decide which
* are exiting.
*/
for (let i = 0; i < renderedChildren.length; i++) {
const child = renderedChildren[i];
const key = getChildKey(child);
if (!presentKeys.includes(key)) {
nextChildren.splice(i, 0, child);
exitingChildren.push(child);
}
}
/**
* If we're in "wait" mode, and we have exiting children, we want to
* only render these until they've all exited.
*/
if (mode === "wait" && exitingChildren.length) {
nextChildren = exitingChildren;
}
setRenderedChildren(onlyElements(nextChildren));
setDiffedChildren(presentChildren);
/**
* Early return to ensure once we've set state with the latest diffed
* children, we can immediately re-render.
*/
return;
}
if (false) {}
/**
* If we've been provided a forceRender function by the LayoutGroupContext,
* we can use it to force a re-render amongst all surrounding components once
* all components have finished animating out.
*/
const { forceRender } = (0,external_React_.useContext)(LayoutGroupContext);
return ((0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, { children: renderedChildren.map((child) => {
const key = getChildKey(child);
const isPresent = propagate && !isParentPresent
? false
: presentChildren === renderedChildren ||
presentKeys.includes(key);
const onExit = () => {
if (exitComplete.has(key)) {
exitComplete.set(key, true);
}
else {
return;
}
let isEveryExitComplete = true;
exitComplete.forEach((isExitComplete) => {
if (!isExitComplete)
isEveryExitComplete = false;
});
if (isEveryExitComplete) {
forceRender === null || forceRender === void 0 ? void 0 : forceRender();
setRenderedChildren(pendingPresentChildren.current);
propagate && (safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove());
onExitComplete && onExitComplete();
}
};
return ((0,external_ReactJSXRuntime_namespaceObject.jsx)(PresenceChild, { isPresent: isPresent, initial: !isInitialRender.current || initial
? undefined
: false, custom: isPresent ? undefined : custom, presenceAffectsLayout: presenceAffectsLayout, mode: mode, onExitComplete: isPresent ? undefined : onExit, children: child }, key));
}) }));
};
;// ./node_modules/framer-motion/dist/es/render/components/create-proxy.mjs
function createDOMMotionComponentProxy(componentFactory) {
if (typeof Proxy === "undefined") {
return componentFactory;
}
/**
* A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.
* Rather than generating them anew every render.
*/
const componentCache = new Map();
const deprecatedFactoryFunction = (...args) => {
if (false) {}
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 this element doesn't exist in the component cache, create it and cache.
*/
if (!componentCache.has(key)) {
componentCache.set(key, componentFactory(key));
}
return componentCache.get(key);
},
});
}
;// ./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs
function isAnimationControls(v) {
return (v !== null &&
typeof v === "object" &&
typeof v.start === "function");
}
;// ./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs
const isKeyframesTarget = (v) => {
return Array.isArray(v);
};
;// ./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs
function shallowCompare(next, prev) {
if (!Array.isArray(prev))
return false;
const prevLength = prev.length;
if (prevLength !== next.length)
return false;
for (let i = 0; i < prevLength; i++) {
if (prev[i] !== next[i])
return false;
}
return true;
}
;// ./node_modules/framer-motion/dist/es/render/utils/is-variant-label.mjs
/**
* Decides if the supplied variable is variant label
*/
function isVariantLabel(v) {
return typeof v === "string" || Array.isArray(v);
}
;// ./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 the variant definition is a function, resolve.
*/
if (typeof definition === "function") {
const [current, velocity] = getValueState(visualElement);
definition = definition(custom !== undefined ? custom : props.custom, current, velocity);
}
/**
* If the variant definition is a variant label, or
* the function returned a variant label, resolve.
*/
if (typeof definition === "string") {
definition = props.variants && props.variants[definition];
}
/**
* At this point we've resolved both functions and variant labels,
* but the resolved variant label might itself have been a function.
* If so, resolve. This can only have returned a valid target object.
*/
if (typeof definition === "function") {
const [current, velocity] = getValueState(visualElement);
definition = definition(custom !== undefined ? custom : props.custom, current, velocity);
}
return definition;
}
;// ./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 !== undefined ? custom : props.custom, visualElement);
}
;// ./node_modules/framer-motion/dist/es/render/utils/variant-props.mjs
const variantPriorityOrder = [
"animate",
"whileInView",
"whileFocus",
"whileHover",
"whileTap",
"whileDrag",
"exit",
];
const variantProps = ["initial", ...variantPriorityOrder];
;// ./node_modules/motion-utils/dist/es/memo.mjs
/*#__NO_SIDE_EFFECTS__*/
function memo(callback) {
let result;
return () => {
if (result === undefined)
result = callback();
return result;
};
}
;// ./node_modules/motion-dom/dist/es/utils/supports/scroll-timeline.mjs
const supportsScrollTimeline = memo(() => window.ScrollTimeline !== undefined);
;// ./node_modules/motion-dom/dist/es/animation/controls/BaseGroup.mjs
class BaseGroup_BaseGroupPlaybackControls {
constructor(animations) {
// Bound to accomodate common `return animation.stop` pattern
this.stop = () => this.runAll("stop");
this.animations = animations.filter(Boolean);
}
get finished() {
// Support for new finished Promise and legacy thennable API
return Promise.all(this.animations.map((animation) => "finished" in animation ? animation.finished : animation));
}
/**
* TODO: Filter out cancelled or stopped animations before returning
*/
getAll(propName) {
return this.animations[0][propName];
}
setAll(propName, newValue) {
for (let i = 0; i < this.animations.length; i++) {
this.animations[i][propName] = newValue;
}
}
attachTimeline(timeline, fallback) {
const subscriptions = this.animations.map((animation) => {
if (supportsScrollTimeline() && animation.attachTimeline) {
return animation.attachTimeline(timeline);
}
else if (typeof fallback === "function") {
return fallback(animation);
}
});
return () => {
subscriptions.forEach((cancel, i) => {
cancel && cancel();
this.animations[i].stop();
});
};
}
get time() {
return this.getAll("time");
}
set time(time) {
this.setAll("time", time);
}
get speed() {
return this.getAll("speed");
}
set speed(speed) {
this.setAll("speed", speed);
}
get startTime() {
return this.getAll("startTime");
}
get duration() {
let max = 0;
for (let i = 0; i < this.animations.length; i++) {
max = Math.max(max, this.animations[i].duration);
}
return max;
}
runAll(methodName) {
this.animations.forEach((controls) => controls[methodName]());
}
flatten() {
this.runAll("flatten");
}
play() {
this.runAll("play");
}
pause() {
this.runAll("pause");
}
cancel() {
this.runAll("cancel");
}
complete() {
this.runAll("complete");
}
}
;// ./node_modules/motion-dom/dist/es/animation/controls/Group.mjs
/**
* TODO: This is a temporary class to support the legacy
* thennable API
*/
class GroupPlaybackControls extends BaseGroup_BaseGroupPlaybackControls {
then(onResolve, onReject) {
return Promise.all(this.animations).then(onResolve).catch(onReject);
}
}
;// ./node_modules/motion-dom/dist/es/animation/utils/get-value-transition.mjs
function get_value_transition_getValueTransition(transition, key) {
return transition
? transition[key] ||
transition["default"] ||
transition
: undefined;
}
;// ./node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs
/**
* Implement a practical max duration for keyframe generation
* to prevent infinite loops
*/
const maxGeneratorDuration = 20000;
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;
}
;// ./node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs
function isGenerator(type) {
return typeof type === "function";
}
;// ./node_modules/motion-dom/dist/es/animation/waapi/utils/attach-timeline.mjs
function attachTimeline(animation, timeline) {
animation.timeline = timeline;
animation.onfinish = null;
}
;// ./node_modules/motion-dom/dist/es/utils/is-bezier-definition.mjs
const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === "number";
;// ./node_modules/motion-dom/dist/es/utils/supports/flags.mjs
/**
* Add the ability for test suites to manually set support flags
* to better test more environments.
*/
const supportsFlags = {
linearEasing: undefined,
};
;// ./node_modules/motion-dom/dist/es/utils/supports/memo.mjs
function memoSupports(callback, supportsFlag) {
const memoized = memo(callback);
return () => { var _a; return (_a = supportsFlags[supportsFlag]) !== null && _a !== void 0 ? _a : memoized(); };
}
;// ./node_modules/motion-dom/dist/es/utils/supports/linear-easing.mjs
const supportsLinearEasing = /*@__PURE__*/ memoSupports(() => {
try {
document
.createElement("div")
.animate({ opacity: 0 }, { easing: "linear(0, 1)" });
}
catch (e) {
return false;
}
return true;
}, "linearEasing");
;// ./node_modules/motion-utils/dist/es/progress.mjs
/*
Progress within given range
Given a lower limit and an upper limit, we return the progress
(expressed as a number 0-1) represented by the given value, and
limit that progress to within 0-1.
@param [number]: Lower limit
@param [number]: Upper limit
@param [number]: Value to find progress within given range
@return [number]: Progress of value within range as expressed 0-1
*/
/*#__NO_SIDE_EFFECTS__*/
const progress = (from, to, value) => {
const toFromDifference = to - from;
return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;
};
;// ./node_modules/motion-dom/dist/es/animation/waapi/utils/linear.mjs
const generateLinearEasing = (easing, duration, // as milliseconds
resolution = 10 // as milliseconds
) => {
let points = "";
const numPoints = Math.max(Math.round(duration / resolution), 2);
for (let i = 0; i < numPoints; i++) {
points += easing(progress(0, numPoints - 1, i)) + ", ";
}
return `linear(${points.substring(0, points.length - 2)})`;
};
;// ./node_modules/motion-dom/dist/es/animation/waapi/utils/easing.mjs
function isWaapiSupportedEasing(easing) {
return Boolean((typeof easing === "function" && supportsLinearEasing()) ||
!easing ||
(typeof easing === "string" &&
(easing in supportedWaapiEasing || supportsLinearEasing())) ||
isBezierDefinition(easing) ||
(Array.isArray(easing) && easing.every(isWaapiSupportedEasing)));
}
const cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;
const supportedWaapiEasing = {
linear: "linear",
ease: "ease",
easeIn: "ease-in",
easeOut: "ease-out",
easeInOut: "ease-in-out",
circIn: /*@__PURE__*/ cubicBezierAsString([0, 0.65, 0.55, 1]),
circOut: /*@__PURE__*/ cubicBezierAsString([0.55, 0, 1, 0.45]),
backIn: /*@__PURE__*/ cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),
backOut: /*@__PURE__*/ cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),
};
function easing_mapEasingToNativeEasing(easing, duration) {
if (!easing) {
return undefined;
}
else if (typeof easing === "function" && supportsLinearEasing()) {
return generateLinearEasing(easing, duration);
}
else if (isBezierDefinition(easing)) {
return cubicBezierAsString(easing);
}
else if (Array.isArray(easing)) {
return easing.map((segmentEasing) => easing_mapEasingToNativeEasing(segmentEasing, duration) ||
supportedWaapiEasing.easeOut);
}
else {
return supportedWaapiEasing[easing];
}
}
;// ./node_modules/motion-dom/dist/es/gestures/drag/state/is-active.mjs
const isDragging = {
x: false,
y: false,
};
function isDragActive() {
return isDragging.x || isDragging.y;
}
;// ./node_modules/motion-dom/dist/es/utils/resolve-elements.mjs
function resolveElements(elementOrSelector, scope, selectorCache) {
var _a;
if (elementOrSelector instanceof Element) {
return [elementOrSelector];
}
else if (typeof elementOrSelector === "string") {
let root = document;
if (scope) {
// TODO: Refactor to utils package
// invariant(
// Boolean(scope.current),
// "Scope provided, but no element detected."
// )
root = scope.current;
}
const elements = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);
return elements ? Array.from(elements) : [];
}
return Array.from(elementOrSelector);
}
;// ./node_modules/motion-dom/dist/es/gestures/utils/setup.mjs
function setupGesture(elementOrSelector, options) {
const elements = resolveElements(elementOrSelector);
const gestureAbortController = new AbortController();
const eventOptions = {
passive: true,
...options,
signal: gestureAbortController.signal,
};
const cancel = () => gestureAbortController.abort();
return [elements, eventOptions, cancel];
}
;// ./node_modules/motion-dom/dist/es/gestures/hover.mjs
/**
* Filter out events that are not pointer events, or are triggering
* while a Motion gesture is active.
*/
function filterEvents(callback) {
return (event) => {
if (event.pointerType === "touch" || isDragActive())
return;
callback(event);
};
}
/**
* Create a hover gesture. hover() is different to .addEventListener("pointerenter")
* in that it has an easier syntax, filters out polyfilled touch events, interoperates
* with drag gestures, and automatically removes the "pointerennd" event listener when the hover ends.
*
* @public
*/
function hover(elementOrSelector, onHoverStart, options = {}) {
const [elements, eventOptions, cancel] = setupGesture(elementOrSelector, options);
const onPointerEnter = filterEvents((enterEvent) => {
const { target } = enterEvent;
const onHoverEnd = onHoverStart(enterEvent);
if (typeof onHoverEnd !== "function" || !target)
return;
const onPointerLeave = filterEvents((leaveEvent) => {
onHoverEnd(leaveEvent);
target.removeEventListener("pointerleave", onPointerLeave);
});
target.addEventListener("pointerleave", onPointerLeave, eventOptions);
});
elements.forEach((element) => {
element.addEventListener("pointerenter", onPointerEnter, eventOptions);
});
return cancel;
}
;// ./node_modules/motion-dom/dist/es/gestures/utils/is-node-or-child.mjs
/**
* Recursively traverse up the tree to check whether the provided child node
* is the parent or a descendant of it.
*
* @param parent - Element to find
* @param child - Element to test against parent
*/
const isNodeOrChild = (parent, child) => {
if (!child) {
return false;
}
else if (parent === child) {
return true;
}
else {
return isNodeOrChild(parent, child.parentElement);
}
};
;// ./node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs
const isPrimaryPointer = (event) => {
if (event.pointerType === "mouse") {
return typeof event.button !== "number" || event.button <= 0;
}
else {
/**
* isPrimary is true for all mice buttons, whereas every touch point
* is regarded as its own input. So subsequent concurrent touch points
* will be false.
*
* Specifically match against false here as incomplete versions of
* PointerEvents in very old browser might have it set as undefined.
*/
return event.isPrimary !== false;
}
};
;// ./node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.mjs
const focusableElements = new Set([
"BUTTON",
"INPUT",
"SELECT",
"TEXTAREA",
"A",
]);
function isElementKeyboardAccessible(element) {
return (focusableElements.has(element.tagName) ||
element.tabIndex !== -1);
}
;// ./node_modules/motion-dom/dist/es/gestures/press/utils/state.mjs
const isPressing = new WeakSet();
;// ./node_modules/motion-dom/dist/es/gestures/press/utils/keyboard.mjs
/**
* Filter out events that are not "Enter" keys.
*/
function keyboard_filterEvents(callback) {
return (event) => {
if (event.key !== "Enter")
return;
callback(event);
};
}
function firePointerEvent(target, type) {
target.dispatchEvent(new PointerEvent("pointer" + type, { isPrimary: true, bubbles: true }));
}
const enableKeyboardPress = (focusEvent, eventOptions) => {
const element = focusEvent.currentTarget;
if (!element)
return;
const handleKeydown = keyboard_filterEvents(() => {
if (isPressing.has(element))
return;
firePointerEvent(element, "down");
const handleKeyup = keyboard_filterEvents(() => {
firePointerEvent(element, "up");
});
const handleBlur = () => firePointerEvent(element, "cancel");
element.addEventListener("keyup", handleKeyup, eventOptions);
element.addEventListener("blur", handleBlur, eventOptions);
});
element.addEventListener("keydown", handleKeydown, eventOptions);
/**
* Add an event listener that fires on blur to remove the keydown events.
*/
element.addEventListener("blur", () => element.removeEventListener("keydown", handleKeydown), eventOptions);
};
;// ./node_modules/motion-dom/dist/es/gestures/press/index.mjs
/**
* Filter out events that are not primary pointer events, or are triggering
* while a Motion gesture is active.
*/
function isValidPressEvent(event) {
return isPrimaryPointer(event) && !isDragActive();
}
/**
* Create a press gesture.
*
* Press is different to `"pointerdown"`, `"pointerup"` in that it
* automatically filters out secondary pointer events like right
* click and multitouch.
*
* It also adds accessibility support for keyboards, where
* an element with a press gesture will receive focus and
* trigger on Enter `"keydown"` and `"keyup"` events.
*
* This is different to a browser's `"click"` event, which does
* respond to keyboards but only for the `"click"` itself, rather
* than the press start and end/cancel. The element also needs
* to be focusable for this to work, whereas a press gesture will
* make an element focusable by default.
*
* @public
*/
function press(elementOrSelector, onPressStart, options = {}) {
const [elements, eventOptions, cancelEvents] = setupGesture(elementOrSelector, options);
const startPress = (startEvent) => {
const element = startEvent.currentTarget;
if (!isValidPressEvent(startEvent) || isPressing.has(element))
return;
isPressing.add(element);
const onPressEnd = onPressStart(startEvent);
const onPointerEnd = (endEvent, success) => {
window.removeEventListener("pointerup", onPointerUp);
window.removeEventListener("pointercancel", onPointerCancel);
if (!isValidPressEvent(endEvent) || !isPressing.has(element)) {
return;
}
isPressing.delete(element);
if (typeof onPressEnd === "function") {
onPressEnd(endEvent, { success });
}
};
const onPointerUp = (upEvent) => {
onPointerEnd(upEvent, options.useGlobalTarget ||
isNodeOrChild(element, upEvent.target));
};
const onPointerCancel = (cancelEvent) => {
onPointerEnd(cancelEvent, false);
};
window.addEventListener("pointerup", onPointerUp, eventOptions);
window.addEventListener("pointercancel", onPointerCancel, eventOptions);
};
elements.forEach((element) => {
if (!isElementKeyboardAccessible(element) &&
element.getAttribute("tabindex") === null) {
element.tabIndex = 0;
}
const target = options.useGlobalTarget ? window : element;
target.addEventListener("pointerdown", startPress, eventOptions);
element.addEventListener("focus", (event) => enableKeyboardPress(event, eventOptions), eventOptions);
});
return cancelEvents;
}
;// ./node_modules/motion-utils/dist/es/time-conversion.mjs
/**
* Converts seconds to milliseconds
*
* @param seconds - Time in seconds.
* @return milliseconds - Converted time in milliseconds.
*/
/*#__NO_SIDE_EFFECTS__*/
const time_conversion_secondsToMilliseconds = (seconds) => seconds * 1000;
/*#__NO_SIDE_EFFECTS__*/
const millisecondsToSeconds = (milliseconds) => milliseconds / 1000;
;// ./node_modules/motion-utils/dist/es/noop.mjs
/*#__NO_SIDE_EFFECTS__*/
const noop_noop = (any) => any;
;// ./node_modules/motion-dom/dist/es/animation/waapi/NativeAnimationControls.mjs
class NativeAnimationControls_NativeAnimationControls {
constructor(animation) {
this.animation = animation;
}
get duration() {
var _a, _b, _c;
const durationInMs = ((_b = (_a = this.animation) === null || _a === void 0 ? void 0 : _a.effect) === null || _b === void 0 ? void 0 : _b.getComputedTiming().duration) ||
((_c = this.options) === null || _c === void 0 ? void 0 : _c.duration) ||
300;
return millisecondsToSeconds(Number(durationInMs));
}
get time() {
var _a;
if (this.animation) {
return millisecondsToSeconds(((_a = this.animation) === null || _a === void 0 ? void 0 : _a.currentTime) || 0);
}
return 0;
}
set time(newTime) {
if (this.animation) {
this.animation.currentTime = time_conversion_secondsToMilliseconds(newTime);
}
}
get speed() {
return this.animation ? this.animation.playbackRate : 1;
}
set speed(newSpeed) {
if (this.animation) {
this.animation.playbackRate = newSpeed;
}
}
get state() {
return this.animation ? this.animation.playState : "finished";
}
get startTime() {
return this.animation ? this.animation.startTime : null;
}
get finished() {
return this.animation ? this.animation.finished : Promise.resolve();
}
play() {
this.animation && this.animation.play();
}
pause() {
this.animation && this.animation.pause();
}
stop() {
if (!this.animation ||
this.state === "idle" ||
this.state === "finished") {
return;
}
if (this.animation.commitStyles) {
this.animation.commitStyles();
}
this.cancel();
}
flatten() {
var _a;
if (!this.animation)
return;
(_a = this.animation.effect) === null || _a === void 0 ? void 0 : _a.updateTiming({ easing: "linear" });
}
attachTimeline(timeline) {
if (this.animation)
attachTimeline(this.animation, timeline);
return noop_noop;
}
complete() {
this.animation && this.animation.finish();
}
cancel() {
try {
this.animation && this.animation.cancel();
}
catch (e) { }
}
}
;// ./node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs
/**
* Create a progress => progress easing function from a generator.
*/
function createGeneratorEasing(options, scale = 100, createGenerator) {
const generator = createGenerator({ ...options, keyframes: [0, scale] });
const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
return {
type: "keyframes",
ease: (progress) => {
return generator.next(duration * progress).value / scale;
},
duration: millisecondsToSeconds(duration),
};
}
;// ./node_modules/motion-dom/dist/es/animation/waapi/utils/convert-options.mjs
const defaultEasing = "easeOut";
function convert_options_applyGeneratorOptions(options) {
var _a;
if (isGenerator(options.type)) {
const generatorOptions = createGeneratorEasing(options, 100, options.type);
options.ease = supportsLinearEasing()
? generatorOptions.ease
: defaultEasing;
options.duration = time_conversion_secondsToMilliseconds(generatorOptions.duration);
options.type = "keyframes";
}
else {
options.duration = time_conversion_secondsToMilliseconds((_a = options.duration) !== null && _a !== void 0 ? _a : 0.3);
options.ease = options.ease || defaultEasing;
}
}
// TODO: Reuse for NativeAnimation
function convertMotionOptionsToNative(valueName, keyframes, options) {
var _a;
const nativeKeyframes = {};
const nativeOptions = {
fill: "both",
easing: "linear",
composite: "replace",
};
nativeOptions.delay = time_conversion_secondsToMilliseconds((_a = options.delay) !== null && _a !== void 0 ? _a : 0);
convert_options_applyGeneratorOptions(options);
nativeOptions.duration = options.duration;
const { ease, times } = options;
if (times)
nativeKeyframes.offset = times;
nativeKeyframes[valueName] = keyframes;
const easing = easing_mapEasingToNativeEasing(ease, options.duration);
/**
* If this is an easing array, apply to keyframes, not animation as a whole
*/
if (Array.isArray(easing)) {
nativeKeyframes.easing = easing;
}
else {
nativeOptions.easing = easing;
}
return {
keyframes: nativeKeyframes,
options: nativeOptions,
};
}
;// ./node_modules/motion-dom/dist/es/animation/waapi/PseudoAnimation.mjs
class PseudoAnimation_PseudoAnimation extends NativeAnimationControls_NativeAnimationControls {
constructor(target, pseudoElement, valueName, keyframes, options) {
const animationOptions = convertMotionOptionsToNative(valueName, keyframes, options);
const animation = target.animate(animationOptions.keyframes, {
pseudoElement,
...animationOptions.options,
});
super(animation);
}
}
;// ./node_modules/motion-dom/dist/es/view/utils/css.mjs
let pendingRules = {};
let style = null;
const css_css = {
set: (selector, values) => {
pendingRules[selector] = values;
},
commit: () => {
if (!style) {
style = document.createElement("style");
style.id = "motion-view";
}
let cssText = "";
for (const selector in pendingRules) {
const rule = pendingRules[selector];
cssText += `${selector} {\n`;
for (const [property, value] of Object.entries(rule)) {
cssText += ` ${property}: ${value};\n`;
}
cssText += "}\n";
}
style.textContent = cssText;
document.head.appendChild(style);
pendingRules = {};
},
remove: () => {
if (style && style.parentElement) {
style.parentElement.removeChild(style);
}
},
};
;// ./node_modules/motion-dom/dist/es/view/start.mjs
const definitionNames = (/* unused pure expression or super */ null && (["layout", "enter", "exit", "new", "old"]));
function start_startViewAnimation(update, defaultOptions, targets) {
if (!document.startViewTransition) {
return new Promise(async (resolve) => {
await update();
resolve(new BaseGroupPlaybackControls([]));
});
}
// TODO: Go over existing targets and ensure they all have ids
/**
* If we don't have any animations defined for the root target,
* remove it from being captured.
*/
if (!hasTarget("root", targets)) {
css.set(":root", {
"view-transition-name": "none",
});
}
/**
* Set the timing curve to linear for all view transition layers.
* This gets baked into the keyframes, which can't be changed
* without breaking the generated animation.
*
* This allows us to set easing via updateTiming - which can be changed.
*/
css.set("::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*)", { "animation-timing-function": "linear !important" });
css.commit(); // Write
const transition = document.startViewTransition(async () => {
await update();
// TODO: Go over new targets and ensure they all have ids
});
transition.finished.finally(() => {
css.remove(); // Write
});
return new Promise((resolve) => {
transition.ready.then(() => {
var _a;
const generatedViewAnimations = getViewAnimations();
const animations = [];
/**
* Create animations for our definitions
*/
targets.forEach((definition, target) => {
// TODO: If target is not "root", resolve elements
// and iterate over each
for (const key of definitionNames) {
if (!definition[key])
continue;
const { keyframes, options } = definition[key];
for (let [valueName, valueKeyframes] of Object.entries(keyframes)) {
if (!valueKeyframes)
continue;
const valueOptions = {
...getValueTransition(defaultOptions, valueName),
...getValueTransition(options, valueName),
};
const type = chooseLayerType(key);
/**
* If this is an opacity animation, and keyframes are not an array,
* we need to convert them into an array and set an initial value.
*/
if (valueName === "opacity" &&
!Array.isArray(valueKeyframes)) {
const initialValue = type === "new" ? 0 : 1;
valueKeyframes = [initialValue, valueKeyframes];
}
/**
* Resolve stagger function if provided.
*/
if (typeof valueOptions.delay === "function") {
valueOptions.delay = valueOptions.delay(0, 1);
}
const animation = new PseudoAnimation(document.documentElement, `::view-transition-${type}(${target})`, valueName, valueKeyframes, valueOptions);
animations.push(animation);
}
}
});
/**
* Handle browser generated animations
*/
for (const animation of generatedViewAnimations) {
if (animation.playState === "finished")
continue;
const { effect } = animation;
if (!effect || !(effect instanceof KeyframeEffect))
continue;
const { pseudoElement } = effect;
if (!pseudoElement)
continue;
const name = getLayerName(pseudoElement);
if (!name)
continue;
const targetDefinition = targets.get(name.layer);
if (!targetDefinition) {
/**
* If transition name is group then update the timing of the animation
* whereas if it's old or new then we could possibly replace it using
* the above method.
*/
const transitionName = name.type === "group" ? "layout" : "";
const animationTransition = {
...getValueTransition(defaultOptions, transitionName),
};
applyGeneratorOptions(animationTransition);
const easing = mapEasingToNativeEasing(animationTransition.ease, animationTransition.duration);
effect.updateTiming({
delay: secondsToMilliseconds((_a = animationTransition.delay) !== null && _a !== void 0 ? _a : 0),
duration: animationTransition.duration,
easing,
});
animations.push(new NativeAnimationControls(animation));
}
else if (hasOpacity(targetDefinition, "enter") &&
hasOpacity(targetDefinition, "exit") &&
effect
.getKeyframes()
.some((keyframe) => keyframe.mixBlendMode)) {
animations.push(new NativeAnimationControls(animation));
}
else {
animation.cancel();
}
}
resolve(new BaseGroupPlaybackControls(animations));
});
});
}
function hasOpacity(target, key) {
var _a;
return (_a = target === null || target === void 0 ? void 0 : target[key]) === null || _a === void 0 ? void 0 : _a.keyframes.opacity;
}
;// ./node_modules/motion-dom/dist/es/view/index.mjs
/**
* TODO:
* - Create view transition on next tick
* - Replace animations with Motion animations
* - Return GroupAnimation on next tick
*/
class ViewTransitionBuilder {
constructor(update, options = {}) {
this.currentTarget = "root";
this.targets = new Map();
this.notifyReady = noop;
this.readyPromise = new Promise((resolve) => {
this.notifyReady = resolve;
});
queueMicrotask(() => {
startViewAnimation(update, options, this.targets).then((animation) => this.notifyReady(animation));
});
}
get(selector) {
this.currentTarget = selector;
return this;
}
layout(keyframes, options) {
this.updateTarget("layout", keyframes, options);
return this;
}
new(keyframes, options) {
this.updateTarget("new", keyframes, options);
return this;
}
old(keyframes, options) {
this.updateTarget("old", keyframes, options);
return this;
}
enter(keyframes, options) {
this.updateTarget("enter", keyframes, options);
return this;
}
exit(keyframes, options) {
this.updateTarget("exit", keyframes, options);
return this;
}
crossfade(options) {
this.updateTarget("enter", { opacity: 1 }, options);
this.updateTarget("exit", { opacity: 0 }, options);
return this;
}
updateTarget(target, keyframes, options = {}) {
const { currentTarget, targets } = this;
if (!targets.has(currentTarget)) {
targets.set(currentTarget, {});
}
const targetData = targets.get(currentTarget);
targetData[target] = { keyframes, options };
}
then(resolve, reject) {
return this.readyPromise.then(resolve, reject);
}
}
function view(update, defaultOptions = {}) {
return new ViewTransitionBuilder(update, defaultOptions);
}
;// ./node_modules/motion-dom/dist/es/gestures/drag/state/set-active.mjs
function setDragLock(axis) {
if (axis === "x" || axis === "y") {
if (isDragging[axis]) {
return null;
}
else {
isDragging[axis] = true;
return () => {
isDragging[axis] = false;
};
}
}
else {
if (isDragging.x || isDragging.y) {
return null;
}
else {
isDragging.x = isDragging.y = true;
return () => {
isDragging.x = isDragging.y = false;
};
}
}
}
;// ./node_modules/motion-dom/dist/es/index.mjs
;// ./node_modules/framer-motion/dist/es/render/html/utils/keys-transform.mjs
/**
* Generate a list of every possible transform key.
*/
const transformPropOrder = [
"transformPerspective",
"x",
"y",
"z",
"translateX",
"translateY",
"translateZ",
"scale",
"scaleX",
"scaleY",
"rotate",
"rotateX",
"rotateY",
"rotateZ",
"skew",
"skewX",
"skewY",
];
/**
* A quick lookup for transform props.
*/
const transformProps = new Set(transformPropOrder);
;// ./node_modules/framer-motion/dist/es/render/html/utils/keys-position.mjs
const positionalKeys = new Set([
"width",
"height",
"top",
"left",
"right",
"bottom",
...transformPropOrder,
]);
;// ./node_modules/framer-motion/dist/es/utils/resolve-value.mjs
const isCustomValue = (v) => {
return Boolean(v && typeof v === "object" && v.mix && v.toValue);
};
const resolveFinalValueInKeyframes = (v) => {
// TODO maybe throw if v.length - 1 is placeholder token?
return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
};
;// ./node_modules/framer-motion/dist/es/utils/GlobalConfig.mjs
const MotionGlobalConfig = {
skipAnimations: false,
useManualTiming: false,
};
;// ./node_modules/framer-motion/dist/es/frameloop/render-step.mjs
function createRenderStep(runNextFrame) {
/**
* We create and reuse two queues, one to queue jobs for the current frame
* and one for the next. We reuse to avoid triggering GC after x frames.
*/
let thisFrame = new Set();
let nextFrame = new Set();
/**
* Track whether we're currently processing jobs in this step. This way
* we can decide whether to schedule new jobs for this frame or next.
*/
let isProcessing = false;
let flushNextFrame = false;
/**
* A set of processes which were marked keepAlive when scheduled.
*/
const toKeepAlive = new WeakSet();
let latestFrameData = {
delta: 0.0,
timestamp: 0.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: (frameData) => {
latestFrameData = frameData;
/**
* If we're already processing we've probably been triggered by a flushSync
* inside an existing process. Instead of executing, mark flushNextFrame
* as true and ensure we flush the following frame at the end of this one.
*/
if (isProcessing) {
flushNextFrame = true;
return;
}
isProcessing = true;
[thisFrame, nextFrame] = [nextFrame, thisFrame];
// Execute this frame
thisFrame.forEach(triggerCallback);
// Clear the frame so no callbacks remain. This is to avoid
// memory leaks should this render step not run for a while.
thisFrame.clear();
isProcessing = false;
if (flushNextFrame) {
flushNextFrame = false;
step.process(frameData);
}
},
};
return step;
}
;// ./node_modules/framer-motion/dist/es/frameloop/batcher.mjs
const stepsOrder = [
"read", // Read
"resolveKeyframes", // Write/Read/Write/Read
"update", // Compute
"preRender", // Compute
"render", // Write
"postRender", // Compute
];
const maxElapsed = 40;
function createRenderBatcher(scheduleNextBatch, allowKeepAlive) {
let runNextFrame = false;
let useDefaultElapsed = true;
const state = {
delta: 0.0,
timestamp: 0.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
? 1000 / 60
: Math.max(Math.min(timestamp - state.timestamp, maxElapsed), 1);
state.timestamp = timestamp;
state.isProcessing = true;
// Unrolled render loop for better per-frame performance
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] = (process, keepAlive = false, immediate = false) => {
if (!runNextFrame)
wake();
return step.schedule(process, keepAlive, immediate);
};
return acc;
}, {});
const cancel = (process) => {
for (let i = 0; i < stepsOrder.length; i++) {
steps[stepsOrder[i]].cancel(process);
}
};
return { schedule, cancel, state, steps };
}
;// ./node_modules/framer-motion/dist/es/frameloop/frame.mjs
const { schedule: frame_frame, cancel: cancelFrame, state: frameData, steps: frameSteps, } = createRenderBatcher(typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : noop_noop, true);
;// ./node_modules/framer-motion/dist/es/frameloop/sync-time.mjs
let now;
function clearTime() {
now = undefined;
}
/**
* An eventloop-synchronous alternative to performance.now().
*
* Ensures that time measurements remain consistent within a synchronous context.
* Usually calling performance.now() twice within the same synchronous context
* will return different values which isn't useful for animations when we're usually
* trying to sync animations to the same frame.
*/
const time = {
now: () => {
if (now === undefined) {
time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming
? frameData.timestamp
: performance.now());
}
return now;
},
set: (newTime) => {
now = newTime;
queueMicrotask(clearTime);
},
};
;// ./node_modules/framer-motion/dist/es/utils/array.mjs
function addUniqueItem(arr, item) {
if (arr.indexOf(item) === -1)
arr.push(item);
}
function removeItem(arr, item) {
const index = arr.indexOf(item);
if (index > -1)
arr.splice(index, 1);
}
// Adapted from array-move
function moveItem([...arr], fromIndex, toIndex) {
const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;
if (startIndex >= 0 && startIndex < arr.length) {
const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;
const [item] = arr.splice(fromIndex, 1);
arr.splice(endIndex, 0, item);
}
return arr;
}
;// ./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs
class SubscriptionManager {
constructor() {
this.subscriptions = [];
}
add(handler) {
addUniqueItem(this.subscriptions, handler);
return () => removeItem(this.subscriptions, handler);
}
notify(a, b, c) {
const numSubscriptions = this.subscriptions.length;
if (!numSubscriptions)
return;
if (numSubscriptions === 1) {
/**
* If there's only a single handler we can just call it without invoking a loop.
*/
this.subscriptions[0](a, b, c);
}
else {
for (let i = 0; i < numSubscriptions; i++) {
/**
* Check whether the handler exists before firing as it's possible
* the subscriptions were modified during this loop running.
*/
const handler = this.subscriptions[i];
handler && handler(a, b, c);
}
}
}
getSize() {
return this.subscriptions.length;
}
clear() {
this.subscriptions.length = 0;
}
}
;// ./node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs
/*
Convert velocity into velocity per second
@param [number]: Unit per frame
@param [number]: Frame duration in ms
*/
function velocityPerSecond(velocity, frameDuration) {
return frameDuration ? velocity * (1000 / frameDuration) : 0;
}
;// ./node_modules/framer-motion/dist/es/value/index.mjs
/**
* Maximum time between the value of two frames, beyond which we
* assume the velocity has since been 0.
*/
const MAX_VELOCITY_DELTA = 30;
const isFloat = (value) => {
return !isNaN(parseFloat(value));
};
const collectMotionValues = {
current: undefined,
};
/**
* `MotionValue` is used to track the state and velocity of motion values.
*
* @public
*/
class MotionValue {
/**
* @param init - The initiating value
* @param config - Optional configuration options
*
* - `transformer`: A function to transform incoming values with.
*
* @internal
*/
constructor(init, options = {}) {
/**
* This will be replaced by the build step with the latest version number.
* When MotionValues are provided to motion components, warn if versions are mixed.
*/
this.version = "11.18.2";
/**
* Tracks whether this value can output a velocity. Currently this is only true
* if the value is numerical, but we might be able to widen the scope here and support
* other value types.
*
* @internal
*/
this.canTrackVelocity = null;
/**
* An object containing a SubscriptionManager for each active event.
*/
this.events = {};
this.updateAndNotify = (v, render = true) => {
const currentTime = time.now();
/**
* If we're updating the value during another frame or eventloop
* than the previous frame, then the we set the previous frame value
* to current.
*/
if (this.updatedAt !== currentTime) {
this.setPrevFrameValue();
}
this.prev = this.current;
this.setCurrent(v);
// Update update subscribers
if (this.current !== this.prev && this.events.change) {
this.events.change.notify(this.current);
}
// Update render subscribers
if (render && this.events.renderRequest) {
this.events.renderRequest.notify(this.current);
}
};
this.hasAnimated = false;
this.setCurrent(init);
this.owner = options.owner;
}
setCurrent(current) {
this.current = current;
this.updatedAt = time.now();
if (this.canTrackVelocity === null && current !== undefined) {
this.canTrackVelocity = isFloat(this.current);
}
}
setPrevFrameValue(prevFrameValue = this.current) {
this.prevFrameValue = prevFrameValue;
this.prevUpdatedAt = this.updatedAt;
}
/**
* Adds a function that will be notified when the `MotionValue` is updated.
*
* It returns a function that, when called, will cancel the subscription.
*
* When calling `onChange` inside a React component, it should be wrapped with the
* `useEffect` hook. As it returns an unsubscribe function, this should be returned
* from the `useEffect` function to ensure you don't add duplicate subscribers..
*
* ```jsx
* export const MyComponent = () => {
* const x = useMotionValue(0)
* const y = useMotionValue(0)
* const opacity = useMotionValue(1)
*
* useEffect(() => {
* function updateOpacity() {
* const maxXY = Math.max(x.get(), y.get())
* const newOpacity = transform(maxXY, [0, 100], [1, 0])
* opacity.set(newOpacity)
* }
*
* const unsubscribeX = x.on("change", updateOpacity)
* const unsubscribeY = y.on("change", updateOpacity)
*
* return () => {
* unsubscribeX()
* unsubscribeY()
* }
* }, [])
*
* return <motion.div style={{ x }} />
* }
* ```
*
* @param subscriber - A function that receives the latest value.
* @returns A function that, when called, will cancel this subscription.
*
* @deprecated
*/
onChange(subscription) {
if (false) {}
return this.on("change", subscription);
}
on(eventName, callback) {
if (!this.events[eventName]) {
this.events[eventName] = new SubscriptionManager();
}
const unsubscribe = this.events[eventName].add(callback);
if (eventName === "change") {
return () => {
unsubscribe();
/**
* If we have no more change listeners by the start
* of the next frame, stop active animations.
*/
frame_frame.read(() => {
if (!this.events.change.getSize()) {
this.stop();
}
});
};
}
return unsubscribe;
}
clearListeners() {
for (const eventManagers in this.events) {
this.events[eventManagers].clear();
}
}
/**
* Attaches a passive effect to the `MotionValue`.
*
* @internal
*/
attach(passiveEffect, stopPassiveEffect) {
this.passiveEffect = passiveEffect;
this.stopPassiveEffect = stopPassiveEffect;
}
/**
* Sets the state of the `MotionValue`.
*
* @remarks
*
* ```jsx
* const x = useMotionValue(0)
* x.set(10)
* ```
*
* @param latest - Latest value to set.
* @param render - Whether to notify render subscribers. Defaults to `true`
*
* @public
*/
set(v, render = true) {
if (!render || !this.passiveEffect) {
this.updateAndNotify(v, render);
}
else {
this.passiveEffect(v, this.updateAndNotify);
}
}
setWithVelocity(prev, current, delta) {
this.set(current);
this.prev = undefined;
this.prevFrameValue = prev;
this.prevUpdatedAt = this.updatedAt - delta;
}
/**
* Set the state of the `MotionValue`, stopping any active animations,
* effects, and resets velocity to `0`.
*/
jump(v, endAnimation = true) {
this.updateAndNotify(v);
this.prev = v;
this.prevUpdatedAt = this.prevFrameValue = undefined;
endAnimation && this.stop();
if (this.stopPassiveEffect)
this.stopPassiveEffect();
}
/**
* Returns the latest state of `MotionValue`
*
* @returns - The latest state of `MotionValue`
*
* @public
*/
get() {
if (collectMotionValues.current) {
collectMotionValues.current.push(this);
}
return this.current;
}
/**
* @public
*/
getPrevious() {
return this.prev;
}
/**
* Returns the latest velocity of `MotionValue`
*
* @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
*
* @public
*/
getVelocity() {
const currentTime = time.now();
if (!this.canTrackVelocity ||
this.prevFrameValue === undefined ||
currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {
return 0;
}
const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);
// Casts because of parseFloat's poor typing
return velocityPerSecond(parseFloat(this.current) -
parseFloat(this.prevFrameValue), delta);
}
/**
* Registers a new animation to control this `MotionValue`. Only one
* animation can drive a `MotionValue` at one time.
*
* ```jsx
* value.start()
* ```
*
* @param animation - A function that starts the provided animation
*
* @internal
*/
start(startAnimation) {
this.stop();
return new Promise((resolve) => {
this.hasAnimated = true;
this.animation = startAnimation(resolve);
if (this.events.animationStart) {
this.events.animationStart.notify();
}
}).then(() => {
if (this.events.animationComplete) {
this.events.animationComplete.notify();
}
this.clearAnimation();
});
}
/**
* Stop the currently active animation.
*
* @public
*/
stop() {
if (this.animation) {
this.animation.stop();
if (this.events.animationCancel) {
this.events.animationCancel.notify();
}
}
this.clearAnimation();
}
/**
* Returns `true` if this value is currently animating.
*
* @public
*/
isAnimating() {
return !!this.animation;
}
clearAnimation() {
delete this.animation;
}
/**
* Destroy and clean up subscribers to this `MotionValue`.
*
* The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
* handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
* created a `MotionValue` via the `motionValue` function.
*
* @public
*/
destroy() {
this.clearListeners();
this.stop();
if (this.stopPassiveEffect) {
this.stopPassiveEffect();
}
}
}
function motionValue(init, options) {
return new MotionValue(init, options);
}
;// ./node_modules/framer-motion/dist/es/render/utils/setters.mjs
/**
* Set VisualElement's MotionValue, creating a new MotionValue for it if
* it doesn't exist.
*/
function setMotionValue(visualElement, key, value) {
if (visualElement.hasValue(key)) {
visualElement.getValue(key).set(value);
}
else {
visualElement.addValue(key, motionValue(value));
}
}
function setTarget(visualElement, definition) {
const resolved = resolveVariant(visualElement, definition);
let { transitionEnd = {}, transition = {}, ...target } = resolved || {};
target = { ...target, ...transitionEnd };
for (const key in target) {
const value = resolveFinalValueInKeyframes(target[key]);
setMotionValue(visualElement, key, value);
}
}
;// ./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs
const isMotionValue = (value) => Boolean(value && value.getVelocity);
;// ./node_modules/framer-motion/dist/es/value/use-will-change/is.mjs
function isWillChangeMotionValue(value) {
return Boolean(isMotionValue(value) && value.add);
}
;// ./node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.mjs
function addValueToWillChange(visualElement, key) {
const willChange = visualElement.getValue("willChange");
/**
* It could be that a user has set willChange to a regular MotionValue,
* in which case we can't add the value to it.
*/
if (isWillChangeMotionValue(willChange)) {
return willChange.add(key);
}
}
;// ./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs
/**
* Convert camelCase to dash-case properties.
*/
const camelToDash = (str) => str.replace(/([a-z])([A-Z])/gu, "$1-$2").toLowerCase();
;// ./node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs
const optimizedAppearDataId = "framerAppearId";
const optimizedAppearDataAttribute = "data-" + camelToDash(optimizedAppearDataId);
;// ./node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs
function getOptimisedAppearId(visualElement) {
return visualElement.props[optimizedAppearDataAttribute];
}
;// ./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs
const instantAnimationState = {
current: false,
};
;// ./node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs
/*
Bezier function generator
This has been modified from Gaëtan Renaudeau's BezierEasing
https://github.com/gre/bezier-easing/blob/master/src/index.js
https://github.com/gre/bezier-easing/blob/master/LICENSE
I've removed the newtonRaphsonIterate algo because in benchmarking it
wasn't noticiably faster than binarySubdivision, indeed removing it
usually improved times, depending on the curve.
I also removed the lookup table, as for the added bundle size and loop we're
only cutting ~4 or so subdivision iterations. I bumped the max iterations up
to 12 to compensate and this still tended to be faster for no perceivable
loss in accuracy.
Usage
const easeOut = cubicBezier(.17,.67,.83,.67);
const x = easeOut(0.5); // returns 0.627...
*/
// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
const calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *
t;
const subdivisionPrecision = 0.0000001;
const subdivisionMaxIterations = 12;
function binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {
let currentX;
let currentT;
let i = 0;
do {
currentT = lowerBound + (upperBound - lowerBound) / 2.0;
currentX = calcBezier(currentT, mX1, mX2) - x;
if (currentX > 0.0) {
upperBound = currentT;
}
else {
lowerBound = currentT;
}
} while (Math.abs(currentX) > subdivisionPrecision &&
++i < subdivisionMaxIterations);
return currentT;
}
function cubicBezier(mX1, mY1, mX2, mY2) {
// If this is a linear gradient, return linear easing
if (mX1 === mY1 && mX2 === mY2)
return noop_noop;
const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);
// If animation is at start/end, return t without easing
return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);
}
;// ./node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs
// Accepts an easing function and returns a new one that outputs mirrored values for
// the second half of the animation. Turns easeIn into easeInOut.
const mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;
;// ./node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs
// Accepts an easing function and returns a new one that outputs reversed values.
// Turns easeIn into easeOut.
const reverseEasing = (easing) => (p) => 1 - easing(1 - p);
;// ./node_modules/framer-motion/dist/es/easing/back.mjs
const backOut = /*@__PURE__*/ cubicBezier(0.33, 1.53, 0.69, 0.99);
const backIn = /*@__PURE__*/ reverseEasing(backOut);
const backInOut = /*@__PURE__*/ mirrorEasing(backIn);
;// ./node_modules/framer-motion/dist/es/easing/anticipate.mjs
const anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));
;// ./node_modules/framer-motion/dist/es/easing/circ.mjs
const circIn = (p) => 1 - Math.sin(Math.acos(p));
const circOut = reverseEasing(circIn);
const circInOut = mirrorEasing(circIn);
;// ./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs
/**
* Check if the value is a zero value string like "0px" or "0%"
*/
const isZeroValueString = (v) => /^0[^.\s]+$/u.test(v);
;// ./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;
}
}
;// ./node_modules/framer-motion/dist/es/utils/clamp.mjs
const clamp_clamp = (min, max, v) => {
if (v > max)
return max;
if (v < min)
return min;
return v;
};
;// ./node_modules/framer-motion/dist/es/value/types/numbers/index.mjs
const number = {
test: (v) => typeof v === "number",
parse: parseFloat,
transform: (v) => v,
};
const alpha = {
...number,
transform: (v) => clamp_clamp(0, 1, v),
};
const scale = {
...number,
default: 1,
};
;// ./node_modules/framer-motion/dist/es/value/types/utils/sanitize.mjs
// If this number is a decimal, make it just five decimal places
// to avoid exponents
const sanitize = (v) => Math.round(v * 100000) / 100000;
;// ./node_modules/framer-motion/dist/es/value/types/utils/float-regex.mjs
const floatRegex = /-?(?:\d+(?:\.\d+)?|\.\d+)/gu;
;// ./node_modules/framer-motion/dist/es/value/types/utils/is-nullish.mjs
function isNullish(v) {
return v == null;
}
;// ./node_modules/framer-motion/dist/es/value/types/utils/single-color-regex.mjs
const singleColorRegex = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))$/iu;
;// ./node_modules/framer-motion/dist/es/value/types/color/utils.mjs
/**
* Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,
* but false if a number or multiple colors
*/
const isColorString = (type, testProp) => (v) => {
return Boolean((typeof v === "string" &&
singleColorRegex.test(v) &&
v.startsWith(type)) ||
(testProp &&
!isNullish(v) &&
Object.prototype.hasOwnProperty.call(v, testProp)));
};
const splitColor = (aName, bName, cName) => (v) => {
if (typeof v !== "string")
return v;
const [a, b, c, alpha] = v.match(floatRegex);
return {
[aName]: parseFloat(a),
[bName]: parseFloat(b),
[cName]: parseFloat(c),
alpha: alpha !== undefined ? parseFloat(alpha) : 1,
};
};
;// ./node_modules/framer-motion/dist/es/value/types/color/rgba.mjs
const clampRgbUnit = (v) => clamp_clamp(0, 255, v);
const rgbUnit = {
...number,
transform: (v) => Math.round(clampRgbUnit(v)),
};
const 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)) +
")",
};
;// ./node_modules/framer-motion/dist/es/value/types/color/hex.mjs
function parseHex(v) {
let r = "";
let g = "";
let b = "";
let a = "";
// If we have 6 characters, ie #FF0000
if (v.length > 5) {
r = v.substring(1, 3);
g = v.substring(3, 5);
b = v.substring(5, 7);
a = v.substring(7, 9);
// Or we have 3 characters, ie #F00
}
else {
r = v.substring(1, 2);
g = v.substring(2, 3);
b = v.substring(3, 4);
a = v.substring(4, 5);
r += r;
g += g;
b += b;
a += a;
}
return {
red: parseInt(r, 16),
green: parseInt(g, 16),
blue: parseInt(b, 16),
alpha: a ? parseInt(a, 16) / 255 : 1,
};
}
const hex = {
test: /*@__PURE__*/ isColorString("#"),
parse: parseHex,
transform: rgba.transform,
};
;// ./node_modules/framer-motion/dist/es/value/types/numbers/units.mjs
const createUnitType = (unit) => ({
test: (v) => typeof v === "string" && v.endsWith(unit) && v.split(" ").length === 1,
parse: parseFloat,
transform: (v) => `${v}${unit}`,
});
const degrees = /*@__PURE__*/ createUnitType("deg");
const percent = /*@__PURE__*/ createUnitType("%");
const px = /*@__PURE__*/ createUnitType("px");
const vh = /*@__PURE__*/ createUnitType("vh");
const vw = /*@__PURE__*/ createUnitType("vw");
const progressPercentage = {
...percent,
parse: (v) => percent.parse(v) / 100,
transform: (v) => percent.transform(v * 100),
};
;// ./node_modules/framer-motion/dist/es/value/types/color/hsla.mjs
const 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)) +
")");
},
};
;// ./node_modules/framer-motion/dist/es/value/types/color/index.mjs
const color = {
test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),
parse: (v) => {
if (rgba.test(v)) {
return rgba.parse(v);
}
else if (hsla.test(v)) {
return hsla.parse(v);
}
else {
return hex.parse(v);
}
},
transform: (v) => {
return typeof v === "string"
? v
: v.hasOwnProperty("red")
? rgba.transform(v)
: hsla.transform(v);
},
};
;// ./node_modules/framer-motion/dist/es/value/types/utils/color-regex.mjs
const colorRegex = /(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\))/giu;
;// ./node_modules/framer-motion/dist/es/value/types/complex/index.mjs
function test(v) {
var _a, _b;
return (isNaN(v) &&
typeof v === "string" &&
(((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) +
(((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) >
0);
}
const NUMBER_TOKEN = "number";
const COLOR_TOKEN = "color";
const VAR_TOKEN = "var";
const VAR_FUNCTION_TOKEN = "var(";
const SPLIT_TOKEN = "${}";
// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`
const 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 i = 0;
const tokenised = originalValue.replace(complexRegex, (parsedValue) => {
if (color.test(parsedValue)) {
indexes.color.push(i);
types.push(COLOR_TOKEN);
values.push(color.parse(parsedValue));
}
else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {
indexes.var.push(i);
types.push(VAR_TOKEN);
values.push(parsedValue);
}
else {
indexes.number.push(i);
types.push(NUMBER_TOKEN);
values.push(parseFloat(parsedValue));
}
++i;
return SPLIT_TOKEN;
});
const split = tokenised.split(SPLIT_TOKEN);
return { values, split, indexes, types };
}
function parseComplexValue(v) {
return analyseComplexValue(v).values;
}
function createTransformer(source) {
const { split, types } = analyseComplexValue(source);
const numSections = split.length;
return (v) => {
let output = "";
for (let i = 0; i < numSections; i++) {
output += split[i];
if (v[i] !== undefined) {
const type = types[i];
if (type === NUMBER_TOKEN) {
output += sanitize(v[i]);
}
else if (type === COLOR_TOKEN) {
output += color.transform(v[i]);
}
else {
output += v[i];
}
}
}
return output;
};
}
const convertNumbersToZero = (v) => typeof v === "number" ? 0 : v;
function getAnimatableNone(v) {
const parsed = parseComplexValue(v);
const transformer = createTransformer(v);
return transformer(parsed.map(convertNumbersToZero));
}
const complex = {
test,
parse: parseComplexValue,
createTransformer,
getAnimatableNone,
};
;// ./node_modules/framer-motion/dist/es/value/types/complex/filter.mjs
/**
* Properties that should default to 1 or 100%
*/
const maxDefaults = new Set(["brightness", "contrast", "saturate", "opacity"]);
function applyDefaultFilter(v) {
const [name, value] = v.slice(0, -1).split("(");
if (name === "drop-shadow")
return v;
const [number] = value.match(floatRegex) || [];
if (!number)
return v;
const unit = value.replace(number, "");
let defaultValue = maxDefaults.has(name) ? 1 : 0;
if (number !== value)
defaultValue *= 100;
return name + "(" + defaultValue + unit + ")";
}
const functionRegex = /\b([a-z-]*)\(.*?\)/gu;
const filter = {
...complex,
getAnimatableNone: (v) => {
const functions = v.match(functionRegex);
return functions ? functions.map(applyDefaultFilter).join(" ") : v;
},
};
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/number-browser.mjs
const 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,
};
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/transform.mjs
const transformValueTypes = {
rotate: degrees,
rotateX: degrees,
rotateY: degrees,
rotateZ: degrees,
scale: 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,
};
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs
const type_int_int = {
...number,
transform: Math.round,
};
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs
const numberValueTypes = {
...browserNumberValueTypes,
...transformValueTypes,
zIndex: type_int_int,
size: px,
// SVG
fillOpacity: alpha,
strokeOpacity: alpha,
numOctaves: type_int_int,
};
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs
/**
* A map of default value types for common values
*/
const defaultValueTypes = {
...numberValueTypes,
// Color props
color: color,
backgroundColor: color,
outlineColor: color,
fill: color,
stroke: color,
// Border props
borderColor: color,
borderTopColor: color,
borderRightColor: color,
borderBottomColor: color,
borderLeftColor: color,
filter: filter,
WebkitFilter: filter,
};
/**
* Gets the default ValueType for the provided value key
*/
const getDefaultValueType = (key) => defaultValueTypes[key];
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs
function animatable_none_getAnimatableNone(key, value) {
let defaultValueType = getDefaultValueType(key);
if (defaultValueType !== filter)
defaultValueType = complex;
// If value is not recognised as animatable, ie "none", create an animatable version origin based on the target
return defaultValueType.getAnimatableNone
? defaultValueType.getAnimatableNone(value)
: undefined;
}
;// ./node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs
/**
* If we encounter keyframes like "none" or "0" and we also have keyframes like
* "#fff" or "200px 200px" we want to find a keyframe to serve as a template for
* the "none" keyframes. In this case "#fff" or "200px 200px" - then these get turned into
* zero equivalents, i.e. "#fff0" or "0px 0px".
*/
const invalidTemplates = new Set(["auto", "none", "0"]);
function makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {
let i = 0;
let animatableTemplate = undefined;
while (i < unresolvedKeyframes.length && !animatableTemplate) {
const keyframe = unresolvedKeyframes[i];
if (typeof keyframe === "string" &&
!invalidTemplates.has(keyframe) &&
analyseComplexValue(keyframe).values.length) {
animatableTemplate = unresolvedKeyframes[i];
}
i++;
}
if (animatableTemplate && name) {
for (const noneIndex of noneKeyframeIndexes) {
unresolvedKeyframes[noneIndex] = animatable_none_getAnimatableNone(name, animatableTemplate);
}
}
}
;// ./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs
const isNumOrPxType = (v) => v === number || v === px;
const getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(", ")[pos]);
const 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;
}
}
};
const transformKeys = new Set(["x", "y", "z"]);
const nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));
function removeNonTranslationalTransform(visualElement) {
const removedTransforms = [];
nonTranslationalTransformKeys.forEach((key) => {
const value = visualElement.getValue(key);
if (value !== undefined) {
removedTransforms.push([key, value.get()]);
value.set(key.startsWith("scale") ? 1 : 0);
}
});
return removedTransforms;
}
const positionalValues = {
// Dimensions
width: ({ x }, { paddingLeft = "0", paddingRight = "0" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),
height: ({ y }, { paddingTop = "0", paddingBottom = "0" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),
top: (_bbox, { top }) => parseFloat(top),
left: (_bbox, { left }) => parseFloat(left),
bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),
right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),
// Transform
x: getTranslateFromMatrix(4, 13),
y: getTranslateFromMatrix(5, 14),
};
// Alias translate longform names
positionalValues.translateX = positionalValues.x;
positionalValues.translateY = positionalValues.y;
;// ./node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs
const toResolve = new Set();
let isScheduled = false;
let 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 = new Map();
/**
* Write pass
* If we're measuring elements we want to remove bounding box-changing transforms.
*/
elementsToMeasure.forEach((element) => {
const removedTransforms = removeNonTranslationalTransform(element);
if (!removedTransforms.length)
return;
transformsToRestore.set(element, removedTransforms);
element.render();
});
// Read
resolversToMeasure.forEach((resolver) => resolver.measureInitialState());
// Write
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);
});
}
});
// Read
resolversToMeasure.forEach((resolver) => resolver.measureEndState());
// Write
resolversToMeasure.forEach((resolver) => {
if (resolver.suspendedScrollY !== undefined) {
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();
}
class KeyframeResolver {
constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {
/**
* Track whether this resolver has completed. Once complete, it never
* needs to attempt keyframe resolution again.
*/
this.isComplete = false;
/**
* Track whether this resolver is async. If it is, it'll be added to the
* resolver queue and flushed in the next frame. Resolvers that aren't going
* to trigger read/write thrashing don't need to be async.
*/
this.isAsync = false;
/**
* Track whether this resolver needs to perform a measurement
* to resolve its keyframes.
*/
this.needsMeasurement = false;
/**
* Track whether this resolver is currently scheduled to resolve
* to allow it to be cancelled and resumed externally.
*/
this.isScheduled = false;
this.unresolvedKeyframes = [...unresolvedKeyframes];
this.onComplete = onComplete;
this.name = name;
this.motionValue = motionValue;
this.element = element;
this.isAsync = isAsync;
}
scheduleResolve() {
this.isScheduled = true;
if (this.isAsync) {
toResolve.add(this);
if (!isScheduled) {
isScheduled = true;
frame_frame.read(readAllKeyframes);
frame_frame.resolveKeyframes(measureAllKeyframes);
}
}
else {
this.readKeyframes();
this.complete();
}
}
readKeyframes() {
const { unresolvedKeyframes, name, element, motionValue } = this;
/**
* If a keyframe is null, we hydrate it either by reading it from
* the instance, or propagating from previous keyframes.
*/
for (let i = 0; i < unresolvedKeyframes.length; i++) {
if (unresolvedKeyframes[i] === null) {
/**
* If the first keyframe is null, we need to find its value by sampling the element
*/
if (i === 0) {
const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();
const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
if (currentValue !== undefined) {
unresolvedKeyframes[0] = currentValue;
}
else if (element && name) {
const valueAsRead = element.readValue(name, finalKeyframe);
if (valueAsRead !== undefined && valueAsRead !== null) {
unresolvedKeyframes[0] = valueAsRead;
}
}
if (unresolvedKeyframes[0] === undefined) {
unresolvedKeyframes[0] = finalKeyframe;
}
if (motionValue && currentValue === undefined) {
motionValue.set(unresolvedKeyframes[0]);
}
}
else {
unresolvedKeyframes[i] = unresolvedKeyframes[i - 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();
}
}
;// ./node_modules/motion-utils/dist/es/errors.mjs
let warning = noop_noop;
let errors_invariant = noop_noop;
if (false) {}
;// ./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs
/**
* Check if value is a numerical string, ie a string that is purely a number eg "100" or "-100.1"
*/
const isNumericalString = (v) => /^-?(?:\d+(?:\.\d+)?|\.\d+)$/u.test(v);
;// ./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs
const checkStringStartsWith = (token) => (key) => typeof key === "string" && key.startsWith(token);
const isCSSVariableName =
/*@__PURE__*/ checkStringStartsWith("--");
const startsAsVariableToken =
/*@__PURE__*/ checkStringStartsWith("var(--");
const isCSSVariableToken = (value) => {
const startsWithToken = startsAsVariableToken(value);
if (!startsWithToken)
return false;
// Ensure any comments are stripped from the value as this can harm performance of the regex.
return singleCssVariableRegex.test(value.split("/*")[0].trim());
};
const singleCssVariableRegex = /var\(--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)$/iu;
;// ./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs
/**
* Parse Framer's special CSS variable format into a CSS token and a fallback.
*
* ```
* `var(--foo, #fff)` => [`--foo`, '#fff']
* ```
*
* @param current
*/
const 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 match = splitCSSVariableRegex.exec(current);
if (!match)
return [,];
const [, token1, token2, fallback] = match;
return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, fallback];
}
const maxDepth = 4;
function getVariableValue(current, element, depth = 1) {
errors_invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property "${current}". This may indicate a circular fallback dependency.`);
const [token, fallback] = parseCSSVariable(current);
// No CSS variable detected
if (!token)
return;
// Attempt to read this CSS variable off the element
const resolved = window.getComputedStyle(element).getPropertyValue(token);
if (resolved) {
const trimmed = resolved.trim();
return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;
}
return isCSSVariableToken(fallback)
? getVariableValue(fallback, element, depth + 1)
: fallback;
}
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs
/**
* Tests a provided value against a ValueType
*/
const testValueType = (v) => (type) => type.test(v);
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs
/**
* ValueType for "auto"
*/
const auto = {
test: (v) => v === "auto",
parse: (v) => v,
};
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs
/**
* A list of value types commonly used for dimensions
*/
const dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];
/**
* Tests a dimensional value against the list of dimension ValueTypes
*/
const findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));
;// ./node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs
class DOMKeyframesResolver extends KeyframeResolver {
constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {
super(unresolvedKeyframes, onComplete, name, motionValue, element, true);
}
readKeyframes() {
const { unresolvedKeyframes, element, name } = this;
if (!element || !element.current)
return;
super.readKeyframes();
/**
* If any keyframe is a CSS variable, we need to find its value by sampling the element
*/
for (let i = 0; i < unresolvedKeyframes.length; i++) {
let keyframe = unresolvedKeyframes[i];
if (typeof keyframe === "string") {
keyframe = keyframe.trim();
if (isCSSVariableToken(keyframe)) {
const resolved = getVariableValue(keyframe, element.current);
if (resolved !== undefined) {
unresolvedKeyframes[i] = resolved;
}
if (i === unresolvedKeyframes.length - 1) {
this.finalKeyframe = keyframe;
}
}
}
}
/**
* Resolve "none" values. We do this potentially twice - once before and once after measuring keyframes.
* This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which
* have a far bigger performance impact.
*/
this.resolveNoneKeyframes();
/**
* Check to see if unit type has changed. If so schedule jobs that will
* temporarily set styles to the destination keyframes.
* Skip if we have more than two keyframes or this isn't a positional value.
* TODO: We can throw if there are multiple keyframes and the value type changes.
*/
if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {
return;
}
const [origin, target] = unresolvedKeyframes;
const originType = findDimensionValueType(origin);
const targetType = findDimensionValueType(target);
/**
* Either we don't recognise these value types or we can animate between them.
*/
if (originType === targetType)
return;
/**
* If both values are numbers or pixels, we can animate between them by
* converting them to numbers.
*/
if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {
for (let i = 0; i < unresolvedKeyframes.length; i++) {
const value = unresolvedKeyframes[i];
if (typeof value === "string") {
unresolvedKeyframes[i] = parseFloat(value);
}
}
}
else {
/**
* Else, the only way to resolve this is by measuring the element.
*/
this.needsMeasurement = true;
}
}
resolveNoneKeyframes() {
const { unresolvedKeyframes, name } = this;
const noneKeyframeIndexes = [];
for (let i = 0; i < unresolvedKeyframes.length; i++) {
if (isNone(unresolvedKeyframes[i])) {
noneKeyframeIndexes.push(i);
}
}
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;
// Set final key frame to measure after next render
const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];
if (measureKeyframe !== undefined) {
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 === undefined) {
this.finalKeyframe = finalKeyframe;
}
// If we removed transform values, reapply them before the next render
if ((_a = this.removedTransforms) === null || _a === void 0 ? void 0 : _a.length) {
this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {
element
.getValue(unsetTransformName)
.set(unsetTransformValue);
});
}
this.resolveNoneKeyframes();
}
}
;// ./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs
/**
* Check if a value is animatable. Examples:
*
* ✅: 100, "100px", "#fff"
* ❌: "block", "url(2.jpg)"
* @param value
*
* @internal
*/
const isAnimatable = (value, name) => {
// If the list of keys tat might be non-animatable grows, replace with Set
if (name === "zIndex")
return false;
// If it's a number or a keyframes array, we can animate it. We might at some point
// need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,
// but for now lets leave it like this for performance reasons
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(") // Unless it starts with "url("
) {
return true;
}
return false;
};
;// ./node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs
function hasKeyframesChanged(keyframes) {
const current = keyframes[0];
if (keyframes.length === 1)
return true;
for (let i = 0; i < keyframes.length; i++) {
if (keyframes[i] !== current)
return true;
}
}
function canAnimate(keyframes, name, type, velocity) {
/**
* Check if we're able to animate between the start and end keyframes,
* and throw a warning if we're attempting to animate between one that's
* animatable and another that isn't.
*/
const originKeyframe = keyframes[0];
if (originKeyframe === null)
return false;
/**
* These aren't traditionally animatable but we do support them.
* In future we could look into making this more generic or replacing
* this function with mix() === mixImmediate
*/
if (name === "display" || name === "visibility")
return true;
const targetKeyframe = keyframes[keyframes.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.`);
// Always skip if any of these are true
if (!isOriginAnimatable || !isTargetAnimatable) {
return false;
}
return (hasKeyframesChanged(keyframes) ||
((type === "spring" || isGenerator(type)) && velocity));
}
;// ./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs
const isNotNull = (value) => value !== null;
function getFinalKeyframe(keyframes, { repeat, repeatType = "loop" }, finalKeyframe) {
const resolvedKeyframes = keyframes.filter(isNotNull);
const index = repeat && repeatType !== "loop" && repeat % 2 === 1
? 0
: resolvedKeyframes.length - 1;
return !index || finalKeyframe === undefined
? resolvedKeyframes[index]
: finalKeyframe;
}
;// ./node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs
/**
* Maximum time allowed between an animation being created and it being
* resolved for us to use the latter as the start time.
*
* This is to ensure that while we prefer to "start" an animation as soon
* as it's triggered, we also want to avoid a visual jump if there's a big delay
* between these two moments.
*/
const MAX_RESOLVE_DELAY = 40;
class BaseAnimation {
constructor({ autoplay = true, delay = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", ...options }) {
// Track whether the animation has been stopped. Stopped animations won't restart.
this.isStopped = false;
this.hasAttemptedResolve = false;
this.createdAt = time.now();
this.options = {
autoplay,
delay,
type,
repeat,
repeatDelay,
repeatType,
...options,
};
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(keyframes, finalKeyframe) {
this.resolvedAt = time.now();
this.hasAttemptedResolve = true;
const { name, type, velocity, delay, onComplete, onUpdate, isGenerator, } = this.options;
/**
* If we can't animate this value with the resolved keyframes
* then we should complete it immediately.
*/
if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {
// Finish immediately
if (instantAnimationState.current || !delay) {
onUpdate &&
onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));
onComplete && onComplete();
this.resolveFinishedPromise();
return;
}
// Finish after a delay
else {
this.options.duration = 0;
}
}
const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);
if (resolvedAnimation === false)
return;
this._resolved = {
keyframes,
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;
});
}
}
;// ./node_modules/framer-motion/dist/es/utils/mix/number.mjs
/*
Value in range from progress
Given a lower limit and an upper limit, we return the value within
that range as expressed by progress (usually a number from 0 to 1)
So progress = 0.5 would change
from -------- to
to
from ---- to
E.g. from = 10, to = 20, progress = 0.5 => 15
@param [number]: Lower limit of range
@param [number]: Upper limit of range
@param [number]: The progress between lower and upper limits expressed 0-1
@return [number]: Value as calculated from progress within range (not limited within range)
*/
const mixNumber = (from, to, progress) => {
return from + (to - from) * progress;
};
;// ./node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs
// Adapted from https://gist.github.com/mjackson/5311256
function hueToRgb(p, q, t) {
if (t < 0)
t += 1;
if (t > 1)
t -= 1;
if (t < 1 / 6)
return p + (q - p) * 6 * t;
if (t < 1 / 2)
return q;
if (t < 2 / 3)
return p + (q - p) * (2 / 3 - t) * 6;
return p;
}
function hslaToRgba({ hue, saturation, lightness, alpha }) {
hue /= 360;
saturation /= 100;
lightness /= 100;
let red = 0;
let green = 0;
let blue = 0;
if (!saturation) {
red = green = blue = lightness;
}
else {
const q = lightness < 0.5
? lightness * (1 + saturation)
: lightness + saturation - lightness * saturation;
const p = 2 * lightness - q;
red = hueToRgb(p, q, hue + 1 / 3);
green = hueToRgb(p, q, hue);
blue = hueToRgb(p, q, hue - 1 / 3);
}
return {
red: Math.round(red * 255),
green: Math.round(green * 255),
blue: Math.round(blue * 255),
alpha,
};
}
;// ./node_modules/framer-motion/dist/es/utils/mix/immediate.mjs
function mixImmediate(a, b) {
return (p) => (p > 0 ? b : a);
}
;// ./node_modules/framer-motion/dist/es/utils/mix/color.mjs
// Linear color space blending
// Explained https://www.youtube.com/watch?v=LKnqECcg6Gw
// Demonstrated http://codepen.io/osublake/pen/xGVVaN
const mixLinearColor = (from, to, v) => {
const fromExpo = from * from;
const expo = v * (to * to - fromExpo) + fromExpo;
return expo < 0 ? 0 : Math.sqrt(expo);
};
const colorTypes = [hex, rgba, hsla];
const getColorType = (v) => colorTypes.find((type) => type.test(v));
function asRGBA(color) {
const type = getColorType(color);
warning(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`);
if (!Boolean(type))
return false;
let model = type.parse(color);
if (type === hsla) {
// TODO Remove this cast - needed since Motion's stricter typing
model = hslaToRgba(model);
}
return model;
}
const mixColor = (from, to) => {
const fromRGBA = asRGBA(from);
const toRGBA = asRGBA(to);
if (!fromRGBA || !toRGBA) {
return mixImmediate(from, to);
}
const blended = { ...fromRGBA };
return (v) => {
blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);
blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);
blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);
blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v);
return rgba.transform(blended);
};
};
;// ./node_modules/framer-motion/dist/es/utils/pipe.mjs
/**
* Pipe
* Compose other transformers to run linearily
* pipe(min(20), max(40))
* @param {...functions} transformers
* @return {function}
*/
const combineFunctions = (a, b) => (v) => b(a(v));
const pipe = (...transformers) => transformers.reduce(combineFunctions);
;// ./node_modules/framer-motion/dist/es/utils/mix/visibility.mjs
const invisibleValues = new Set(["none", "hidden"]);
/**
* Returns a function that, when provided a progress value between 0 and 1,
* will return the "none" or "hidden" string only when the progress is that of
* the origin or target.
*/
function mixVisibility(origin, target) {
if (invisibleValues.has(origin)) {
return (p) => (p <= 0 ? origin : target);
}
else {
return (p) => (p >= 1 ? target : origin);
}
}
;// ./node_modules/framer-motion/dist/es/utils/mix/complex.mjs
function complex_mixNumber(a, b) {
return (p) => mixNumber(a, b, p);
}
function getMixer(a) {
if (typeof a === "number") {
return complex_mixNumber;
}
else if (typeof a === "string") {
return isCSSVariableToken(a)
? mixImmediate
: color.test(a)
? mixColor
: mixComplex;
}
else if (Array.isArray(a)) {
return mixArray;
}
else if (typeof a === "object") {
return color.test(a) ? mixColor : mixObject;
}
return mixImmediate;
}
function mixArray(a, b) {
const output = [...a];
const numValues = output.length;
const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));
return (p) => {
for (let i = 0; i < numValues; i++) {
output[i] = blendValue[i](p);
}
return output;
};
}
function mixObject(a, b) {
const output = { ...a, ...b };
const blendValue = {};
for (const key in output) {
if (a[key] !== undefined && b[key] !== undefined) {
blendValue[key] = getMixer(a[key])(a[key], b[key]);
}
}
return (v) => {
for (const key in blendValue) {
output[key] = blendValue[key](v);
}
return output;
};
}
function matchOrder(origin, target) {
var _a;
const orderedOrigin = [];
const pointers = { color: 0, var: 0, number: 0 };
for (let i = 0; i < target.values.length; i++) {
const type = target.types[i];
const originIndex = origin.indexes[type][pointers[type]];
const originValue = (_a = origin.values[originIndex]) !== null && _a !== void 0 ? _a : 0;
orderedOrigin[i] = originValue;
pointers[type]++;
}
return orderedOrigin;
}
const 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 different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);
return mixImmediate(origin, target);
}
};
;// ./node_modules/framer-motion/dist/es/utils/mix/index.mjs
function mix(from, to, p) {
if (typeof from === "number" &&
typeof to === "number" &&
typeof p === "number") {
return mixNumber(from, to, p);
}
const mixer = getMixer(from);
return mixer(from, to);
}
;// ./node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs
const velocitySampleDuration = 5; // ms
function calcGeneratorVelocity(resolveValue, t, current) {
const prevT = Math.max(t - velocitySampleDuration, 0);
return velocityPerSecond(current - resolveValue(prevT), t - prevT);
}
;// ./node_modules/framer-motion/dist/es/animation/generators/spring/defaults.mjs
const springDefaults = {
// Default spring physics
stiffness: 100,
damping: 10,
mass: 1.0,
velocity: 0.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: 0.005,
default: 0.5,
},
// Limits
minDuration: 0.01, // in seconds
maxDuration: 10.0, // in seconds
minDamping: 0.05,
maxDamping: 1,
};
;// ./node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs
const safeMin = 0.001;
function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {
let envelope;
let derivative;
warning(duration <= time_conversion_secondsToMilliseconds(springDefaults.maxDuration), "Spring duration must be 10 seconds or less");
let dampingRatio = 1 - bounce;
/**
* Restrict dampingRatio and duration to within acceptable ranges.
*/
dampingRatio = clamp_clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
duration = clamp_clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));
if (dampingRatio < 1) {
/**
* Underdamped spring
*/
envelope = (undampedFreq) => {
const exponentialDecay = undampedFreq * dampingRatio;
const delta = exponentialDecay * duration;
const a = exponentialDecay - velocity;
const b = calcAngularFreq(undampedFreq, dampingRatio);
const c = Math.exp(-delta);
return safeMin - (a / b) * c;
};
derivative = (undampedFreq) => {
const exponentialDecay = undampedFreq * dampingRatio;
const delta = exponentialDecay * duration;
const d = delta * velocity + velocity;
const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;
const f = Math.exp(-delta);
const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);
const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;
return (factor * ((d - e) * f)) / g;
};
}
else {
/**
* Critically-damped spring
*/
envelope = (undampedFreq) => {
const a = Math.exp(-undampedFreq * duration);
const b = (undampedFreq - velocity) * duration + 1;
return -safeMin + a * b;
};
derivative = (undampedFreq) => {
const a = Math.exp(-undampedFreq * duration);
const b = (velocity - undampedFreq) * (duration * duration);
return a * b;
};
}
const initialGuess = 5 / duration;
const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
duration = time_conversion_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,
};
}
}
const rootIterations = 12;
function approximateRoot(envelope, derivative, initialGuess) {
let result = initialGuess;
for (let i = 1; i < rootIterations; i++) {
result = result - envelope(result) / derivative(result);
}
return result;
}
function calcAngularFreq(undampedFreq, dampingRatio) {
return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
}
;// ./node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs
const durationKeys = ["duration", "bounce"];
const physicsKeys = ["stiffness", "damping", "mass"];
function isSpringType(options, keys) {
return keys.some((key) => options[key] !== undefined);
}
function getSpringOptions(options) {
let springOptions = {
velocity: springDefaults.velocity,
stiffness: springDefaults.stiffness,
damping: springDefaults.damping,
mass: springDefaults.mass,
isResolvedFromDuration: false,
...options,
};
// stiffness/damping/mass overrides duration/bounce
if (!isSpringType(options, physicsKeys) &&
isSpringType(options, durationKeys)) {
if (options.visualDuration) {
const visualDuration = options.visualDuration;
const root = (2 * Math.PI) / (visualDuration * 1.2);
const stiffness = root * root;
const damping = 2 *
clamp_clamp(0.05, 1, 1 - (options.bounce || 0)) *
Math.sqrt(stiffness);
springOptions = {
...springOptions,
mass: springDefaults.mass,
stiffness,
damping,
};
}
else {
const derived = findSpring(options);
springOptions = {
...springOptions,
...derived,
mass: springDefaults.mass,
};
springOptions.isResolvedFromDuration = true;
}
}
return springOptions;
}
function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
const options = typeof optionsOrVisualDuration !== "object"
? {
visualDuration: optionsOrVisualDuration,
keyframes: [0, 1],
bounce,
}
: optionsOrVisualDuration;
let { restSpeed, restDelta } = options;
const origin = options.keyframes[0];
const target = options.keyframes[options.keyframes.length - 1];
/**
* This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
* to reduce GC during animation.
*/
const state = { done: false, value: origin };
const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({
...options,
velocity: -millisecondsToSeconds(options.velocity || 0),
});
const initialVelocity = velocity || 0.0;
const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
const initialDelta = target - origin;
const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
/**
* If we're working on a granular scale, use smaller defaults for determining
* when the spring is finished.
*
* These defaults have been selected emprically based on what strikes a good
* ratio between feeling good and finishing as soon as changes are imperceptible.
*/
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);
// Underdamped spring
resolveSpring = (t) => {
const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
return (target -
envelope *
(((initialVelocity +
dampingRatio * undampedAngularFreq * initialDelta) /
angularFreq) *
Math.sin(angularFreq * t) +
initialDelta * Math.cos(angularFreq * t)));
};
}
else if (dampingRatio === 1) {
// Critically damped spring
resolveSpring = (t) => target -
Math.exp(-undampedAngularFreq * t) *
(initialDelta +
(initialVelocity + undampedAngularFreq * initialDelta) * t);
}
else {
// Overdamped spring
const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
resolveSpring = (t) => {
const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
// When performing sinh or cosh values can hit Infinity so we cap them here
const freqForT = Math.min(dampedAngularFreq * t, 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: (t) => {
const current = resolveSpring(t);
if (!isResolvedFromDuration) {
let currentVelocity = 0.0;
/**
* We only need to calculate velocity for under-damped springs
* as over- and critically-damped springs can't overshoot, so
* checking only for displacement is enough.
*/
if (dampingRatio < 1) {
currentVelocity =
t === 0
? time_conversion_secondsToMilliseconds(initialVelocity)
: calcGeneratorVelocity(resolveSpring, t, current);
}
const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
state.done =
isBelowVelocityThreshold && isBelowDisplacementThreshold;
}
else {
state.done = t >= duration;
}
state.value = state.done ? target : current;
return state;
},
toString: () => {
const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);
return calculatedDuration + "ms " + easing;
},
};
return generator;
}
;// ./node_modules/framer-motion/dist/es/animation/generators/inertia.mjs
function inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {
const origin = keyframes[0];
const state = {
done: false,
value: origin,
};
const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);
const nearestBoundary = (v) => {
if (min === undefined)
return max;
if (max === undefined)
return min;
return Math.abs(min - v) < Math.abs(max - v) ? min : max;
};
let amplitude = power * velocity;
const ideal = origin + amplitude;
const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);
/**
* If the target has changed we need to re-calculate the amplitude, otherwise
* the animation will start from the wrong position.
*/
if (target !== ideal)
amplitude = target - origin;
const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);
const calcLatest = (t) => target + calcDelta(t);
const applyFriction = (t) => {
const delta = calcDelta(t);
const latest = calcLatest(t);
state.done = Math.abs(delta) <= restDelta;
state.value = state.done ? target : latest;
};
/**
* Ideally this would resolve for t in a stateless way, we could
* do that by always precalculating the animation but as we know
* this will be done anyway we can assume that spring will
* be discovered during that.
*/
let timeReachedBoundary;
let spring$1;
const checkCatchBoundary = (t) => {
if (!isOutOfBounds(state.value))
return;
timeReachedBoundary = t;
spring$1 = spring({
keyframes: [state.value, nearestBoundary(state.value)],
velocity: calcGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000
damping: bounceDamping,
stiffness: bounceStiffness,
restDelta,
restSpeed,
});
};
checkCatchBoundary(0);
return {
calculatedDuration: null,
next: (t) => {
/**
* We need to resolve the friction to figure out if we need a
* spring but we don't want to do this twice per frame. So here
* we flag if we updated for this frame and later if we did
* we can skip doing it again.
*/
let hasUpdatedFrame = false;
if (!spring$1 && timeReachedBoundary === undefined) {
hasUpdatedFrame = true;
applyFriction(t);
checkCatchBoundary(t);
}
/**
* If we have a spring and the provided t is beyond the moment the friction
* animation crossed the min/max boundary, use the spring.
*/
if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {
return spring$1.next(t - timeReachedBoundary);
}
else {
!hasUpdatedFrame && applyFriction(t);
return state;
}
},
};
}
;// ./node_modules/framer-motion/dist/es/easing/ease.mjs
const easeIn = /*@__PURE__*/ cubicBezier(0.42, 0, 1, 1);
const easeOut = /*@__PURE__*/ cubicBezier(0, 0, 0.58, 1);
const easeInOut = /*@__PURE__*/ cubicBezier(0.42, 0, 0.58, 1);
;// ./node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs
const isEasingArray = (ease) => {
return Array.isArray(ease) && typeof ease[0] !== "number";
};
;// ./node_modules/framer-motion/dist/es/easing/utils/map.mjs
const easingLookup = {
linear: noop_noop,
easeIn: easeIn,
easeInOut: easeInOut,
easeOut: easeOut,
circIn: circIn,
circInOut: circInOut,
circOut: circOut,
backIn: backIn,
backInOut: backInOut,
backOut: backOut,
anticipate: anticipate,
};
const easingDefinitionToFunction = (definition) => {
if (isBezierDefinition(definition)) {
// If cubic bezier definition, create bezier curve
errors_invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);
const [x1, y1, x2, y2] = definition;
return cubicBezier(x1, y1, x2, y2);
}
else if (typeof definition === "string") {
// Else lookup from table
errors_invariant(easingLookup[definition] !== undefined, `Invalid easing type '${definition}'`);
return easingLookup[definition];
}
return definition;
};
;// ./node_modules/framer-motion/dist/es/utils/interpolate.mjs
function createMixers(output, ease, customMixer) {
const mixers = [];
const mixerFactory = customMixer || mix;
const numMixers = output.length - 1;
for (let i = 0; i < numMixers; i++) {
let mixer = mixerFactory(output[i], output[i + 1]);
if (ease) {
const easingFunction = Array.isArray(ease) ? ease[i] || noop_noop : ease;
mixer = pipe(easingFunction, mixer);
}
mixers.push(mixer);
}
return mixers;
}
/**
* Create a function that maps from a numerical input array to a generic output array.
*
* Accepts:
* - Numbers
* - Colors (hex, hsl, hsla, rgb, rgba)
* - Complex (combinations of one or more numbers or strings)
*
* ```jsx
* const mixColor = interpolate([0, 1], ['#fff', '#000'])
*
* mixColor(0.5) // 'rgba(128, 128, 128, 1)'
* ```
*
* TODO Revist this approach once we've moved to data models for values,
* probably not needed to pregenerate mixer functions.
*
* @public
*/
function interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {
const inputLength = input.length;
errors_invariant(inputLength === output.length, "Both input and output ranges must be the same length");
/**
* If we're only provided a single input, we can just make a function
* that returns the output.
*/
if (inputLength === 1)
return () => output[0];
if (inputLength === 2 && output[0] === output[1])
return () => output[1];
const isZeroDeltaRange = input[0] === input[1];
// If input runs highest -> lowest, reverse both arrays
if (input[0] > input[inputLength - 1]) {
input = [...input].reverse();
output = [...output].reverse();
}
const mixers = createMixers(output, ease, mixer);
const numMixers = mixers.length;
const interpolator = (v) => {
if (isZeroDeltaRange && v < input[0])
return output[0];
let i = 0;
if (numMixers > 1) {
for (; i < input.length - 2; i++) {
if (v < input[i + 1])
break;
}
}
const progressInRange = progress(input[i], input[i + 1], v);
return mixers[i](progressInRange);
};
return isClamp
? (v) => interpolator(clamp_clamp(input[0], input[inputLength - 1], v))
: interpolator;
}
;// ./node_modules/framer-motion/dist/es/utils/offsets/fill.mjs
function fillOffset(offset, remaining) {
const min = offset[offset.length - 1];
for (let i = 1; i <= remaining; i++) {
const offsetProgress = progress(0, remaining, i);
offset.push(mixNumber(min, 1, offsetProgress));
}
}
;// ./node_modules/framer-motion/dist/es/utils/offsets/default.mjs
function defaultOffset(arr) {
const offset = [0];
fillOffset(offset, arr.length - 1);
return offset;
}
;// ./node_modules/framer-motion/dist/es/utils/offsets/time.mjs
function convertOffsetToTimes(offset, duration) {
return offset.map((o) => o * duration);
}
;// ./node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs
function keyframes_defaultEasing(values, easing) {
return values.map(() => easing || easeInOut).splice(0, values.length - 1);
}
function keyframes_keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut", }) {
/**
* Easing functions can be externally defined as strings. Here we convert them
* into actual functions.
*/
const easingFunctions = isEasingArray(ease)
? ease.map(easingDefinitionToFunction)
: easingDefinitionToFunction(ease);
/**
* This is the Iterator-spec return value. We ensure it's mutable rather than using a generator
* to reduce GC during animation.
*/
const state = {
done: false,
value: keyframeValues[0],
};
/**
* Create a times array based on the provided 0-1 offsets
*/
const absoluteTimes = convertOffsetToTimes(
// Only use the provided offsets if they're the correct length
// TODO Maybe we should warn here if there's a length mismatch
times && times.length === keyframeValues.length
? times
: defaultOffset(keyframeValues), duration);
const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {
ease: Array.isArray(easingFunctions)
? easingFunctions
: keyframes_defaultEasing(keyframeValues, easingFunctions),
});
return {
calculatedDuration: duration,
next: (t) => {
state.value = mapTimeToKeyframe(t);
state.done = t >= duration;
return state;
},
};
}
;// ./node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs
const frameloopDriver = (update) => {
const passTimestamp = ({ timestamp }) => update(timestamp);
return {
start: () => frame_frame.update(passTimestamp, true),
stop: () => cancelFrame(passTimestamp),
/**
* If we're processing this frame we can use the
* framelocked timestamp to keep things in sync.
*/
now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),
};
};
;// ./node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs
const generators = {
decay: inertia,
inertia: inertia,
tween: keyframes_keyframes,
keyframes: keyframes_keyframes,
spring: spring,
};
const percentToProgress = (percent) => percent / 100;
/**
* Animation that runs on the main thread. Designed to be WAAPI-spec in the subset of
* features we expose publically. Mostly the compatibility is to ensure visual identity
* between both WAAPI and main thread animations.
*/
class MainThreadAnimation extends BaseAnimation {
constructor(options) {
super(options);
/**
* The time at which the animation was paused.
*/
this.holdTime = null;
/**
* The time at which the animation was cancelled.
*/
this.cancelTime = null;
/**
* The current time of the animation.
*/
this.currentTime = 0;
/**
* Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.
*/
this.playbackSpeed = 1;
/**
* The state of the animation to apply when the animation is resolved. This
* allows calls to the public API to control the animation before it is resolved,
* without us having to resolve it first.
*/
this.pendingPlayState = "running";
/**
* The time at which the animation was started.
*/
this.startTime = null;
this.state = "idle";
/**
* This method is bound to the instance to fix a pattern where
* animation.stop is returned as a reference from a useEffect.
*/
this.stop = () => {
this.resolver.cancel();
this.isStopped = true;
if (this.state === "idle")
return;
this.teardown();
const { onStop } = this.options;
onStop && onStop();
};
const { name, motionValue, element, keyframes } = this.options;
const KeyframeResolver$1 = (element === null || element === void 0 ? void 0 : element.KeyframeResolver) || KeyframeResolver;
const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);
this.resolver = new KeyframeResolver$1(keyframes, onResolved, name, motionValue, element);
this.resolver.scheduleResolve();
}
flatten() {
super.flatten();
// If we've already resolved the animation, re-initialise it
if (this._resolved) {
Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));
}
}
initPlayback(keyframes$1) {
const { type = "keyframes", repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = this.options;
const generatorFactory = isGenerator(type)
? type
: generators[type] || keyframes_keyframes;
/**
* If our generator doesn't support mixing numbers, we need to replace keyframes with
* [0, 100] and then make a function that maps that to the actual keyframes.
*
* 100 is chosen instead of 1 as it works nicer with spring animations.
*/
let mapPercentToKeyframes;
let mirroredGenerator;
if (generatorFactory !== keyframes_keyframes &&
typeof keyframes$1[0] !== "number") {
if (false) {}
mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));
keyframes$1 = [0, 100];
}
const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });
/**
* If we have a mirror repeat type we need to create a second generator that outputs the
* mirrored (not reversed) animation and later ping pong between the two generators.
*/
if (repeatType === "mirror") {
mirroredGenerator = generatorFactory({
...this.options,
keyframes: [...keyframes$1].reverse(),
velocity: -velocity,
});
}
/**
* If duration is undefined and we have repeat options,
* we need to calculate a duration from the generator.
*
* We set it to the generator itself to cache the duration.
* Any timeline resolver will need to have already precalculated
* the duration by this step.
*/
if (generator.calculatedDuration === null) {
generator.calculatedDuration = calcGeneratorDuration(generator);
}
const { calculatedDuration } = generator;
const resolvedDuration = calculatedDuration + repeatDelay;
const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;
return {
generator,
mirroredGenerator,
mapPercentToKeyframes,
calculatedDuration,
resolvedDuration,
totalDuration,
};
}
onPostResolved() {
const { autoplay = true } = this.options;
this.play();
if (this.pendingPlayState === "paused" || !autoplay) {
this.pause();
}
else {
this.state = this.pendingPlayState;
}
}
tick(timestamp, sample = false) {
const { resolved } = this;
// If the animations has failed to resolve, return the final keyframe.
if (!resolved) {
const { keyframes } = this.options;
return { done: true, value: keyframes[keyframes.length - 1] };
}
const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes, calculatedDuration, totalDuration, resolvedDuration, } = resolved;
if (this.startTime === null)
return generator.next(0);
const { delay, repeat, repeatType, repeatDelay, onUpdate } = this.options;
/**
* requestAnimationFrame timestamps can come through as lower than
* the startTime as set by performance.now(). Here we prevent this,
* though in the future it could be possible to make setting startTime
* a pending operation that gets resolved here.
*/
if (this.speed > 0) {
this.startTime = Math.min(this.startTime, timestamp);
}
else if (this.speed < 0) {
this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);
}
// Update currentTime
if (sample) {
this.currentTime = timestamp;
}
else if (this.holdTime !== null) {
this.currentTime = this.holdTime;
}
else {
// Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =
// 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for
// example.
this.currentTime =
Math.round(timestamp - this.startTime) * this.speed;
}
// Rebase on delay
const timeWithoutDelay = this.currentTime - delay * (this.speed >= 0 ? 1 : -1);
const isInDelayPhase = this.speed >= 0
? timeWithoutDelay < 0
: timeWithoutDelay > totalDuration;
this.currentTime = Math.max(timeWithoutDelay, 0);
// If this animation has finished, set the current time to the total duration.
if (this.state === "finished" && this.holdTime === null) {
this.currentTime = totalDuration;
}
let elapsed = this.currentTime;
let frameGenerator = generator;
if (repeat) {
/**
* Get the current progress (0-1) of the animation. If t is >
* than duration we'll get values like 2.5 (midway through the
* third iteration)
*/
const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;
/**
* Get the current iteration (0 indexed). For instance the floor of
* 2.5 is 2.
*/
let currentIteration = Math.floor(progress);
/**
* Get the current progress of the iteration by taking the remainder
* so 2.5 is 0.5 through iteration 2
*/
let iterationProgress = progress % 1.0;
/**
* If iteration progress is 1 we count that as the end
* of the previous iteration.
*/
if (!iterationProgress && progress >= 1) {
iterationProgress = 1;
}
iterationProgress === 1 && currentIteration--;
currentIteration = Math.min(currentIteration, repeat + 1);
/**
* Reverse progress if we're not running in "normal" direction
*/
const isOddIteration = Boolean(currentIteration % 2);
if (isOddIteration) {
if (repeatType === "reverse") {
iterationProgress = 1 - iterationProgress;
if (repeatDelay) {
iterationProgress -= repeatDelay / resolvedDuration;
}
}
else if (repeatType === "mirror") {
frameGenerator = mirroredGenerator;
}
}
elapsed = clamp_clamp(0, 1, iterationProgress) * resolvedDuration;
}
/**
* If we're in negative time, set state as the initial keyframe.
* This prevents delay: x, duration: 0 animations from finishing
* instantly.
*/
const state = isInDelayPhase
? { done: false, value: keyframes[0] }
: frameGenerator.next(elapsed);
if (mapPercentToKeyframes) {
state.value = mapPercentToKeyframes(state.value);
}
let { done } = state;
if (!isInDelayPhase && calculatedDuration !== null) {
done =
this.speed >= 0
? this.currentTime >= totalDuration
: this.currentTime <= 0;
}
const isAnimationFinished = this.holdTime === null &&
(this.state === "finished" || (this.state === "running" && done));
if (isAnimationFinished && finalKeyframe !== undefined) {
state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe);
}
if (onUpdate) {
onUpdate(state.value);
}
if (isAnimationFinished) {
this.finish();
}
return state;
}
get duration() {
const { resolved } = this;
return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;
}
get time() {
return millisecondsToSeconds(this.currentTime);
}
set time(newTime) {
newTime = time_conversion_secondsToMilliseconds(newTime);
this.currentTime = newTime;
if (this.holdTime !== null || this.speed === 0) {
this.holdTime = newTime;
}
else if (this.driver) {
this.startTime = this.driver.now() - newTime / this.speed;
}
}
get speed() {
return this.playbackSpeed;
}
set speed(newSpeed) {
const hasChanged = this.playbackSpeed !== newSpeed;
this.playbackSpeed = newSpeed;
if (hasChanged) {
this.time = millisecondsToSeconds(this.currentTime);
}
}
play() {
if (!this.resolver.isScheduled) {
this.resolver.resume();
}
if (!this._resolved) {
this.pendingPlayState = "running";
return;
}
if (this.isStopped)
return;
const { driver = frameloopDriver, onPlay, startTime } = this.options;
if (!this.driver) {
this.driver = driver((timestamp) => this.tick(timestamp));
}
onPlay && onPlay();
const now = this.driver.now();
if (this.holdTime !== null) {
this.startTime = now - this.holdTime;
}
else if (!this.startTime) {
this.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
}
else if (this.state === "finished") {
this.startTime = now;
}
if (this.state === "finished") {
this.updateFinishedPromise();
}
this.cancelTime = this.startTime;
this.holdTime = null;
/**
* Set playState to running only after we've used it in
* the previous logic.
*/
this.state = "running";
this.driver.start();
}
pause() {
var _a;
if (!this._resolved) {
this.pendingPlayState = "paused";
return;
}
this.state = "paused";
this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;
}
complete() {
if (this.state !== "running") {
this.play();
}
this.pendingPlayState = this.state = "finished";
this.holdTime = null;
}
finish() {
this.teardown();
this.state = "finished";
const { onComplete } = this.options;
onComplete && onComplete();
}
cancel() {
if (this.cancelTime !== null) {
this.tick(this.cancelTime);
}
this.teardown();
this.updateFinishedPromise();
}
teardown() {
this.state = "idle";
this.stopDriver();
this.resolveFinishedPromise();
this.updateFinishedPromise();
this.startTime = this.cancelTime = null;
this.resolver.cancel();
}
stopDriver() {
if (!this.driver)
return;
this.driver.stop();
this.driver = undefined;
}
sample(time) {
this.startTime = 0;
return this.tick(time, true);
}
}
// Legacy interface
function animateValue(options) {
return new MainThreadAnimation(options);
}
;// ./node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs
/**
* A list of values that can be hardware-accelerated.
*/
const acceleratedValues = new Set([
"opacity",
"clipPath",
"filter",
"transform",
// TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved
// or until we implement support for linear() easing.
// "background-color"
]);
;// ./node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs
function startWaapiAnimation(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = "loop", ease = "easeInOut", times, } = {}) {
const keyframeOptions = { [valueName]: keyframes };
if (times)
keyframeOptions.offset = times;
const easing = easing_mapEasingToNativeEasing(ease, duration);
/**
* If this is an easing array, apply to keyframes, not animation as a whole
*/
if (Array.isArray(easing))
keyframeOptions.easing = easing;
return element.animate(keyframeOptions, {
delay,
duration,
easing: !Array.isArray(easing) ? easing : "linear",
fill: "both",
iterations: repeat + 1,
direction: repeatType === "reverse" ? "alternate" : "normal",
});
}
;// ./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-waapi.mjs
const supportsWaapi = /*@__PURE__*/ memo(() => Object.hasOwnProperty.call(Element.prototype, "animate"));
;// ./node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs
/**
* 10ms is chosen here as it strikes a balance between smooth
* results (more than one keyframe per frame at 60fps) and
* keyframe quantity.
*/
const sampleDelta = 10; //ms
/**
* Implement a practical max duration for keyframe generation
* to prevent infinite loops
*/
const maxDuration = 20000;
/**
* Check if an animation can run natively via WAAPI or requires pregenerated keyframes.
* WAAPI doesn't support spring or function easings so we run these as JS animation before
* handing off.
*/
function requiresPregeneratedKeyframes(options) {
return (isGenerator(options.type) ||
options.type === "spring" ||
!isWaapiSupportedEasing(options.ease));
}
function pregenerateKeyframes(keyframes, options) {
/**
* Create a main-thread animation to pregenerate keyframes.
* We sample this at regular intervals to generate keyframes that we then
* linearly interpolate between.
*/
const sampleAnimation = new MainThreadAnimation({
...options,
keyframes,
repeat: 0,
delay: 0,
isGenerator: true,
});
let state = { done: false, value: keyframes[0] };
const pregeneratedKeyframes = [];
/**
* Bail after 20 seconds of pre-generated keyframes as it's likely
* we're heading for an infinite loop.
*/
let t = 0;
while (!state.done && t < maxDuration) {
state = sampleAnimation.sample(t);
pregeneratedKeyframes.push(state.value);
t += sampleDelta;
}
return {
times: undefined,
keyframes: pregeneratedKeyframes,
duration: t - sampleDelta,
ease: "linear",
};
}
const unsupportedEasingFunctions = {
anticipate: anticipate,
backInOut: backInOut,
circInOut: circInOut,
};
function isUnsupportedEase(key) {
return key in unsupportedEasingFunctions;
}
class AcceleratedAnimation extends BaseAnimation {
constructor(options) {
super(options);
const { name, motionValue, element, keyframes } = this.options;
this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue, element);
this.resolver.scheduleResolve();
}
initPlayback(keyframes, finalKeyframe) {
let { duration = 300, times, ease, type, motionValue, name, startTime, } = this.options;
/**
* If element has since been unmounted, return false to indicate
* the animation failed to initialised.
*/
if (!motionValue.owner || !motionValue.owner.current) {
return false;
}
/**
* If the user has provided an easing function name that isn't supported
* by WAAPI (like "anticipate"), we need to provide the corressponding
* function. This will later get converted to a linear() easing function.
*/
if (typeof ease === "string" &&
supportsLinearEasing() &&
isUnsupportedEase(ease)) {
ease = unsupportedEasingFunctions[ease];
}
/**
* If this animation needs pre-generated keyframes then generate.
*/
if (requiresPregeneratedKeyframes(this.options)) {
const { onComplete, onUpdate, motionValue, element, ...options } = this.options;
const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);
keyframes = pregeneratedAnimation.keyframes;
// If this is a very short animation, ensure we have
// at least two keyframes to animate between as older browsers
// can't animate between a single keyframe.
if (keyframes.length === 1) {
keyframes[1] = keyframes[0];
}
duration = pregeneratedAnimation.duration;
times = pregeneratedAnimation.times;
ease = pregeneratedAnimation.ease;
type = "keyframes";
}
const animation = startWaapiAnimation(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });
// Override the browser calculated startTime with one synchronised to other JS
// and WAAPI animations starting this event loop.
animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();
if (this.pendingTimeline) {
attachTimeline(animation, this.pendingTimeline);
this.pendingTimeline = undefined;
}
else {
/**
* Prefer the `onfinish` prop as it's more widely supported than
* the `finished` promise.
*
* Here, we synchronously set the provided MotionValue to the end
* keyframe. If we didn't, when the WAAPI animation is finished it would
* be removed from the element which would then revert to its old styles.
*/
animation.onfinish = () => {
const { onComplete } = this.options;
motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));
onComplete && onComplete();
this.cancel();
this.resolveFinishedPromise();
};
}
return {
animation,
duration,
times,
type,
ease,
keyframes: keyframes,
};
}
get duration() {
const { resolved } = this;
if (!resolved)
return 0;
const { duration } = resolved;
return millisecondsToSeconds(duration);
}
get time() {
const { resolved } = this;
if (!resolved)
return 0;
const { animation } = resolved;
return millisecondsToSeconds(animation.currentTime || 0);
}
set time(newTime) {
const { resolved } = this;
if (!resolved)
return;
const { animation } = resolved;
animation.currentTime = time_conversion_secondsToMilliseconds(newTime);
}
get speed() {
const { resolved } = this;
if (!resolved)
return 1;
const { animation } = resolved;
return animation.playbackRate;
}
set speed(newSpeed) {
const { resolved } = this;
if (!resolved)
return;
const { animation } = resolved;
animation.playbackRate = newSpeed;
}
get state() {
const { resolved } = this;
if (!resolved)
return "idle";
const { animation } = resolved;
return animation.playState;
}
get startTime() {
const { resolved } = this;
if (!resolved)
return null;
const { animation } = resolved;
// Coerce to number as TypeScript incorrectly types this
// as CSSNumberish
return animation.startTime;
}
/**
* Replace the default DocumentTimeline with another AnimationTimeline.
* Currently used for scroll animations.
*/
attachTimeline(timeline) {
if (!this._resolved) {
this.pendingTimeline = timeline;
}
else {
const { resolved } = this;
if (!resolved)
return noop_noop;
const { animation } = resolved;
attachTimeline(animation, timeline);
}
return noop_noop;
}
play() {
if (this.isStopped)
return;
const { resolved } = this;
if (!resolved)
return;
const { animation } = resolved;
if (animation.playState === "finished") {
this.updateFinishedPromise();
}
animation.play();
}
pause() {
const { resolved } = this;
if (!resolved)
return;
const { animation } = resolved;
animation.pause();
}
stop() {
this.resolver.cancel();
this.isStopped = true;
if (this.state === "idle")
return;
this.resolveFinishedPromise();
this.updateFinishedPromise();
const { resolved } = this;
if (!resolved)
return;
const { animation, keyframes, duration, type, ease, times } = resolved;
if (animation.playState === "idle" ||
animation.playState === "finished") {
return;
}
/**
* WAAPI doesn't natively have any interruption capabilities.
*
* Rather than read commited styles back out of the DOM, we can
* create a renderless JS animation and sample it twice to calculate
* its current value, "previous" value, and therefore allow
* Motion to calculate velocity for any subsequent animation.
*/
if (this.time) {
const { motionValue, onUpdate, onComplete, element, ...options } = this.options;
const sampleAnimation = new MainThreadAnimation({
...options,
keyframes,
duration,
type,
ease,
times,
isGenerator: true,
});
const sampleTime = time_conversion_secondsToMilliseconds(this.time);
motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);
}
const { onStop } = this.options;
onStop && onStop();
this.cancel();
}
complete() {
const { resolved } = this;
if (!resolved)
return;
resolved.animation.finish();
}
cancel() {
const { resolved } = this;
if (!resolved)
return;
resolved.animation.cancel();
}
static supports(options) {
const { motionValue, name, repeatDelay, repeatType, damping, type } = options;
if (!motionValue ||
!motionValue.owner ||
!(motionValue.owner.current instanceof HTMLElement)) {
return false;
}
const { onUpdate, transformTemplate } = motionValue.owner.getProps();
return (supportsWaapi() &&
name &&
acceleratedValues.has(name) &&
/**
* If we're outputting values to onUpdate then we can't use WAAPI as there's
* no way to read the value from WAAPI every frame.
*/
!onUpdate &&
!transformTemplate &&
!repeatDelay &&
repeatType !== "mirror" &&
damping !== 0 &&
type !== "inertia");
}
}
;// ./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs
const underDampedSpring = {
type: "spring",
stiffness: 500,
damping: 25,
restSpeed: 10,
};
const criticallyDampedSpring = (target) => ({
type: "spring",
stiffness: 550,
damping: target === 0 ? 2 * Math.sqrt(550) : 30,
restSpeed: 10,
});
const keyframesTransition = {
type: "keyframes",
duration: 0.8,
};
/**
* Default easing curve is a slightly shallower version of
* the default browser easing curve.
*/
const ease = {
type: "keyframes",
ease: [0.25, 0.1, 0.35, 1],
duration: 0.3,
};
const getDefaultTransition = (valueKey, { keyframes }) => {
if (keyframes.length > 2) {
return keyframesTransition;
}
else if (transformProps.has(valueKey)) {
return valueKey.startsWith("scale")
? criticallyDampedSpring(keyframes[1])
: underDampedSpring;
}
return ease;
};
;// ./node_modules/framer-motion/dist/es/animation/utils/is-transition-defined.mjs
/**
* Decide whether a transition is defined on a given Transition.
* This filters out orchestration options and returns true
* if any options are left.
*/
function isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {
return !!Object.keys(transition).length;
}
;// ./node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs
const animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
const valueTransition = get_value_transition_getValueTransition(transition, name) || {};
/**
* Most transition values are currently completely overwritten by value-specific
* transitions. In the future it'd be nicer to blend these transitions. But for now
* delay actually does inherit from the root transition if not value-specific.
*/
const delay = valueTransition.delay || transition.delay || 0;
/**
* Elapsed isn't a public transition option but can be passed through from
* optimized appear effects in milliseconds.
*/
let { elapsed = 0 } = transition;
elapsed = elapsed - time_conversion_secondsToMilliseconds(delay);
let options = {
keyframes: Array.isArray(target) ? target : [null, target],
ease: "easeOut",
velocity: value.getVelocity(),
...valueTransition,
delay: -elapsed,
onUpdate: (v) => {
value.set(v);
valueTransition.onUpdate && valueTransition.onUpdate(v);
},
onComplete: () => {
onComplete();
valueTransition.onComplete && valueTransition.onComplete();
},
name,
motionValue: value,
element: isHandoff ? undefined : element,
};
/**
* If there's no transition defined for this value, we can generate
* unqiue transition settings for this value.
*/
if (!isTransitionDefined(valueTransition)) {
options = {
...options,
...getDefaultTransition(name, options),
};
}
/**
* Both WAAPI and our internal animation functions use durations
* as defined by milliseconds, while our external API defines them
* as seconds.
*/
if (options.duration) {
options.duration = time_conversion_secondsToMilliseconds(options.duration);
}
if (options.repeatDelay) {
options.repeatDelay = time_conversion_secondsToMilliseconds(options.repeatDelay);
}
if (options.from !== undefined) {
options.keyframes[0] = options.from;
}
let shouldSkip = false;
if (options.type === false ||
(options.duration === 0 && !options.repeatDelay)) {
options.duration = 0;
if (options.delay === 0) {
shouldSkip = true;
}
}
if (instantAnimationState.current ||
MotionGlobalConfig.skipAnimations) {
shouldSkip = true;
options.duration = 0;
options.delay = 0;
}
/**
* If we can or must skip creating the animation, and apply only
* the final keyframe, do so. We also check once keyframes are resolved but
* this early check prevents the need to create an animation at all.
*/
if (shouldSkip && !isHandoff && value.get() !== undefined) {
const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);
if (finalKeyframe !== undefined) {
frame_frame.update(() => {
options.onUpdate(finalKeyframe);
options.onComplete();
});
// We still want to return some animation controls here rather
// than returning undefined
return new GroupPlaybackControls([]);
}
}
/**
* Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via
* WAAPI. Therefore, this animation must be JS to ensure it runs "under" the
* optimised animation.
*/
if (!isHandoff && AcceleratedAnimation.supports(options)) {
return new AcceleratedAnimation(options);
}
else {
return new MainThreadAnimation(options);
}
};
;// ./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs
/**
* Decide whether we should block this animation. Previously, we achieved this
* just by checking whether the key was listed in protectedKeys, but this
* posed problems if an animation was triggered by afterChildren and protectedKeys
* had been set to true in the meantime.
*/
function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
needsAnimating[key] = false;
return shouldBlock;
}
function animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {
var _a;
let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;
if (transitionOverride)
transition = transitionOverride;
const animations = [];
const animationTypeState = type &&
visualElement.animationState &&
visualElement.animationState.getState()[type];
for (const key in target) {
const value = visualElement.getValue(key, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);
const valueTarget = target[key];
if (valueTarget === undefined ||
(animationTypeState &&
shouldBlockAnimation(animationTypeState, key))) {
continue;
}
const valueTransition = {
delay,
...get_value_transition_getValueTransition(transition || {}, key),
};
/**
* If this is the first time a value is being animated, check
* to see if we're handling off from an existing animation.
*/
let isHandoff = false;
if (window.MotionHandoffAnimation) {
const appearId = getOptimisedAppearId(visualElement);
if (appearId) {
const startTime = window.MotionHandoffAnimation(appearId, key, frame_frame);
if (startTime !== null) {
valueTransition.startTime = startTime;
isHandoff = true;
}
}
}
addValueToWillChange(visualElement, key);
value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && positionalKeys.has(key)
? { type: false }
: valueTransition, visualElement, isHandoff));
const animation = value.animation;
if (animation) {
animations.push(animation);
}
}
if (transitionEnd) {
Promise.all(animations).then(() => {
frame_frame.update(() => {
transitionEnd && setTarget(visualElement, transitionEnd);
});
});
}
return animations;
}
;// ./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs
function animateVariant(visualElement, variant, options = {}) {
var _a;
const resolved = resolveVariant(visualElement, variant, options.type === "exit"
? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom
: undefined);
let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};
if (options.transitionOverride) {
transition = options.transitionOverride;
}
/**
* If we have a variant, create a callback that runs it as an animation.
* Otherwise, we resolve a Promise immediately for a composable no-op.
*/
const getAnimation = resolved
? () => Promise.all(animateTarget(visualElement, resolved, options))
: () => Promise.resolve();
/**
* If we have children, create a callback that runs all their animations.
* Otherwise, we resolve a Promise immediately for a composable no-op.
*/
const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size
? (forwardDelay = 0) => {
const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;
return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);
}
: () => Promise.resolve();
/**
* If the transition explicitly defines a "when" option, we need to resolve either
* this animation or all children animations before playing the other.
*/
const { when } = transition;
if (when) {
const [first, last] = when === "beforeChildren"
? [getAnimation, getChildAnimations]
: [getChildAnimations, getAnimation];
return first().then(() => last());
}
else {
return Promise.all([getAnimation(), getChildAnimations(options.delay)]);
}
}
function animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {
const animations = [];
const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;
const generateStaggerDuration = staggerDirection === 1
? (i = 0) => i * staggerChildren
: (i = 0) => maxStaggerDuration - i * staggerChildren;
Array.from(visualElement.variantChildren)
.sort(sortByTreeOrder)
.forEach((child, i) => {
child.notify("AnimationStart", variant);
animations.push(animateVariant(child, variant, {
...options,
delay: delayChildren + generateStaggerDuration(i),
}).then(() => child.notify("AnimationComplete", variant)));
});
return Promise.all(animations);
}
function sortByTreeOrder(a, b) {
return a.sortNodePosition(b);
}
;// ./node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs
function animateVisualElement(visualElement, definition, options = {}) {
visualElement.notify("AnimationStart", definition);
let animation;
if (Array.isArray(definition)) {
const animations = definition.map((variant) => animateVariant(visualElement, variant, options));
animation = Promise.all(animations);
}
else if (typeof definition === "string") {
animation = animateVariant(visualElement, definition, options);
}
else {
const resolvedDefinition = typeof definition === "function"
? resolveVariant(visualElement, definition, options.custom)
: definition;
animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));
}
return animation.then(() => {
visualElement.notify("AnimationComplete", definition);
});
}
;// ./node_modules/framer-motion/dist/es/render/utils/get-variant-context.mjs
const numVariantProps = variantProps.length;
function getVariantContext(visualElement) {
if (!visualElement)
return undefined;
if (!visualElement.isControllingVariants) {
const context = visualElement.parent
? getVariantContext(visualElement.parent) || {}
: {};
if (visualElement.props.initial !== undefined) {
context.initial = visualElement.props.initial;
}
return context;
}
const context = {};
for (let i = 0; i < numVariantProps; i++) {
const name = variantProps[i];
const prop = visualElement.props[name];
if (isVariantLabel(prop) || prop === false) {
context[name] = prop;
}
}
return context;
}
;// ./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs
const reversePriorityOrder = [...variantPriorityOrder].reverse();
const numAnimationTypes = variantPriorityOrder.length;
function animateList(visualElement) {
return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));
}
function createAnimationState(visualElement) {
let animate = animateList(visualElement);
let state = createState();
let isInitialRender = true;
/**
* This function will be used to reduce the animation definitions for
* each active animation type into an object of resolved values for it.
*/
const buildResolvedTypeValues = (type) => (acc, definition) => {
var _a;
const resolved = resolveVariant(visualElement, definition, type === "exit"
? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom
: undefined);
if (resolved) {
const { transition, transitionEnd, ...target } = resolved;
acc = { ...acc, ...target, ...transitionEnd };
}
return acc;
};
/**
* This just allows us to inject mocked animation functions
* @internal
*/
function setAnimateFunction(makeAnimator) {
animate = makeAnimator(visualElement);
}
/**
* When we receive new props, we need to:
* 1. Create a list of protected keys for each type. This is a directory of
* value keys that are currently being "handled" by types of a higher priority
* so that whenever an animation is played of a given type, these values are
* protected from being animated.
* 2. Determine if an animation type needs animating.
* 3. Determine if any values have been removed from a type and figure out
* what to animate those to.
*/
function animateChanges(changedActiveType) {
const { props } = visualElement;
const context = getVariantContext(visualElement.parent) || {};
/**
* A list of animations that we'll build into as we iterate through the animation
* types. This will get executed at the end of the function.
*/
const animations = [];
/**
* Keep track of which values have been removed. Then, as we hit lower priority
* animation types, we can check if they contain removed values and animate to that.
*/
const removedKeys = new Set();
/**
* A dictionary of all encountered keys. This is an object to let us build into and
* copy it without iteration. Each time we hit an animation type we set its protected
* keys - the keys its not allowed to animate - to the latest version of this object.
*/
let encounteredKeys = {};
/**
* If a variant has been removed at a given index, and this component is controlling
* variant animations, we want to ensure lower-priority variants are forced to animate.
*/
let removedVariantIndex = Infinity;
/**
* Iterate through all animation types in reverse priority order. For each, we want to
* detect which values it's handling and whether or not they've changed (and therefore
* need to be animated). If any values have been removed, we want to detect those in
* lower priority props and flag for animation.
*/
for (let i = 0; i < numAnimationTypes; i++) {
const type = reversePriorityOrder[i];
const typeState = state[type];
const prop = props[type] !== undefined
? props[type]
: context[type];
const propIsVariant = isVariantLabel(prop);
/**
* If this type has *just* changed isActive status, set activeDelta
* to that status. Otherwise set to null.
*/
const activeDelta = type === changedActiveType ? typeState.isActive : null;
if (activeDelta === false)
removedVariantIndex = i;
/**
* If this prop is an inherited variant, rather than been set directly on the
* component itself, we want to make sure we allow the parent to trigger animations.
*
* TODO: Can probably change this to a !isControllingVariants check
*/
let isInherited = prop === context[type] &&
prop !== props[type] &&
propIsVariant;
/**
*
*/
if (isInherited &&
isInitialRender &&
visualElement.manuallyAnimateOnMount) {
isInherited = false;
}
/**
* Set all encountered keys so far as the protected keys for this type. This will
* be any key that has been animated or otherwise handled by active, higher-priortiy types.
*/
typeState.protectedKeys = { ...encounteredKeys };
// Check if we can skip analysing this prop early
if (
// If it isn't active and hasn't *just* been set as inactive
(!typeState.isActive && activeDelta === null) ||
// If we didn't and don't have any defined prop for this animation type
(!prop && !typeState.prevProp) ||
// Or if the prop doesn't define an animation
isAnimationControls(prop) ||
typeof prop === "boolean") {
continue;
}
/**
* As we go look through the values defined on this type, if we detect
* a changed value or a value that was removed in a higher priority, we set
* this to true and add this prop to the animation list.
*/
const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);
let shouldAnimateType = variantDidChange ||
// If we're making this variant active, we want to always make it active
(type === changedActiveType &&
typeState.isActive &&
!isInherited &&
propIsVariant) ||
// If we removed a higher-priority variant (i is in reverse order)
(i > removedVariantIndex && propIsVariant);
let handledRemovedValues = false;
/**
* As animations can be set as variant lists, variants or target objects, we
* coerce everything to an array if it isn't one already
*/
const definitionList = Array.isArray(prop) ? prop : [prop];
/**
* Build an object of all the resolved values. We'll use this in the subsequent
* animateChanges calls to determine whether a value has changed.
*/
let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});
if (activeDelta === false)
resolvedValues = {};
/**
* Now we need to loop through all the keys in the prev prop and this prop,
* and decide:
* 1. If the value has changed, and needs animating
* 2. If it has been removed, and needs adding to the removedKeys set
* 3. If it has been removed in a higher priority type and needs animating
* 4. If it hasn't been removed in a higher priority but hasn't changed, and
* needs adding to the type's protectedKeys list.
*/
const { prevResolvedValues = {} } = typeState;
const allKeys = {
...prevResolvedValues,
...resolvedValues,
};
const markToAnimate = (key) => {
shouldAnimateType = true;
if (removedKeys.has(key)) {
handledRemovedValues = true;
removedKeys.delete(key);
}
typeState.needsAnimating[key] = true;
const motionValue = visualElement.getValue(key);
if (motionValue)
motionValue.liveStyle = false;
};
for (const key in allKeys) {
const next = resolvedValues[key];
const prev = prevResolvedValues[key];
// If we've already handled this we can just skip ahead
if (encounteredKeys.hasOwnProperty(key))
continue;
/**
* If the value has changed, we probably want to animate it.
*/
let valueHasChanged = false;
if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {
valueHasChanged = !shallowCompare(next, prev);
}
else {
valueHasChanged = next !== prev;
}
if (valueHasChanged) {
if (next !== undefined && next !== null) {
// If next is defined and doesn't equal prev, it needs animating
markToAnimate(key);
}
else {
// If it's undefined, it's been removed.
removedKeys.add(key);
}
}
else if (next !== undefined && removedKeys.has(key)) {
/**
* If next hasn't changed and it isn't undefined, we want to check if it's
* been removed by a higher priority
*/
markToAnimate(key);
}
else {
/**
* If it hasn't changed, we add it to the list of protected values
* to ensure it doesn't get animated.
*/
typeState.protectedKeys[key] = true;
}
}
/**
* Update the typeState so next time animateChanges is called we can compare the
* latest prop and resolvedValues to these.
*/
typeState.prevProp = prop;
typeState.prevResolvedValues = resolvedValues;
/**
*
*/
if (typeState.isActive) {
encounteredKeys = { ...encounteredKeys, ...resolvedValues };
}
if (isInitialRender && visualElement.blockInitialAnimation) {
shouldAnimateType = false;
}
/**
* If this is an inherited prop we want to skip this animation
* unless the inherited variants haven't changed on this render.
*/
const willAnimateViaParent = isInherited && variantDidChange;
const needsAnimating = !willAnimateViaParent || handledRemovedValues;
if (shouldAnimateType && needsAnimating) {
animations.push(...definitionList.map((animation) => ({
animation: animation,
options: { type },
})));
}
}
/**
* If there are some removed value that haven't been dealt with,
* we need to create a new animation that falls back either to the value
* defined in the style prop, or the last read value.
*/
if (removedKeys.size) {
const fallbackAnimation = {};
removedKeys.forEach((key) => {
const fallbackTarget = visualElement.getBaseTarget(key);
const motionValue = visualElement.getValue(key);
if (motionValue)
motionValue.liveStyle = true;
// @ts-expect-error - @mattgperry to figure if we should do something here
fallbackAnimation[key] = fallbackTarget !== null && fallbackTarget !== void 0 ? fallbackTarget : null;
});
animations.push({ animation: fallbackAnimation });
}
let shouldAnimate = Boolean(animations.length);
if (isInitialRender &&
(props.initial === false || props.initial === props.animate) &&
!visualElement.manuallyAnimateOnMount) {
shouldAnimate = false;
}
isInitialRender = false;
return shouldAnimate ? animate(animations) : Promise.resolve();
}
/**
* Change whether a certain animation type is active.
*/
function setActive(type, isActive) {
var _a;
// If the active state hasn't changed, we can safely do nothing here
if (state[type].isActive === isActive)
return Promise.resolve();
// Propagate active change to children
(_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });
state[type].isActive = isActive;
const animations = animateChanges(type);
for (const key in state) {
state[key].protectedKeys = {};
}
return animations;
}
return {
animateChanges,
setActive,
setAnimateFunction,
getState: () => state,
reset: () => {
state = createState();
isInitialRender = true;
},
};
}
function checkVariantsDidChange(prev, next) {
if (typeof next === "string") {
return next !== prev;
}
else if (Array.isArray(next)) {
return !shallowCompare(next, prev);
}
return false;
}
function createTypeState(isActive = false) {
return {
isActive,
protectedKeys: {},
needsAnimating: {},
prevResolvedValues: {},
};
}
function createState() {
return {
animate: createTypeState(true),
whileInView: createTypeState(),
whileHover: createTypeState(),
whileTap: createTypeState(),
whileDrag: createTypeState(),
whileFocus: createTypeState(),
exit: createTypeState(),
};
}
;// ./node_modules/framer-motion/dist/es/motion/features/Feature.mjs
class Feature {
constructor(node) {
this.isMounted = false;
this.node = node;
}
update() { }
}
;// ./node_modules/framer-motion/dist/es/motion/features/animation/index.mjs
class AnimationFeature extends Feature {
/**
* We dynamically generate the AnimationState manager as it contains a reference
* to the underlying animation library. We only want to load that if we load this,
* so people can optionally code split it out using the `m` component.
*/
constructor(node) {
super(node);
node.animationState || (node.animationState = createAnimationState(node));
}
updateAnimationControlsSubscription() {
const { animate } = this.node.getProps();
if (isAnimationControls(animate)) {
this.unmountControls = animate.subscribe(this.node);
}
}
/**
* Subscribe any provided AnimationControls to the component's VisualElement
*/
mount() {
this.updateAnimationControlsSubscription();
}
update() {
const { animate } = this.node.getProps();
const { animate: prevAnimate } = this.node.prevProps || {};
if (animate !== prevAnimate) {
this.updateAnimationControlsSubscription();
}
}
unmount() {
var _a;
this.node.animationState.reset();
(_a = this.unmountControls) === null || _a === void 0 ? void 0 : _a.call(this);
}
}
;// ./node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs
let id = 0;
class ExitAnimationFeature extends Feature {
constructor() {
super(...arguments);
this.id = id++;
}
update() {
if (!this.node.presenceContext)
return;
const { isPresent, onExitComplete } = this.node.presenceContext;
const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};
if (!this.node.animationState || isPresent === prevIsPresent) {
return;
}
const exitAnimation = this.node.animationState.setActive("exit", !isPresent);
if (onExitComplete && !isPresent) {
exitAnimation.then(() => onExitComplete(this.id));
}
}
mount() {
const { register } = this.node.presenceContext || {};
if (register) {
this.unmount = register(this.id);
}
}
unmount() { }
}
;// ./node_modules/framer-motion/dist/es/motion/features/animations.mjs
const animations = {
animation: {
Feature: AnimationFeature,
},
exit: {
Feature: ExitAnimationFeature,
},
};
;// ./node_modules/framer-motion/dist/es/events/add-dom-event.mjs
function addDomEvent(target, eventName, handler, options = { passive: true }) {
target.addEventListener(eventName, handler, options);
return () => target.removeEventListener(eventName, handler);
}
;// ./node_modules/framer-motion/dist/es/events/event-info.mjs
function extractEventInfo(event) {
return {
point: {
x: event.pageX,
y: event.pageY,
},
};
}
const addPointerInfo = (handler) => {
return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));
};
;// ./node_modules/framer-motion/dist/es/events/add-pointer-event.mjs
function addPointerEvent(target, eventName, handler, options) {
return addDomEvent(target, eventName, addPointerInfo(handler), options);
}
;// ./node_modules/framer-motion/dist/es/utils/distance.mjs
const distance = (a, b) => Math.abs(a - b);
function distance2D(a, b) {
// Multi-dimensional
const xDelta = distance(a.x, b.x);
const yDelta = distance(a.y, b.y);
return Math.sqrt(xDelta ** 2 + yDelta ** 2);
}
;// ./node_modules/framer-motion/dist/es/gestures/pan/PanSession.mjs
/**
* @internal
*/
class PanSession {
constructor(event, handlers, { transformPagePoint, contextWindow, dragSnapToOrigin = false, } = {}) {
/**
* @internal
*/
this.startEvent = null;
/**
* @internal
*/
this.lastMoveEvent = null;
/**
* @internal
*/
this.lastMoveEventInfo = null;
/**
* @internal
*/
this.handlers = {};
/**
* @internal
*/
this.contextWindow = window;
this.updatePoint = () => {
if (!(this.lastMoveEvent && this.lastMoveEventInfo))
return;
const info = getPanInfo(this.lastMoveEventInfo, this.history);
const isPanStarted = this.startEvent !== null;
// Only start panning if the offset is larger than 3 pixels. If we make it
// any larger than this we'll want to reset the pointer history
// on the first update to avoid visual snapping to the cursoe.
const isDistancePastThreshold = distance2D(info.offset, { x: 0, y: 0 }) >= 3;
if (!isPanStarted && !isDistancePastThreshold)
return;
const { point } = info;
const { timestamp } = frameData;
this.history.push({ ...point, timestamp });
const { onStart, onMove } = this.handlers;
if (!isPanStarted) {
onStart && onStart(this.lastMoveEvent, info);
this.startEvent = this.lastMoveEvent;
}
onMove && onMove(this.lastMoveEvent, info);
};
this.handlePointerMove = (event, info) => {
this.lastMoveEvent = event;
this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);
// Throttle mouse move event to once per frame
frame_frame.update(this.updatePoint, true);
};
this.handlePointerUp = (event, info) => {
this.end();
const { onEnd, onSessionEnd, resumeAnimation } = this.handlers;
if (this.dragSnapToOrigin)
resumeAnimation && resumeAnimation();
if (!(this.lastMoveEvent && this.lastMoveEventInfo))
return;
const panInfo = getPanInfo(event.type === "pointercancel"
? this.lastMoveEventInfo
: transformPoint(info, this.transformPagePoint), this.history);
if (this.startEvent && onEnd) {
onEnd(event, panInfo);
}
onSessionEnd && onSessionEnd(event, panInfo);
};
// If we have more than one touch, don't start detecting this gesture
if (!isPrimaryPointer(event))
return;
this.dragSnapToOrigin = dragSnapToOrigin;
this.handlers = handlers;
this.transformPagePoint = transformPagePoint;
this.contextWindow = contextWindow || window;
const info = extractEventInfo(event);
const initialInfo = transformPoint(info, this.transformPagePoint);
const { point } = initialInfo;
const { timestamp } = frameData;
this.history = [{ ...point, timestamp }];
const { onSessionStart } = handlers;
onSessionStart &&
onSessionStart(event, getPanInfo(initialInfo, this.history));
this.removeListeners = pipe(addPointerEvent(this.contextWindow, "pointermove", this.handlePointerMove), addPointerEvent(this.contextWindow, "pointerup", this.handlePointerUp), addPointerEvent(this.contextWindow, "pointercancel", this.handlePointerUp));
}
updateHandlers(handlers) {
this.handlers = handlers;
}
end() {
this.removeListeners && this.removeListeners();
cancelFrame(this.updatePoint);
}
}
function transformPoint(info, transformPagePoint) {
return transformPagePoint ? { point: transformPagePoint(info.point) } : info;
}
function subtractPoint(a, b) {
return { x: a.x - b.x, y: a.y - b.y };
}
function getPanInfo({ point }, history) {
return {
point,
delta: subtractPoint(point, lastDevicePoint(history)),
offset: subtractPoint(point, startDevicePoint(history)),
velocity: getVelocity(history, 0.1),
};
}
function startDevicePoint(history) {
return history[0];
}
function lastDevicePoint(history) {
return history[history.length - 1];
}
function getVelocity(history, timeDelta) {
if (history.length < 2) {
return { x: 0, y: 0 };
}
let i = history.length - 1;
let timestampedPoint = null;
const lastPoint = lastDevicePoint(history);
while (i >= 0) {
timestampedPoint = history[i];
if (lastPoint.timestamp - timestampedPoint.timestamp >
time_conversion_secondsToMilliseconds(timeDelta)) {
break;
}
i--;
}
if (!timestampedPoint) {
return { x: 0, y: 0 };
}
const time = millisecondsToSeconds(lastPoint.timestamp - timestampedPoint.timestamp);
if (time === 0) {
return { x: 0, y: 0 };
}
const currentVelocity = {
x: (lastPoint.x - timestampedPoint.x) / time,
y: (lastPoint.y - timestampedPoint.y) / time,
};
if (currentVelocity.x === Infinity) {
currentVelocity.x = 0;
}
if (currentVelocity.y === Infinity) {
currentVelocity.y = 0;
}
return currentVelocity;
}
;// ./node_modules/framer-motion/dist/es/utils/is-ref-object.mjs
function isRefObject(ref) {
return (ref &&
typeof ref === "object" &&
Object.prototype.hasOwnProperty.call(ref, "current"));
}
;// ./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs
const SCALE_PRECISION = 0.0001;
const SCALE_MIN = 1 - SCALE_PRECISION;
const SCALE_MAX = 1 + SCALE_PRECISION;
const TRANSLATE_PRECISION = 0.01;
const TRANSLATE_MIN = 0 - TRANSLATE_PRECISION;
const TRANSLATE_MAX = 0 + TRANSLATE_PRECISION;
function calcLength(axis) {
return axis.max - axis.min;
}
function isNear(value, target, maxDistance) {
return Math.abs(value - target) <= maxDistance;
}
function calcAxisDelta(delta, source, target, origin = 0.5) {
delta.origin = origin;
delta.originPoint = mixNumber(source.min, source.max, delta.origin);
delta.scale = calcLength(target) / calcLength(source);
delta.translate =
mixNumber(target.min, target.max, delta.origin) - delta.originPoint;
if ((delta.scale >= SCALE_MIN && delta.scale <= SCALE_MAX) ||
isNaN(delta.scale)) {
delta.scale = 1.0;
}
if ((delta.translate >= TRANSLATE_MIN &&
delta.translate <= TRANSLATE_MAX) ||
isNaN(delta.translate)) {
delta.translate = 0.0;
}
}
function calcBoxDelta(delta, source, target, origin) {
calcAxisDelta(delta.x, source.x, target.x, origin ? origin.originX : undefined);
calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : undefined);
}
function calcRelativeAxis(target, relative, parent) {
target.min = parent.min + relative.min;
target.max = target.min + calcLength(relative);
}
function calcRelativeBox(target, relative, parent) {
calcRelativeAxis(target.x, relative.x, parent.x);
calcRelativeAxis(target.y, relative.y, parent.y);
}
function calcRelativeAxisPosition(target, layout, parent) {
target.min = layout.min - parent.min;
target.max = target.min + calcLength(layout);
}
function calcRelativePosition(target, layout, parent) {
calcRelativeAxisPosition(target.x, layout.x, parent.x);
calcRelativeAxisPosition(target.y, layout.y, parent.y);
}
;// ./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs
/**
* Apply constraints to a point. These constraints are both physical along an
* axis, and an elastic factor that determines how much to constrain the point
* by if it does lie outside the defined parameters.
*/
function applyConstraints(point, { min, max }, elastic) {
if (min !== undefined && point < min) {
// If we have a min point defined, and this is outside of that, constrain
point = elastic
? mixNumber(min, point, elastic.min)
: Math.max(point, min);
}
else if (max !== undefined && point > max) {
// If we have a max point defined, and this is outside of that, constrain
point = elastic
? mixNumber(max, point, elastic.max)
: Math.min(point, max);
}
return point;
}
/**
* Calculate constraints in terms of the viewport when defined relatively to the
* measured axis. This is measured from the nearest edge, so a max constraint of 200
* on an axis with a max value of 300 would return a constraint of 500 - axis length
*/
function calcRelativeAxisConstraints(axis, min, max) {
return {
min: min !== undefined ? axis.min + min : undefined,
max: max !== undefined
? axis.max + max - (axis.max - axis.min)
: undefined,
};
}
/**
* Calculate constraints in terms of the viewport when
* defined relatively to the measured bounding box.
*/
function calcRelativeConstraints(layoutBox, { top, left, bottom, right }) {
return {
x: calcRelativeAxisConstraints(layoutBox.x, left, right),
y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),
};
}
/**
* Calculate viewport constraints when defined as another viewport-relative axis
*/
function calcViewportAxisConstraints(layoutAxis, constraintsAxis) {
let min = constraintsAxis.min - layoutAxis.min;
let max = constraintsAxis.max - layoutAxis.max;
// If the constraints axis is actually smaller than the layout axis then we can
// flip the constraints
if (constraintsAxis.max - constraintsAxis.min <
layoutAxis.max - layoutAxis.min) {
[min, max] = [max, min];
}
return { min, max };
}
/**
* Calculate viewport constraints when defined as another viewport-relative box
*/
function calcViewportConstraints(layoutBox, constraintsBox) {
return {
x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),
y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),
};
}
/**
* Calculate a transform origin relative to the source axis, between 0-1, that results
* in an asthetically pleasing scale/transform needed to project from source to target.
*/
function calcOrigin(source, target) {
let origin = 0.5;
const sourceLength = calcLength(source);
const targetLength = calcLength(target);
if (targetLength > sourceLength) {
origin = progress(target.min, target.max - sourceLength, source.min);
}
else if (sourceLength > targetLength) {
origin = progress(source.min, source.max - targetLength, target.min);
}
return clamp_clamp(0, 1, origin);
}
/**
* Rebase the calculated viewport constraints relative to the layout.min point.
*/
function rebaseAxisConstraints(layout, constraints) {
const relativeConstraints = {};
if (constraints.min !== undefined) {
relativeConstraints.min = constraints.min - layout.min;
}
if (constraints.max !== undefined) {
relativeConstraints.max = constraints.max - layout.min;
}
return relativeConstraints;
}
const defaultElastic = 0.35;
/**
* Accepts a dragElastic prop and returns resolved elastic values for each axis.
*/
function resolveDragElastic(dragElastic = defaultElastic) {
if (dragElastic === false) {
dragElastic = 0;
}
else if (dragElastic === true) {
dragElastic = defaultElastic;
}
return {
x: resolveAxisElastic(dragElastic, "left", "right"),
y: resolveAxisElastic(dragElastic, "top", "bottom"),
};
}
function resolveAxisElastic(dragElastic, minLabel, maxLabel) {
return {
min: resolvePointElastic(dragElastic, minLabel),
max: resolvePointElastic(dragElastic, maxLabel),
};
}
function resolvePointElastic(dragElastic, label) {
return typeof dragElastic === "number"
? dragElastic
: dragElastic[label] || 0;
}
;// ./node_modules/framer-motion/dist/es/projection/geometry/models.mjs
const createAxisDelta = () => ({
translate: 0,
scale: 1,
origin: 0,
originPoint: 0,
});
const createDelta = () => ({
x: createAxisDelta(),
y: createAxisDelta(),
});
const createAxis = () => ({ min: 0, max: 0 });
const createBox = () => ({
x: createAxis(),
y: createAxis(),
});
;// ./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs
function eachAxis(callback) {
return [callback("x"), callback("y")];
}
;// ./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs
/**
* Bounding boxes tend to be defined as top, left, right, bottom. For various operations
* it's easier to consider each axis individually. This function returns a bounding box
* as a map of single-axis min/max values.
*/
function convertBoundingBoxToBox({ top, left, right, bottom, }) {
return {
x: { min: left, max: right },
y: { min: top, max: bottom },
};
}
function convertBoxToBoundingBox({ x, y }) {
return { top: y.min, right: x.max, bottom: y.max, left: x.min };
}
/**
* Applies a TransformPoint function to a bounding box. TransformPoint is usually a function
* provided by Framer to allow measured points to be corrected for device scaling. This is used
* when measuring DOM elements and DOM event points.
*/
function transformBoxPoints(point, transformPoint) {
if (!transformPoint)
return point;
const topLeft = transformPoint({ x: point.left, y: point.top });
const bottomRight = transformPoint({ x: point.right, y: point.bottom });
return {
top: topLeft.y,
left: topLeft.x,
bottom: bottomRight.y,
right: bottomRight.x,
};
}
;// ./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs
function isIdentityScale(scale) {
return scale === undefined || scale === 1;
}
function hasScale({ scale, scaleX, scaleY }) {
return (!isIdentityScale(scale) ||
!isIdentityScale(scaleX) ||
!isIdentityScale(scaleY));
}
function hasTransform(values) {
return (hasScale(values) ||
has2DTranslate(values) ||
values.z ||
values.rotate ||
values.rotateX ||
values.rotateY ||
values.skewX ||
values.skewY);
}
function has2DTranslate(values) {
return is2DTranslate(values.x) || is2DTranslate(values.y);
}
function is2DTranslate(value) {
return value && value !== "0%";
}
;// ./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs
/**
* Scales a point based on a factor and an originPoint
*/
function scalePoint(point, scale, originPoint) {
const distanceFromOrigin = point - originPoint;
const scaled = scale * distanceFromOrigin;
return originPoint + scaled;
}
/**
* Applies a translate/scale delta to a point
*/
function applyPointDelta(point, translate, scale, originPoint, boxScale) {
if (boxScale !== undefined) {
point = scalePoint(point, boxScale, originPoint);
}
return scalePoint(point, scale, originPoint) + translate;
}
/**
* Applies a translate/scale delta to an axis
*/
function applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {
axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);
axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);
}
/**
* Applies a translate/scale delta to a box
*/
function applyBoxDelta(box, { x, y }) {
applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);
applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);
}
const TREE_SCALE_SNAP_MIN = 0.999999999999;
const TREE_SCALE_SNAP_MAX = 1.0000000000001;
/**
* Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms
* in a tree upon our box before then calculating how to project it into our desired viewport-relative box
*
* This is the final nested loop within updateLayoutDelta for future refactoring
*/
function applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {
const treeLength = treePath.length;
if (!treeLength)
return;
// Reset the treeScale
treeScale.x = treeScale.y = 1;
let node;
let delta;
for (let i = 0; i < treeLength; i++) {
node = treePath[i];
delta = node.projectionDelta;
/**
* TODO: Prefer to remove this, but currently we have motion components with
* display: contents in Framer.
*/
const { visualElement } = node.options;
if (visualElement &&
visualElement.props.style &&
visualElement.props.style.display === "contents") {
continue;
}
if (isSharedTransition &&
node.options.layoutScroll &&
node.scroll &&
node !== node.root) {
transformBox(box, {
x: -node.scroll.offset.x,
y: -node.scroll.offset.y,
});
}
if (delta) {
// Incoporate each ancestor's scale into a culmulative treeScale for this component
treeScale.x *= delta.x.scale;
treeScale.y *= delta.y.scale;
// Apply each ancestor's calculated delta into this component's recorded layout box
applyBoxDelta(box, delta);
}
if (isSharedTransition && hasTransform(node.latestValues)) {
transformBox(box, node.latestValues);
}
}
/**
* Snap tree scale back to 1 if it's within a non-perceivable threshold.
* This will help reduce useless scales getting rendered.
*/
if (treeScale.x < TREE_SCALE_SNAP_MAX &&
treeScale.x > TREE_SCALE_SNAP_MIN) {
treeScale.x = 1.0;
}
if (treeScale.y < TREE_SCALE_SNAP_MAX &&
treeScale.y > TREE_SCALE_SNAP_MIN) {
treeScale.y = 1.0;
}
}
function translateAxis(axis, distance) {
axis.min = axis.min + distance;
axis.max = axis.max + distance;
}
/**
* Apply a transform to an axis from the latest resolved motion values.
* This function basically acts as a bridge between a flat motion value map
* and applyAxisDelta
*/
function transformAxis(axis, axisTranslate, axisScale, boxScale, axisOrigin = 0.5) {
const originPoint = mixNumber(axis.min, axis.max, axisOrigin);
// Apply the axis delta to the final axis
applyAxisDelta(axis, axisTranslate, axisScale, originPoint, boxScale);
}
/**
* Apply a transform to a box from the latest resolved motion values.
*/
function transformBox(box, transform) {
transformAxis(box.x, transform.x, transform.scaleX, transform.scale, transform.originX);
transformAxis(box.y, transform.y, transform.scaleY, transform.scale, transform.originY);
}
;// ./node_modules/framer-motion/dist/es/projection/utils/measure.mjs
function measureViewportBox(instance, transformPoint) {
return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));
}
function measurePageBox(element, rootProjectionNode, transformPagePoint) {
const viewportBox = measureViewportBox(element, transformPagePoint);
const { scroll } = rootProjectionNode;
if (scroll) {
translateAxis(viewportBox.x, scroll.offset.x);
translateAxis(viewportBox.y, scroll.offset.y);
}
return viewportBox;
}
;// ./node_modules/framer-motion/dist/es/utils/get-context-window.mjs
// Fixes https://github.com/motiondivision/motion/issues/2270
const getContextWindow = ({ current }) => {
return current ? current.ownerDocument.defaultView : null;
};
;// ./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs
const elementDragControls = new WeakMap();
/**
*
*/
// let latestPointerEvent: PointerEvent
class VisualElementDragControls {
constructor(visualElement) {
this.openDragLock = null;
this.isDragging = false;
this.currentDirection = null;
this.originPoint = { x: 0, y: 0 };
/**
* The permitted boundaries of travel, in pixels.
*/
this.constraints = false;
this.hasMutatedConstraints = false;
/**
* The per-axis resolved elastic values.
*/
this.elastic = createBox();
this.visualElement = visualElement;
}
start(originEvent, { snapToCursor = false } = {}) {
/**
* Don't start dragging if this component is exiting
*/
const { presenceContext } = this.visualElement;
if (presenceContext && presenceContext.isPresent === false)
return;
const onSessionStart = (event) => {
const { dragSnapToOrigin } = this.getProps();
// Stop or pause any animations on both axis values immediately. This allows the user to throw and catch
// the component.
dragSnapToOrigin ? this.pauseAnimation() : this.stopAnimation();
if (snapToCursor) {
this.snapToCursor(extractEventInfo(event).point);
}
};
const onStart = (event, info) => {
// Attempt to grab the global drag gesture lock - maybe make this part of PanSession
const { drag, dragPropagation, onDragStart } = this.getProps();
if (drag && !dragPropagation) {
if (this.openDragLock)
this.openDragLock();
this.openDragLock = setDragLock(drag);
// If we don 't have the lock, don't start dragging
if (!this.openDragLock)
return;
}
this.isDragging = true;
this.currentDirection = null;
this.resolveConstraints();
if (this.visualElement.projection) {
this.visualElement.projection.isAnimationBlocked = true;
this.visualElement.projection.target = undefined;
}
/**
* Record gesture origin
*/
eachAxis((axis) => {
let current = this.getAxisMotionValue(axis).get() || 0;
/**
* If the MotionValue is a percentage value convert to px
*/
if (percent.test(current)) {
const { projection } = this.visualElement;
if (projection && projection.layout) {
const measuredAxis = projection.layout.layoutBox[axis];
if (measuredAxis) {
const length = calcLength(measuredAxis);
current = length * (parseFloat(current) / 100);
}
}
}
this.originPoint[axis] = current;
});
// Fire onDragStart event
if (onDragStart) {
frame_frame.postRender(() => onDragStart(event, info));
}
addValueToWillChange(this.visualElement, "transform");
const { animationState } = this.visualElement;
animationState && animationState.setActive("whileDrag", true);
};
const onMove = (event, info) => {
// latestPointerEvent = event
const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();
// If we didn't successfully receive the gesture lock, early return.
if (!dragPropagation && !this.openDragLock)
return;
const { offset } = info;
// Attempt to detect drag direction if directionLock is true
if (dragDirectionLock && this.currentDirection === null) {
this.currentDirection = getCurrentDirection(offset);
// If we've successfully set a direction, notify listener
if (this.currentDirection !== null) {
onDirectionLock && onDirectionLock(this.currentDirection);
}
return;
}
// Update each point with the latest position
this.updateAxis("x", info.point, offset);
this.updateAxis("y", info.point, offset);
/**
* Ideally we would leave the renderer to fire naturally at the end of
* this frame but if the element is about to change layout as the result
* of a re-render we want to ensure the browser can read the latest
* bounding box to ensure the pointer and element don't fall out of sync.
*/
this.visualElement.render();
/**
* This must fire after the render call as it might trigger a state
* change which itself might trigger a layout update.
*/
onDrag && onDrag(event, info);
};
const onSessionEnd = (event, info) => this.stop(event, info);
const resumeAnimation = () => eachAxis((axis) => {
var _a;
return this.getAnimationState(axis) === "paused" &&
((_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.play());
});
const { dragSnapToOrigin } = this.getProps();
this.panSession = new PanSession(originEvent, {
onSessionStart,
onStart,
onMove,
onSessionEnd,
resumeAnimation,
}, {
transformPagePoint: this.visualElement.getTransformPagePoint(),
dragSnapToOrigin,
contextWindow: getContextWindow(this.visualElement),
});
}
stop(event, info) {
const isDragging = this.isDragging;
this.cancel();
if (!isDragging)
return;
const { velocity } = info;
this.startAnimation(velocity);
const { onDragEnd } = this.getProps();
if (onDragEnd) {
frame_frame.postRender(() => onDragEnd(event, info));
}
}
cancel() {
this.isDragging = false;
const { projection, animationState } = this.visualElement;
if (projection) {
projection.isAnimationBlocked = false;
}
this.panSession && this.panSession.end();
this.panSession = undefined;
const { dragPropagation } = this.getProps();
if (!dragPropagation && this.openDragLock) {
this.openDragLock();
this.openDragLock = null;
}
animationState && animationState.setActive("whileDrag", false);
}
updateAxis(axis, _point, offset) {
const { drag } = this.getProps();
// If we're not dragging this axis, do an early return.
if (!offset || !shouldDrag(axis, drag, this.currentDirection))
return;
const axisValue = this.getAxisMotionValue(axis);
let next = this.originPoint[axis] + offset[axis];
// Apply constraints
if (this.constraints && this.constraints[axis]) {
next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);
}
axisValue.set(next);
}
resolveConstraints() {
var _a;
const { dragConstraints, dragElastic } = this.getProps();
const layout = this.visualElement.projection &&
!this.visualElement.projection.layout
? this.visualElement.projection.measure(false)
: (_a = this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout;
const prevConstraints = this.constraints;
if (dragConstraints && isRefObject(dragConstraints)) {
if (!this.constraints) {
this.constraints = this.resolveRefConstraints();
}
}
else {
if (dragConstraints && layout) {
this.constraints = calcRelativeConstraints(layout.layoutBox, dragConstraints);
}
else {
this.constraints = false;
}
}
this.elastic = resolveDragElastic(dragElastic);
/**
* If we're outputting to external MotionValues, we want to rebase the measured constraints
* from viewport-relative to component-relative.
*/
if (prevConstraints !== this.constraints &&
layout &&
this.constraints &&
!this.hasMutatedConstraints) {
eachAxis((axis) => {
if (this.constraints !== false &&
this.getAxisMotionValue(axis)) {
this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);
}
});
}
}
resolveRefConstraints() {
const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();
if (!constraints || !isRefObject(constraints))
return false;
const constraintsElement = constraints.current;
errors_invariant(constraintsElement !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.");
const { projection } = this.visualElement;
// TODO
if (!projection || !projection.layout)
return false;
const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());
let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, constraintsBox);
/**
* If there's an onMeasureDragConstraints listener we call it and
* if different constraints are returned, set constraints to that
*/
if (onMeasureDragConstraints) {
const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));
this.hasMutatedConstraints = !!userConstraints;
if (userConstraints) {
measuredConstraints = convertBoundingBoxToBox(userConstraints);
}
}
return measuredConstraints;
}
startAnimation(velocity) {
const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();
const constraints = this.constraints || {};
const momentumAnimations = eachAxis((axis) => {
if (!shouldDrag(axis, drag, this.currentDirection)) {
return;
}
let transition = (constraints && constraints[axis]) || {};
if (dragSnapToOrigin)
transition = { min: 0, max: 0 };
/**
* Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame
* of spring animations so we should look into adding a disable spring option to `inertia`.
* We could do something here where we affect the `bounceStiffness` and `bounceDamping`
* using the value of `dragElastic`.
*/
const bounceStiffness = dragElastic ? 200 : 1000000;
const bounceDamping = dragElastic ? 40 : 10000000;
const inertia = {
type: "inertia",
velocity: dragMomentum ? velocity[axis] : 0,
bounceStiffness,
bounceDamping,
timeConstant: 750,
restDelta: 1,
restSpeed: 10,
...dragTransition,
...transition,
};
// If we're not animating on an externally-provided `MotionValue` we can use the
// component's animation controls which will handle interactions with whileHover (etc),
// otherwise we just have to animate the `MotionValue` itself.
return this.startAxisValueAnimation(axis, inertia);
});
// Run all animations and then resolve the new drag constraints.
return Promise.all(momentumAnimations).then(onDragTransitionEnd);
}
startAxisValueAnimation(axis, transition) {
const axisValue = this.getAxisMotionValue(axis);
addValueToWillChange(this.visualElement, axis);
return axisValue.start(animateMotionValue(axis, axisValue, 0, transition, this.visualElement, false));
}
stopAnimation() {
eachAxis((axis) => this.getAxisMotionValue(axis).stop());
}
pauseAnimation() {
eachAxis((axis) => { var _a; return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.pause(); });
}
getAnimationState(axis) {
var _a;
return (_a = this.getAxisMotionValue(axis).animation) === null || _a === void 0 ? void 0 : _a.state;
}
/**
* Drag works differently depending on which props are provided.
*
* - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
* - Otherwise, we apply the delta to the x/y motion values.
*/
getAxisMotionValue(axis) {
const dragKey = `_drag${axis.toUpperCase()}`;
const props = this.visualElement.getProps();
const externalMotionValue = props[dragKey];
return externalMotionValue
? externalMotionValue
: this.visualElement.getValue(axis, (props.initial
? props.initial[axis]
: undefined) || 0);
}
snapToCursor(point) {
eachAxis((axis) => {
const { drag } = this.getProps();
// If we're not dragging this axis, do an early return.
if (!shouldDrag(axis, drag, this.currentDirection))
return;
const { projection } = this.visualElement;
const axisValue = this.getAxisMotionValue(axis);
if (projection && projection.layout) {
const { min, max } = projection.layout.layoutBox[axis];
axisValue.set(point[axis] - mixNumber(min, max, 0.5));
}
});
}
/**
* When the viewport resizes we want to check if the measured constraints
* have changed and, if so, reposition the element within those new constraints
* relative to where it was before the resize.
*/
scalePositionWithinConstraints() {
if (!this.visualElement.current)
return;
const { drag, dragConstraints } = this.getProps();
const { projection } = this.visualElement;
if (!isRefObject(dragConstraints) || !projection || !this.constraints)
return;
/**
* Stop current animations as there can be visual glitching if we try to do
* this mid-animation
*/
this.stopAnimation();
/**
* Record the relative position of the dragged element relative to the
* constraints box and save as a progress value.
*/
const boxProgress = { x: 0, y: 0 };
eachAxis((axis) => {
const axisValue = this.getAxisMotionValue(axis);
if (axisValue && this.constraints !== false) {
const latest = axisValue.get();
boxProgress[axis] = calcOrigin({ min: latest, max: latest }, this.constraints[axis]);
}
});
/**
* Update the layout of this element and resolve the latest drag constraints
*/
const { transformTemplate } = this.visualElement.getProps();
this.visualElement.current.style.transform = transformTemplate
? transformTemplate({}, "")
: "none";
projection.root && projection.root.updateScroll();
projection.updateLayout();
this.resolveConstraints();
/**
* For each axis, calculate the current progress of the layout axis
* within the new constraints.
*/
eachAxis((axis) => {
if (!shouldDrag(axis, drag, null))
return;
/**
* Calculate a new transform based on the previous box progress
*/
const axisValue = this.getAxisMotionValue(axis);
const { min, max } = this.constraints[axis];
axisValue.set(mixNumber(min, max, boxProgress[axis]));
});
}
addListeners() {
if (!this.visualElement.current)
return;
elementDragControls.set(this.visualElement, this);
const element = this.visualElement.current;
/**
* Attach a pointerdown event listener on this DOM element to initiate drag tracking.
*/
const stopPointerListener = addPointerEvent(element, "pointerdown", (event) => {
const { drag, dragListener = true } = this.getProps();
drag && dragListener && this.start(event);
});
const measureDragConstraints = () => {
const { dragConstraints } = this.getProps();
if (isRefObject(dragConstraints) && dragConstraints.current) {
this.constraints = this.resolveRefConstraints();
}
};
const { projection } = this.visualElement;
const stopMeasureLayoutListener = projection.addEventListener("measure", measureDragConstraints);
if (projection && !projection.layout) {
projection.root && projection.root.updateScroll();
projection.updateLayout();
}
frame_frame.read(measureDragConstraints);
/**
* Attach a window resize listener to scale the draggable target within its defined
* constraints as the window resizes.
*/
const stopResizeListener = addDomEvent(window, "resize", () => this.scalePositionWithinConstraints());
/**
* If the element's layout changes, calculate the delta and apply that to
* the drag gesture's origin point.
*/
const stopLayoutUpdateListener = projection.addEventListener("didUpdate", (({ delta, hasLayoutChanged }) => {
if (this.isDragging && hasLayoutChanged) {
eachAxis((axis) => {
const motionValue = this.getAxisMotionValue(axis);
if (!motionValue)
return;
this.originPoint[axis] += delta[axis].translate;
motionValue.set(motionValue.get() + delta[axis].translate);
});
this.visualElement.render();
}
}));
return () => {
stopResizeListener();
stopPointerListener();
stopMeasureLayoutListener();
stopLayoutUpdateListener && stopLayoutUpdateListener();
};
}
getProps() {
const props = this.visualElement.getProps();
const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;
return {
...props,
drag,
dragDirectionLock,
dragPropagation,
dragConstraints,
dragElastic,
dragMomentum,
};
}
}
function shouldDrag(direction, drag, currentDirection) {
return ((drag === true || drag === direction) &&
(currentDirection === null || currentDirection === direction));
}
/**
* Based on an x/y offset determine the current drag direction. If both axis' offsets are lower
* than the provided threshold, return `null`.
*
* @param offset - The x/y offset from origin.
* @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.
*/
function getCurrentDirection(offset, lockThreshold = 10) {
let direction = null;
if (Math.abs(offset.y) > lockThreshold) {
direction = "y";
}
else if (Math.abs(offset.x) > lockThreshold) {
direction = "x";
}
return direction;
}
;// ./node_modules/framer-motion/dist/es/gestures/drag/index.mjs
class DragGesture extends Feature {
constructor(node) {
super(node);
this.removeGroupControls = noop_noop;
this.removeListeners = noop_noop;
this.controls = new VisualElementDragControls(node);
}
mount() {
// If we've been provided a DragControls for manual control over the drag gesture,
// subscribe this component to it on mount.
const { dragControls } = this.node.getProps();
if (dragControls) {
this.removeGroupControls = dragControls.subscribe(this.controls);
}
this.removeListeners = this.controls.addListeners() || noop_noop;
}
unmount() {
this.removeGroupControls();
this.removeListeners();
}
}
;// ./node_modules/framer-motion/dist/es/gestures/pan/index.mjs
const asyncHandler = (handler) => (event, info) => {
if (handler) {
frame_frame.postRender(() => handler(event, info));
}
};
class PanGesture extends Feature {
constructor() {
super(...arguments);
this.removePointerDownListener = noop_noop;
}
onPointerDown(pointerDownEvent) {
this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), {
transformPagePoint: this.node.getTransformPagePoint(),
contextWindow: getContextWindow(this.node),
});
}
createPanHandlers() {
const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();
return {
onSessionStart: asyncHandler(onPanSessionStart),
onStart: asyncHandler(onPanStart),
onMove: onPan,
onEnd: (event, info) => {
delete this.session;
if (onPanEnd) {
frame_frame.postRender(() => onPanEnd(event, info));
}
},
};
}
mount() {
this.removePointerDownListener = addPointerEvent(this.node.current, "pointerdown", (event) => this.onPointerDown(event));
}
update() {
this.session && this.session.updateHandlers(this.createPanHandlers());
}
unmount() {
this.removePointerDownListener();
this.session && this.session.end();
}
}
;// ./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs
"use client";
/**
* Internal, exported only for usage in Framer
*/
const SwitchLayoutGroupContext = (0,external_React_.createContext)({});
;// ./node_modules/framer-motion/dist/es/projection/node/state.mjs
/**
* This should only ever be modified on the client otherwise it'll
* persist through server requests. If we need instanced states we
* could lazy-init via root.
*/
const globalProjectionState = {
/**
* Global flag as to whether the tree has animated since the last time
* we resized the window
*/
hasAnimatedSinceResize: true,
/**
* We set this to true once, on the first update. Any nodes added to the tree beyond that
* update will be given a `data-projection-id` attribute.
*/
hasEverUpdated: false,
};
;// ./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs
function pixelsToPercent(pixels, axis) {
if (axis.max === axis.min)
return 0;
return (pixels / (axis.max - axis.min)) * 100;
}
/**
* We always correct borderRadius as a percentage rather than pixels to reduce paints.
* For example, if you are projecting a box that is 100px wide with a 10px borderRadius
* into a box that is 200px wide with a 20px borderRadius, that is actually a 10%
* borderRadius in both states. If we animate between the two in pixels that will trigger
* a paint each time. If we animate between the two in percentage we'll avoid a paint.
*/
const correctBorderRadius = {
correct: (latest, node) => {
if (!node.target)
return latest;
/**
* If latest is a string, if it's a percentage we can return immediately as it's
* going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.
*/
if (typeof latest === "string") {
if (px.test(latest)) {
latest = parseFloat(latest);
}
else {
return latest;
}
}
/**
* If latest is a number, it's a pixel value. We use the current viewportBox to calculate that
* pixel value as a percentage of each axis
*/
const x = pixelsToPercent(latest, node.target.x);
const y = pixelsToPercent(latest, node.target.y);
return `${x}% ${y}%`;
},
};
;// ./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs
const correctBoxShadow = {
correct: (latest, { treeScale, projectionDelta }) => {
const original = latest;
const shadow = complex.parse(latest);
// TODO: Doesn't support multiple shadows
if (shadow.length > 5)
return original;
const template = complex.createTransformer(latest);
const offset = typeof shadow[0] !== "number" ? 1 : 0;
// Calculate the overall context scale
const xScale = projectionDelta.x.scale * treeScale.x;
const yScale = projectionDelta.y.scale * treeScale.y;
shadow[0 + offset] /= xScale;
shadow[1 + offset] /= yScale;
/**
* Ideally we'd correct x and y scales individually, but because blur and
* spread apply to both we have to take a scale average and apply that instead.
* We could potentially improve the outcome of this by incorporating the ratio between
* the two scales.
*/
const averageScale = mixNumber(xScale, yScale, 0.5);
// Blur
if (typeof shadow[2 + offset] === "number")
shadow[2 + offset] /= averageScale;
// Spread
if (typeof shadow[3 + offset] === "number")
shadow[3 + offset] /= averageScale;
return template(shadow);
},
};
;// ./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs
const scaleCorrectors = {};
function addScaleCorrector(correctors) {
Object.assign(scaleCorrectors, correctors);
}
;// ./node_modules/framer-motion/dist/es/frameloop/microtask.mjs
const { schedule: microtask, cancel: cancelMicrotask } = createRenderBatcher(queueMicrotask, false);
;// ./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs
"use client";
class MeasureLayoutWithContext extends external_React_.Component {
/**
* This only mounts projection nodes for components that
* need measuring, we might want to do it for all components
* in order to incorporate transforms
*/
componentDidMount() {
const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;
const { projection } = visualElement;
addScaleCorrector(defaultScaleCorrectors);
if (projection) {
if (layoutGroup.group)
layoutGroup.group.add(projection);
if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {
switchLayoutGroup.register(projection);
}
projection.root.didUpdate();
projection.addEventListener("animationComplete", () => {
this.safeToRemove();
});
projection.setOptions({
...projection.options,
onExitComplete: () => this.safeToRemove(),
});
}
globalProjectionState.hasEverUpdated = true;
}
getSnapshotBeforeUpdate(prevProps) {
const { layoutDependency, visualElement, drag, isPresent } = this.props;
const projection = visualElement.projection;
if (!projection)
return null;
/**
* TODO: We use this data in relegate to determine whether to
* promote a previous element. There's no guarantee its presence data
* will have updated by this point - if a bug like this arises it will
* have to be that we markForRelegation and then find a new lead some other way,
* perhaps in didUpdate
*/
projection.isPresent = isPresent;
if (drag ||
prevProps.layoutDependency !== layoutDependency ||
layoutDependency === undefined) {
projection.willUpdate();
}
else {
this.safeToRemove();
}
if (prevProps.isPresent !== isPresent) {
if (isPresent) {
projection.promote();
}
else if (!projection.relegate()) {
/**
* If there's another stack member taking over from this one,
* it's in charge of the exit animation and therefore should
* be in charge of the safe to remove. Otherwise we call it here.
*/
frame_frame.postRender(() => {
const stack = projection.getStack();
if (!stack || !stack.members.length) {
this.safeToRemove();
}
});
}
}
return null;
}
componentDidUpdate() {
const { projection } = this.props.visualElement;
if (projection) {
projection.root.didUpdate();
microtask.postRender(() => {
if (!projection.currentAnimation && projection.isLead()) {
this.safeToRemove();
}
});
}
}
componentWillUnmount() {
const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;
const { projection } = visualElement;
if (projection) {
projection.scheduleCheckAfterUnmount();
if (layoutGroup && layoutGroup.group)
layoutGroup.group.remove(projection);
if (promoteContext && promoteContext.deregister)
promoteContext.deregister(projection);
}
}
safeToRemove() {
const { safeToRemove } = this.props;
safeToRemove && safeToRemove();
}
render() {
return null;
}
}
function MeasureLayout(props) {
const [isPresent, safeToRemove] = usePresence();
const layoutGroup = (0,external_React_.useContext)(LayoutGroupContext);
return ((0,external_ReactJSXRuntime_namespaceObject.jsx)(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: (0,external_React_.useContext)(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));
}
const defaultScaleCorrectors = {
borderRadius: {
...correctBorderRadius,
applyTo: [
"borderTopLeftRadius",
"borderTopRightRadius",
"borderBottomLeftRadius",
"borderBottomRightRadius",
],
},
borderTopLeftRadius: correctBorderRadius,
borderTopRightRadius: correctBorderRadius,
borderBottomLeftRadius: correctBorderRadius,
borderBottomRightRadius: correctBorderRadius,
boxShadow: correctBoxShadow,
};
;// ./node_modules/framer-motion/dist/es/animation/animate/single-value.mjs
function animateSingleValue(value, keyframes, options) {
const motionValue$1 = isMotionValue(value) ? value : motionValue(value);
motionValue$1.start(animateMotionValue("", motionValue$1, keyframes, options));
return motionValue$1.animation;
}
;// ./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-element.mjs
function isSVGElement(element) {
return element instanceof SVGElement && element.tagName !== "svg";
}
;// ./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs
const compareByDepth = (a, b) => a.depth - b.depth;
;// ./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs
class FlatTree {
constructor() {
this.children = [];
this.isDirty = false;
}
add(child) {
addUniqueItem(this.children, child);
this.isDirty = true;
}
remove(child) {
removeItem(this.children, child);
this.isDirty = true;
}
forEach(callback) {
this.isDirty && this.children.sort(compareByDepth);
this.isDirty = false;
this.children.forEach(callback);
}
}
;// ./node_modules/framer-motion/dist/es/utils/delay.mjs
/**
* Timeout defined in ms
*/
function delay(callback, timeout) {
const start = time.now();
const checkElapsed = ({ timestamp }) => {
const elapsed = timestamp - start;
if (elapsed >= timeout) {
cancelFrame(checkElapsed);
callback(elapsed - timeout);
}
};
frame_frame.read(checkElapsed, true);
return () => cancelFrame(checkElapsed);
}
function delayInSeconds(callback, timeout) {
return delay(callback, secondsToMilliseconds(timeout));
}
;// ./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs
/**
* If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself
*
* TODO: Remove and move to library
*/
function resolveMotionValue(value) {
const unwrappedValue = isMotionValue(value) ? value.get() : value;
return isCustomValue(unwrappedValue)
? unwrappedValue.toValue()
: unwrappedValue;
}
;// ./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs
const borders = ["TopLeft", "TopRight", "BottomLeft", "BottomRight"];
const numBorders = borders.length;
const asNumber = (value) => typeof value === "string" ? parseFloat(value) : value;
const isPx = (value) => typeof value === "number" || px.test(value);
function mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {
if (shouldCrossfadeOpacity) {
target.opacity = mixNumber(0,
// TODO Reinstate this if only child
lead.opacity !== undefined ? lead.opacity : 1, easeCrossfadeIn(progress));
target.opacityExit = mixNumber(follow.opacity !== undefined ? follow.opacity : 1, 0, easeCrossfadeOut(progress));
}
else if (isOnlyMember) {
target.opacity = mixNumber(follow.opacity !== undefined ? follow.opacity : 1, lead.opacity !== undefined ? lead.opacity : 1, progress);
}
/**
* Mix border radius
*/
for (let i = 0; i < numBorders; i++) {
const borderLabel = `border${borders[i]}Radius`;
let followRadius = getRadius(follow, borderLabel);
let leadRadius = getRadius(lead, borderLabel);
if (followRadius === undefined && leadRadius === undefined)
continue;
followRadius || (followRadius = 0);
leadRadius || (leadRadius = 0);
const canMix = followRadius === 0 ||
leadRadius === 0 ||
isPx(followRadius) === isPx(leadRadius);
if (canMix) {
target[borderLabel] = Math.max(mixNumber(asNumber(followRadius), asNumber(leadRadius), progress), 0);
if (percent.test(leadRadius) || percent.test(followRadius)) {
target[borderLabel] += "%";
}
}
else {
target[borderLabel] = leadRadius;
}
}
/**
* Mix rotation
*/
if (follow.rotate || lead.rotate) {
target.rotate = mixNumber(follow.rotate || 0, lead.rotate || 0, progress);
}
}
function getRadius(values, radiusName) {
return values[radiusName] !== undefined
? values[radiusName]
: values.borderRadius;
}
// /**
// * We only want to mix the background color if there's a follow element
// * that we're not crossfading opacity between. For instance with switch
// * AnimateSharedLayout animations, this helps the illusion of a continuous
// * element being animated but also cuts down on the number of paints triggered
// * for elements where opacity is doing that work for us.
// */
// if (
// !hasFollowElement &&
// latestLeadValues.backgroundColor &&
// latestFollowValues.backgroundColor
// ) {
// /**
// * This isn't ideal performance-wise as mixColor is creating a new function every frame.
// * We could probably create a mixer that runs at the start of the animation but
// * the idea behind the crossfader is that it runs dynamically between two potentially
// * changing targets (ie opacity or borderRadius may be animating independently via variants)
// */
// leadState.backgroundColor = followState.backgroundColor = mixColor(
// latestFollowValues.backgroundColor as string,
// latestLeadValues.backgroundColor as string
// )(p)
// }
const easeCrossfadeIn = /*@__PURE__*/ compress(0, 0.5, circOut);
const easeCrossfadeOut = /*@__PURE__*/ compress(0.5, 0.95, noop_noop);
function compress(min, max, easing) {
return (p) => {
// Could replace ifs with clamp
if (p < min)
return 0;
if (p > max)
return 1;
return easing(progress(min, max, p));
};
}
;// ./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs
/**
* Reset an axis to the provided origin box.
*
* This is a mutative operation.
*/
function copyAxisInto(axis, originAxis) {
axis.min = originAxis.min;
axis.max = originAxis.max;
}
/**
* Reset a box to the provided origin box.
*
* This is a mutative operation.
*/
function copyBoxInto(box, originBox) {
copyAxisInto(box.x, originBox.x);
copyAxisInto(box.y, originBox.y);
}
/**
* Reset a delta to the provided origin box.
*
* This is a mutative operation.
*/
function copyAxisDeltaInto(delta, originDelta) {
delta.translate = originDelta.translate;
delta.scale = originDelta.scale;
delta.originPoint = originDelta.originPoint;
delta.origin = originDelta.origin;
}
;// ./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs
/**
* Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse
*/
function removePointDelta(point, translate, scale, originPoint, boxScale) {
point -= translate;
point = scalePoint(point, 1 / scale, originPoint);
if (boxScale !== undefined) {
point = scalePoint(point, 1 / boxScale, originPoint);
}
return point;
}
/**
* Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse
*/
function removeAxisDelta(axis, translate = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {
if (percent.test(translate)) {
translate = parseFloat(translate);
const relativeProgress = mixNumber(sourceAxis.min, sourceAxis.max, translate / 100);
translate = relativeProgress - sourceAxis.min;
}
if (typeof translate !== "number")
return;
let originPoint = mixNumber(originAxis.min, originAxis.max, origin);
if (axis === originAxis)
originPoint -= translate;
axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);
axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);
}
/**
* Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse
* and acts as a bridge between motion values and removeAxisDelta
*/
function removeAxisTransforms(axis, transforms, [key, scaleKey, originKey], origin, sourceAxis) {
removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);
}
/**
* The names of the motion values we want to apply as translation, scale and origin.
*/
const xKeys = ["x", "scaleX", "originX"];
const yKeys = ["y", "scaleY", "originY"];
/**
* Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse
* and acts as a bridge between motion values and removeAxisDelta
*/
function removeBoxTransforms(box, transforms, originBox, sourceBox) {
removeAxisTransforms(box.x, transforms, xKeys, originBox ? originBox.x : undefined, sourceBox ? sourceBox.x : undefined);
removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : undefined, sourceBox ? sourceBox.y : undefined);
}
;// ./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs
function isAxisDeltaZero(delta) {
return delta.translate === 0 && delta.scale === 1;
}
function isDeltaZero(delta) {
return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);
}
function axisEquals(a, b) {
return a.min === b.min && a.max === b.max;
}
function boxEquals(a, b) {
return axisEquals(a.x, b.x) && axisEquals(a.y, b.y);
}
function axisEqualsRounded(a, b) {
return (Math.round(a.min) === Math.round(b.min) &&
Math.round(a.max) === Math.round(b.max));
}
function boxEqualsRounded(a, b) {
return axisEqualsRounded(a.x, b.x) && axisEqualsRounded(a.y, b.y);
}
function aspectRatio(box) {
return calcLength(box.x) / calcLength(box.y);
}
function axisDeltaEquals(a, b) {
return (a.translate === b.translate &&
a.scale === b.scale &&
a.originPoint === b.originPoint);
}
;// ./node_modules/framer-motion/dist/es/projection/shared/stack.mjs
class NodeStack {
constructor() {
this.members = [];
}
add(node) {
addUniqueItem(this.members, node);
node.scheduleRender();
}
remove(node) {
removeItem(this.members, node);
if (node === this.prevLead) {
this.prevLead = undefined;
}
if (node === this.lead) {
const prevLead = this.members[this.members.length - 1];
if (prevLead) {
this.promote(prevLead);
}
}
}
relegate(node) {
const indexOfNode = this.members.findIndex((member) => node === member);
if (indexOfNode === 0)
return false;
/**
* Find the next projection node that is present
*/
let prevLead;
for (let i = indexOfNode; i >= 0; i--) {
const member = this.members[i];
if (member.isPresent !== false) {
prevLead = member;
break;
}
}
if (prevLead) {
this.promote(prevLead);
return true;
}
else {
return false;
}
}
promote(node, preserveFollowOpacity) {
const prevLead = this.lead;
if (node === prevLead)
return;
this.prevLead = prevLead;
this.lead = node;
node.show();
if (prevLead) {
prevLead.instance && prevLead.scheduleRender();
node.scheduleRender();
node.resumeFrom = prevLead;
if (preserveFollowOpacity) {
node.resumeFrom.preserveOpacity = true;
}
if (prevLead.snapshot) {
node.snapshot = prevLead.snapshot;
node.snapshot.latestValues =
prevLead.animationValues || prevLead.latestValues;
}
if (node.root && node.root.isUpdating) {
node.isLayoutDirty = true;
}
const { crossfade } = node.options;
if (crossfade === false) {
prevLead.hide();
}
/**
* TODO:
* - Test border radius when previous node was deleted
* - boxShadow mixing
* - Shared between element A in scrolled container and element B (scroll stays the same or changes)
* - Shared between element A in transformed container and element B (transform stays the same or changes)
* - Shared between element A in scrolled page and element B (scroll stays the same or changes)
* ---
* - Crossfade opacity of root nodes
* - layoutId changes after animation
* - layoutId changes mid animation
*/
}
}
exitAnimationComplete() {
this.members.forEach((node) => {
const { options, resumingFrom } = node;
options.onExitComplete && options.onExitComplete();
if (resumingFrom) {
resumingFrom.options.onExitComplete &&
resumingFrom.options.onExitComplete();
}
});
}
scheduleRender() {
this.members.forEach((node) => {
node.instance && node.scheduleRender(false);
});
}
/**
* Clear any leads that have been removed this render to prevent them from being
* used in future animations and to prevent memory leaks
*/
removeLeadSnapshot() {
if (this.lead && this.lead.snapshot) {
this.lead.snapshot = undefined;
}
}
}
;// ./node_modules/framer-motion/dist/es/projection/styles/transform.mjs
function buildProjectionTransform(delta, treeScale, latestTransform) {
let transform = "";
/**
* The translations we use to calculate are always relative to the viewport coordinate space.
* But when we apply scales, we also scale the coordinate space of an element and its children.
* For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need
* to move an element 100 pixels, we actually need to move it 200 in within that scaled space.
*/
const xTranslate = delta.x.translate / treeScale.x;
const yTranslate = delta.y.translate / treeScale.y;
const zTranslate = (latestTransform === null || latestTransform === void 0 ? void 0 : latestTransform.z) || 0;
if (xTranslate || yTranslate || zTranslate) {
transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;
}
/**
* Apply scale correction for the tree transform.
* This will apply scale to the screen-orientated axes.
*/
if (treeScale.x !== 1 || treeScale.y !== 1) {
transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
}
if (latestTransform) {
const { transformPerspective, rotate, rotateX, rotateY, skewX, skewY } = latestTransform;
if (transformPerspective)
transform = `perspective(${transformPerspective}px) ${transform}`;
if (rotate)
transform += `rotate(${rotate}deg) `;
if (rotateX)
transform += `rotateX(${rotateX}deg) `;
if (rotateY)
transform += `rotateY(${rotateY}deg) `;
if (skewX)
transform += `skewX(${skewX}deg) `;
if (skewY)
transform += `skewY(${skewY}deg) `;
}
/**
* Apply scale to match the size of the element to the size we want it.
* This will apply scale to the element-orientated axes.
*/
const elementScaleX = delta.x.scale * treeScale.x;
const elementScaleY = delta.y.scale * treeScale.y;
if (elementScaleX !== 1 || elementScaleY !== 1) {
transform += `scale(${elementScaleX}, ${elementScaleY})`;
}
return transform || "none";
}
;// ./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs
const metrics = {
type: "projectionFrame",
totalNodes: 0,
resolvedTargetDeltas: 0,
recalculatedProjection: 0,
};
const isDebug = typeof window !== "undefined" && window.MotionDebug !== undefined;
const transformAxes = ["", "X", "Y", "Z"];
const hiddenVisibility = { visibility: "hidden" };
/**
* We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1
* which has a noticeable difference in spring animations
*/
const animationTarget = 1000;
let create_projection_node_id = 0;
function resetDistortingTransform(key, visualElement, values, sharedAnimationValues) {
const { latestValues } = visualElement;
// Record the distorting transform and then temporarily set it to 0
if (latestValues[key]) {
values[key] = latestValues[key];
visualElement.setStaticValue(key, 0);
if (sharedAnimationValues) {
sharedAnimationValues[key] = 0;
}
}
}
function cancelTreeOptimisedTransformAnimations(projectionNode) {
projectionNode.hasCheckedOptimisedAppear = true;
if (projectionNode.root === projectionNode)
return;
const { visualElement } = projectionNode.options;
if (!visualElement)
return;
const appearId = getOptimisedAppearId(visualElement);
if (window.MotionHasOptimisedAnimation(appearId, "transform")) {
const { layout, layoutId } = projectionNode.options;
window.MotionCancelOptimisedAnimation(appearId, "transform", frame_frame, !(layout || layoutId));
}
const { parent } = projectionNode;
if (parent && !parent.hasCheckedOptimisedAppear) {
cancelTreeOptimisedTransformAnimations(parent);
}
}
function createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform, }) {
return class ProjectionNode {
constructor(latestValues = {}, parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent()) {
/**
* A unique ID generated for every projection node.
*/
this.id = create_projection_node_id++;
/**
* An id that represents a unique session instigated by startUpdate.
*/
this.animationId = 0;
/**
* A Set containing all this component's children. This is used to iterate
* through the children.
*
* TODO: This could be faster to iterate as a flat array stored on the root node.
*/
this.children = new Set();
/**
* Options for the node. We use this to configure what kind of layout animations
* we should perform (if any).
*/
this.options = {};
/**
* We use this to detect when its safe to shut down part of a projection tree.
* We have to keep projecting children for scale correction and relative projection
* until all their parents stop performing layout animations.
*/
this.isTreeAnimating = false;
this.isAnimationBlocked = false;
/**
* Flag to true if we think this layout has been changed. We can't always know this,
* currently we set it to true every time a component renders, or if it has a layoutDependency
* if that has changed between renders. Additionally, components can be grouped by LayoutGroup
* and if one node is dirtied, they all are.
*/
this.isLayoutDirty = false;
/**
* Flag to true if we think the projection calculations for this node needs
* recalculating as a result of an updated transform or layout animation.
*/
this.isProjectionDirty = false;
/**
* Flag to true if the layout *or* transform has changed. This then gets propagated
* throughout the projection tree, forcing any element below to recalculate on the next frame.
*/
this.isSharedProjectionDirty = false;
/**
* Flag transform dirty. This gets propagated throughout the whole tree but is only
* respected by shared nodes.
*/
this.isTransformDirty = false;
/**
* Block layout updates for instant layout transitions throughout the tree.
*/
this.updateManuallyBlocked = false;
this.updateBlockedByResize = false;
/**
* Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`
* call.
*/
this.isUpdating = false;
/**
* If this is an SVG element we currently disable projection transforms
*/
this.isSVG = false;
/**
* Flag to true (during promotion) if a node doing an instant layout transition needs to reset
* its projection styles.
*/
this.needsReset = false;
/**
* Flags whether this node should have its transform reset prior to measuring.
*/
this.shouldResetTransform = false;
/**
* Store whether this node has been checked for optimised appear animations. As
* effects fire bottom-up, and we want to look up the tree for appear animations,
* this makes sure we only check each path once, stopping at nodes that
* have already been checked.
*/
this.hasCheckedOptimisedAppear = false;
/**
* An object representing the calculated contextual/accumulated/tree scale.
* This will be used to scale calculcated projection transforms, as these are
* calculated in screen-space but need to be scaled for elements to layoutly
* make it to their calculated destinations.
*
* TODO: Lazy-init
*/
this.treeScale = { x: 1, y: 1 };
/**
*
*/
this.eventHandlers = new Map();
this.hasTreeAnimated = false;
// Note: Currently only running on root node
this.updateScheduled = false;
this.scheduleUpdate = () => this.update();
this.projectionUpdateScheduled = false;
this.checkUpdateFailed = () => {
if (this.isUpdating) {
this.isUpdating = false;
this.clearAllSnapshots();
}
};
/**
* This is a multi-step process as shared nodes might be of different depths. Nodes
* are sorted by depth order, so we need to resolve the entire tree before moving to
* the next step.
*/
this.updateProjection = () => {
this.projectionUpdateScheduled = false;
/**
* Reset debug counts. Manually resetting rather than creating a new
* object each frame.
*/
if (isDebug) {
metrics.totalNodes =
metrics.resolvedTargetDeltas =
metrics.recalculatedProjection =
0;
}
this.nodes.forEach(propagateDirtyNodes);
this.nodes.forEach(resolveTargetDelta);
this.nodes.forEach(calcProjection);
this.nodes.forEach(cleanDirtyNodes);
if (isDebug) {
window.MotionDebug.record(metrics);
}
};
/**
* Frame calculations
*/
this.resolvedRelativeTargetAt = 0.0;
this.hasProjected = false;
this.isVisible = true;
this.animationProgress = 0;
/**
* Shared layout
*/
// TODO Only running on root node
this.sharedNodes = new Map();
this.latestValues = latestValues;
this.root = parent ? parent.root || parent : this;
this.path = parent ? [...parent.path, parent] : [];
this.parent = parent;
this.depth = parent ? parent.depth + 1 : 0;
for (let i = 0; i < this.path.length; i++) {
this.path[i].shouldResetTransform = true;
}
if (this.root === this)
this.nodes = new FlatTree();
}
addEventListener(name, handler) {
if (!this.eventHandlers.has(name)) {
this.eventHandlers.set(name, new SubscriptionManager());
}
return this.eventHandlers.get(name).add(handler);
}
notifyListeners(name, ...args) {
const subscriptionManager = this.eventHandlers.get(name);
subscriptionManager && subscriptionManager.notify(...args);
}
hasListeners(name) {
return this.eventHandlers.has(name);
}
/**
* Lifecycles
*/
mount(instance, isLayoutDirty = this.root.hasTreeAnimated) {
if (this.instance)
return;
this.isSVG = isSVGElement(instance);
this.instance = instance;
const { layoutId, layout, visualElement } = this.options;
if (visualElement && !visualElement.current) {
visualElement.mount(instance);
}
this.root.nodes.add(this);
this.parent && this.parent.children.add(this);
if (isLayoutDirty && (layout || layoutId)) {
this.isLayoutDirty = true;
}
if (attachResizeListener) {
let cancelDelay;
const resizeUnblockUpdate = () => (this.root.updateBlockedByResize = false);
attachResizeListener(instance, () => {
this.root.updateBlockedByResize = true;
cancelDelay && cancelDelay();
cancelDelay = delay(resizeUnblockUpdate, 250);
if (globalProjectionState.hasAnimatedSinceResize) {
globalProjectionState.hasAnimatedSinceResize = false;
this.nodes.forEach(finishAnimation);
}
});
}
if (layoutId) {
this.root.registerSharedNode(layoutId, this);
}
// Only register the handler if it requires layout animation
if (this.options.animate !== false &&
visualElement &&
(layoutId || layout)) {
this.addEventListener("didUpdate", ({ delta, hasLayoutChanged, hasRelativeTargetChanged, layout: newLayout, }) => {
if (this.isTreeAnimationBlocked()) {
this.target = undefined;
this.relativeTarget = undefined;
return;
}
// TODO: Check here if an animation exists
const layoutTransition = this.options.transition ||
visualElement.getDefaultTransition() ||
defaultLayoutTransition;
const { onLayoutAnimationStart, onLayoutAnimationComplete, } = visualElement.getProps();
/**
* The target layout of the element might stay the same,
* but its position relative to its parent has changed.
*/
const targetChanged = !this.targetLayout ||
!boxEqualsRounded(this.targetLayout, newLayout) ||
hasRelativeTargetChanged;
/**
* If the layout hasn't seemed to have changed, it might be that the
* element is visually in the same place in the document but its position
* relative to its parent has indeed changed. So here we check for that.
*/
const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;
if (this.options.layoutRoot ||
(this.resumeFrom && this.resumeFrom.instance) ||
hasOnlyRelativeTargetChanged ||
(hasLayoutChanged &&
(targetChanged || !this.currentAnimation))) {
if (this.resumeFrom) {
this.resumingFrom = this.resumeFrom;
this.resumingFrom.resumingFrom = undefined;
}
this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);
const animationOptions = {
...get_value_transition_getValueTransition(layoutTransition, "layout"),
onPlay: onLayoutAnimationStart,
onComplete: onLayoutAnimationComplete,
};
if (visualElement.shouldReduceMotion ||
this.options.layoutRoot) {
animationOptions.delay = 0;
animationOptions.type = false;
}
this.startAnimation(animationOptions);
}
else {
/**
* If the layout hasn't changed and we have an animation that hasn't started yet,
* finish it immediately. Otherwise it will be animating from a location
* that was probably never commited to screen and look like a jumpy box.
*/
if (!hasLayoutChanged) {
finishAnimation(this);
}
if (this.isLead() && this.options.onExitComplete) {
this.options.onExitComplete();
}
}
this.targetLayout = newLayout;
});
}
}
unmount() {
this.options.layoutId && this.willUpdate();
this.root.nodes.remove(this);
const stack = this.getStack();
stack && stack.remove(this);
this.parent && this.parent.children.delete(this);
this.instance = undefined;
cancelFrame(this.updateProjection);
}
// only on the root
blockUpdate() {
this.updateManuallyBlocked = true;
}
unblockUpdate() {
this.updateManuallyBlocked = false;
}
isUpdateBlocked() {
return this.updateManuallyBlocked || this.updateBlockedByResize;
}
isTreeAnimationBlocked() {
return (this.isAnimationBlocked ||
(this.parent && this.parent.isTreeAnimationBlocked()) ||
false);
}
// Note: currently only running on root node
startUpdate() {
if (this.isUpdateBlocked())
return;
this.isUpdating = true;
this.nodes && this.nodes.forEach(resetSkewAndRotation);
this.animationId++;
}
getTransformTemplate() {
const { visualElement } = this.options;
return visualElement && visualElement.getProps().transformTemplate;
}
willUpdate(shouldNotifyListeners = true) {
this.root.hasTreeAnimated = true;
if (this.root.isUpdateBlocked()) {
this.options.onExitComplete && this.options.onExitComplete();
return;
}
/**
* If we're running optimised appear animations then these must be
* cancelled before measuring the DOM. This is so we can measure
* the true layout of the element rather than the WAAPI animation
* which will be unaffected by the resetSkewAndRotate step.
*
* Note: This is a DOM write. Worst case scenario is this is sandwiched
* between other snapshot reads which will cause unnecessary style recalculations.
* This has to happen here though, as we don't yet know which nodes will need
* snapshots in startUpdate(), but we only want to cancel optimised animations
* if a layout animation measurement is actually going to be affected by them.
*/
if (window.MotionCancelOptimisedAnimation &&
!this.hasCheckedOptimisedAppear) {
cancelTreeOptimisedTransformAnimations(this);
}
!this.root.isUpdating && this.root.startUpdate();
if (this.isLayoutDirty)
return;
this.isLayoutDirty = true;
for (let i = 0; i < this.path.length; i++) {
const node = this.path[i];
node.shouldResetTransform = true;
node.updateScroll("snapshot");
if (node.options.layoutRoot) {
node.willUpdate(false);
}
}
const { layoutId, layout } = this.options;
if (layoutId === undefined && !layout)
return;
const transformTemplate = this.getTransformTemplate();
this.prevTransformTemplateValue = transformTemplate
? transformTemplate(this.latestValues, "")
: undefined;
this.updateSnapshot();
shouldNotifyListeners && this.notifyListeners("willUpdate");
}
update() {
this.updateScheduled = false;
const updateWasBlocked = this.isUpdateBlocked();
// When doing an instant transition, we skip the layout update,
// but should still clean up the measurements so that the next
// snapshot could be taken correctly.
if (updateWasBlocked) {
this.unblockUpdate();
this.clearAllSnapshots();
this.nodes.forEach(clearMeasurements);
return;
}
if (!this.isUpdating) {
this.nodes.forEach(clearIsLayoutDirty);
}
this.isUpdating = false;
/**
* Write
*/
this.nodes.forEach(resetTransformStyle);
/**
* Read ==================
*/
// Update layout measurements of updated children
this.nodes.forEach(updateLayout);
/**
* Write
*/
// Notify listeners that the layout is updated
this.nodes.forEach(notifyLayoutUpdate);
this.clearAllSnapshots();
/**
* Manually flush any pending updates. Ideally
* we could leave this to the following requestAnimationFrame but this seems
* to leave a flash of incorrectly styled content.
*/
const now = time.now();
frameData.delta = clamp_clamp(0, 1000 / 60, now - frameData.timestamp);
frameData.timestamp = now;
frameData.isProcessing = true;
frameSteps.update.process(frameData);
frameSteps.preRender.process(frameData);
frameSteps.render.process(frameData);
frameData.isProcessing = false;
}
didUpdate() {
if (!this.updateScheduled) {
this.updateScheduled = true;
microtask.read(this.scheduleUpdate);
}
}
clearAllSnapshots() {
this.nodes.forEach(clearSnapshot);
this.sharedNodes.forEach(removeLeadSnapshots);
}
scheduleUpdateProjection() {
if (!this.projectionUpdateScheduled) {
this.projectionUpdateScheduled = true;
frame_frame.preRender(this.updateProjection, false, true);
}
}
scheduleCheckAfterUnmount() {
/**
* If the unmounting node is in a layoutGroup and did trigger a willUpdate,
* we manually call didUpdate to give a chance to the siblings to animate.
* Otherwise, cleanup all snapshots to prevents future nodes from reusing them.
*/
frame_frame.postRender(() => {
if (this.isLayoutDirty) {
this.root.didUpdate();
}
else {
this.root.checkUpdateFailed();
}
});
}
/**
* Update measurements
*/
updateSnapshot() {
if (this.snapshot || !this.instance)
return;
this.snapshot = this.measure();
}
updateLayout() {
if (!this.instance)
return;
// TODO: Incorporate into a forwarded scroll offset
this.updateScroll();
if (!(this.options.alwaysMeasureLayout && this.isLead()) &&
!this.isLayoutDirty) {
return;
}
/**
* When a node is mounted, it simply resumes from the prevLead's
* snapshot instead of taking a new one, but the ancestors scroll
* might have updated while the prevLead is unmounted. We need to
* update the scroll again to make sure the layout we measure is
* up to date.
*/
if (this.resumeFrom && !this.resumeFrom.instance) {
for (let i = 0; i < this.path.length; i++) {
const node = this.path[i];
node.updateScroll();
}
}
const prevLayout = this.layout;
this.layout = this.measure(false);
this.layoutCorrected = createBox();
this.isLayoutDirty = false;
this.projectionDelta = undefined;
this.notifyListeners("measure", this.layout.layoutBox);
const { visualElement } = this.options;
visualElement &&
visualElement.notify("LayoutMeasure", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : undefined);
}
updateScroll(phase = "measure") {
let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);
if (this.scroll &&
this.scroll.animationId === this.root.animationId &&
this.scroll.phase === phase) {
needsMeasurement = false;
}
if (needsMeasurement) {
const isRoot = checkIsScrollRoot(this.instance);
this.scroll = {
animationId: this.root.animationId,
phase,
isRoot,
offset: measureScroll(this.instance),
wasRoot: this.scroll ? this.scroll.isRoot : isRoot,
};
}
}
resetTransform() {
if (!resetTransform)
return;
const isResetRequested = this.isLayoutDirty ||
this.shouldResetTransform ||
this.options.alwaysMeasureLayout;
const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);
const transformTemplate = this.getTransformTemplate();
const transformTemplateValue = transformTemplate
? transformTemplate(this.latestValues, "")
: undefined;
const transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;
if (isResetRequested &&
(hasProjection ||
hasTransform(this.latestValues) ||
transformTemplateHasChanged)) {
resetTransform(this.instance, transformTemplateValue);
this.shouldResetTransform = false;
this.scheduleRender();
}
}
measure(removeTransform = true) {
const pageBox = this.measurePageBox();
let layoutBox = this.removeElementScroll(pageBox);
/**
* Measurements taken during the pre-render stage
* still have transforms applied so we remove them
* via calculation.
*/
if (removeTransform) {
layoutBox = this.removeTransform(layoutBox);
}
roundBox(layoutBox);
return {
animationId: this.root.animationId,
measuredBox: pageBox,
layoutBox,
latestValues: {},
source: this.id,
};
}
measurePageBox() {
var _a;
const { visualElement } = this.options;
if (!visualElement)
return createBox();
const box = visualElement.measureViewportBox();
const wasInScrollRoot = ((_a = this.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot) || this.path.some(checkNodeWasScrollRoot);
if (!wasInScrollRoot) {
// Remove viewport scroll to give page-relative coordinates
const { scroll } = this.root;
if (scroll) {
translateAxis(box.x, scroll.offset.x);
translateAxis(box.y, scroll.offset.y);
}
}
return box;
}
removeElementScroll(box) {
var _a;
const boxWithoutScroll = createBox();
copyBoxInto(boxWithoutScroll, box);
if ((_a = this.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot) {
return boxWithoutScroll;
}
/**
* Performance TODO: Keep a cumulative scroll offset down the tree
* rather than loop back up the path.
*/
for (let i = 0; i < this.path.length; i++) {
const node = this.path[i];
const { scroll, options } = node;
if (node !== this.root && scroll && options.layoutScroll) {
/**
* If this is a new scroll root, we want to remove all previous scrolls
* from the viewport box.
*/
if (scroll.wasRoot) {
copyBoxInto(boxWithoutScroll, box);
}
translateAxis(boxWithoutScroll.x, scroll.offset.x);
translateAxis(boxWithoutScroll.y, scroll.offset.y);
}
}
return boxWithoutScroll;
}
applyTransform(box, transformOnly = false) {
const withTransforms = createBox();
copyBoxInto(withTransforms, box);
for (let i = 0; i < this.path.length; i++) {
const node = this.path[i];
if (!transformOnly &&
node.options.layoutScroll &&
node.scroll &&
node !== node.root) {
transformBox(withTransforms, {
x: -node.scroll.offset.x,
y: -node.scroll.offset.y,
});
}
if (!hasTransform(node.latestValues))
continue;
transformBox(withTransforms, node.latestValues);
}
if (hasTransform(this.latestValues)) {
transformBox(withTransforms, this.latestValues);
}
return withTransforms;
}
removeTransform(box) {
const boxWithoutTransform = createBox();
copyBoxInto(boxWithoutTransform, box);
for (let i = 0; i < this.path.length; i++) {
const node = this.path[i];
if (!node.instance)
continue;
if (!hasTransform(node.latestValues))
continue;
hasScale(node.latestValues) && node.updateSnapshot();
const sourceBox = createBox();
const nodeBox = node.measurePageBox();
copyBoxInto(sourceBox, nodeBox);
removeBoxTransforms(boxWithoutTransform, node.latestValues, node.snapshot ? node.snapshot.layoutBox : undefined, sourceBox);
}
if (hasTransform(this.latestValues)) {
removeBoxTransforms(boxWithoutTransform, this.latestValues);
}
return boxWithoutTransform;
}
setTargetDelta(delta) {
this.targetDelta = delta;
this.root.scheduleUpdateProjection();
this.isProjectionDirty = true;
}
setOptions(options) {
this.options = {
...this.options,
...options,
crossfade: options.crossfade !== undefined ? options.crossfade : true,
};
}
clearMeasurements() {
this.scroll = undefined;
this.layout = undefined;
this.snapshot = undefined;
this.prevTransformTemplateValue = undefined;
this.targetDelta = undefined;
this.target = undefined;
this.isLayoutDirty = false;
}
forceRelativeParentToResolveTarget() {
if (!this.relativeParent)
return;
/**
* If the parent target isn't up-to-date, force it to update.
* This is an unfortunate de-optimisation as it means any updating relative
* projection will cause all the relative parents to recalculate back
* up the tree.
*/
if (this.relativeParent.resolvedRelativeTargetAt !==
frameData.timestamp) {
this.relativeParent.resolveTargetDelta(true);
}
}
resolveTargetDelta(forceRecalculation = false) {
var _a;
/**
* Once the dirty status of nodes has been spread through the tree, we also
* need to check if we have a shared node of a different depth that has itself
* been dirtied.
*/
const lead = this.getLead();
this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);
this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);
this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);
const isShared = Boolean(this.resumingFrom) || this !== lead;
/**
* We don't use transform for this step of processing so we don't
* need to check whether any nodes have changed transform.
*/
const canSkip = !(forceRecalculation ||
(isShared && this.isSharedProjectionDirty) ||
this.isProjectionDirty ||
((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty) ||
this.attemptToResolveRelativeTarget ||
this.root.updateBlockedByResize);
if (canSkip)
return;
const { layout, layoutId } = this.options;
/**
* If we have no layout, we can't perform projection, so early return
*/
if (!this.layout || !(layout || layoutId))
return;
this.resolvedRelativeTargetAt = frameData.timestamp;
/**
* If we don't have a targetDelta but do have a layout, we can attempt to resolve
* a relativeParent. This will allow a component to perform scale correction
* even if no animation has started.
*/
if (!this.targetDelta && !this.relativeTarget) {
const relativeParent = this.getClosestProjectingParent();
if (relativeParent &&
relativeParent.layout &&
this.animationProgress !== 1) {
this.relativeParent = relativeParent;
this.forceRelativeParentToResolveTarget();
this.relativeTarget = createBox();
this.relativeTargetOrigin = createBox();
calcRelativePosition(this.relativeTargetOrigin, this.layout.layoutBox, relativeParent.layout.layoutBox);
copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);
}
else {
this.relativeParent = this.relativeTarget = undefined;
}
}
/**
* If we have no relative target or no target delta our target isn't valid
* for this frame.
*/
if (!this.relativeTarget && !this.targetDelta)
return;
/**
* Lazy-init target data structure
*/
if (!this.target) {
this.target = createBox();
this.targetWithTransforms = createBox();
}
/**
* If we've got a relative box for this component, resolve it into a target relative to the parent.
*/
if (this.relativeTarget &&
this.relativeTargetOrigin &&
this.relativeParent &&
this.relativeParent.target) {
this.forceRelativeParentToResolveTarget();
calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);
/**
* If we've only got a targetDelta, resolve it into a target
*/
}
else if (this.targetDelta) {
if (Boolean(this.resumingFrom)) {
// TODO: This is creating a new object every frame
this.target = this.applyTransform(this.layout.layoutBox);
}
else {
copyBoxInto(this.target, this.layout.layoutBox);
}
applyBoxDelta(this.target, this.targetDelta);
}
else {
/**
* If no target, use own layout as target
*/
copyBoxInto(this.target, this.layout.layoutBox);
}
/**
* If we've been told to attempt to resolve a relative target, do so.
*/
if (this.attemptToResolveRelativeTarget) {
this.attemptToResolveRelativeTarget = false;
const relativeParent = this.getClosestProjectingParent();
if (relativeParent &&
Boolean(relativeParent.resumingFrom) ===
Boolean(this.resumingFrom) &&
!relativeParent.options.layoutScroll &&
relativeParent.target &&
this.animationProgress !== 1) {
this.relativeParent = relativeParent;
this.forceRelativeParentToResolveTarget();
this.relativeTarget = createBox();
this.relativeTargetOrigin = createBox();
calcRelativePosition(this.relativeTargetOrigin, this.target, relativeParent.target);
copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);
}
else {
this.relativeParent = this.relativeTarget = undefined;
}
}
/**
* Increase debug counter for resolved target deltas
*/
if (isDebug) {
metrics.resolvedTargetDeltas++;
}
}
getClosestProjectingParent() {
if (!this.parent ||
hasScale(this.parent.latestValues) ||
has2DTranslate(this.parent.latestValues)) {
return undefined;
}
if (this.parent.isProjecting()) {
return this.parent;
}
else {
return this.parent.getClosestProjectingParent();
}
}
isProjecting() {
return Boolean((this.relativeTarget ||
this.targetDelta ||
this.options.layoutRoot) &&
this.layout);
}
calcProjection() {
var _a;
const lead = this.getLead();
const isShared = Boolean(this.resumingFrom) || this !== lead;
let canSkip = true;
/**
* If this is a normal layout animation and neither this node nor its nearest projecting
* is dirty then we can't skip.
*/
if (this.isProjectionDirty || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty)) {
canSkip = false;
}
/**
* If this is a shared layout animation and this node's shared projection is dirty then
* we can't skip.
*/
if (isShared &&
(this.isSharedProjectionDirty || this.isTransformDirty)) {
canSkip = false;
}
/**
* If we have resolved the target this frame we must recalculate the
* projection to ensure it visually represents the internal calculations.
*/
if (this.resolvedRelativeTargetAt === frameData.timestamp) {
canSkip = false;
}
if (canSkip)
return;
const { layout, layoutId } = this.options;
/**
* If this section of the tree isn't animating we can
* delete our target sources for the following frame.
*/
this.isTreeAnimating = Boolean((this.parent && this.parent.isTreeAnimating) ||
this.currentAnimation ||
this.pendingAnimation);
if (!this.isTreeAnimating) {
this.targetDelta = this.relativeTarget = undefined;
}
if (!this.layout || !(layout || layoutId))
return;
/**
* Reset the corrected box with the latest values from box, as we're then going
* to perform mutative operations on it.
*/
copyBoxInto(this.layoutCorrected, this.layout.layoutBox);
/**
* Record previous tree scales before updating.
*/
const prevTreeScaleX = this.treeScale.x;
const prevTreeScaleY = this.treeScale.y;
/**
* Apply all the parent deltas to this box to produce the corrected box. This
* is the layout box, as it will appear on screen as a result of the transforms of its parents.
*/
applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, isShared);
/**
* If this layer needs to perform scale correction but doesn't have a target,
* use the layout as the target.
*/
if (lead.layout &&
!lead.target &&
(this.treeScale.x !== 1 || this.treeScale.y !== 1)) {
lead.target = lead.layout.layoutBox;
lead.targetWithTransforms = createBox();
}
const { target } = lead;
if (!target) {
/**
* If we don't have a target to project into, but we were previously
* projecting, we want to remove the stored transform and schedule
* a render to ensure the elements reflect the removed transform.
*/
if (this.prevProjectionDelta) {
this.createProjectionDeltas();
this.scheduleRender();
}
return;
}
if (!this.projectionDelta || !this.prevProjectionDelta) {
this.createProjectionDeltas();
}
else {
copyAxisDeltaInto(this.prevProjectionDelta.x, this.projectionDelta.x);
copyAxisDeltaInto(this.prevProjectionDelta.y, this.projectionDelta.y);
}
/**
* Update the delta between the corrected box and the target box before user-set transforms were applied.
* This will allow us to calculate the corrected borderRadius and boxShadow to compensate
* for our layout reprojection, but still allow them to be scaled correctly by the user.
* It might be that to simplify this we may want to accept that user-set scale is also corrected
* and we wouldn't have to keep and calc both deltas, OR we could support a user setting
* to allow people to choose whether these styles are corrected based on just the
* layout reprojection or the final bounding box.
*/
calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);
if (this.treeScale.x !== prevTreeScaleX ||
this.treeScale.y !== prevTreeScaleY ||
!axisDeltaEquals(this.projectionDelta.x, this.prevProjectionDelta.x) ||
!axisDeltaEquals(this.projectionDelta.y, this.prevProjectionDelta.y)) {
this.hasProjected = true;
this.scheduleRender();
this.notifyListeners("projectionUpdate", target);
}
/**
* Increase debug counter for recalculated projections
*/
if (isDebug) {
metrics.recalculatedProjection++;
}
}
hide() {
this.isVisible = false;
// TODO: Schedule render
}
show() {
this.isVisible = true;
// TODO: Schedule render
}
scheduleRender(notifyAll = true) {
var _a;
(_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.scheduleRender();
if (notifyAll) {
const stack = this.getStack();
stack && stack.scheduleRender();
}
if (this.resumingFrom && !this.resumingFrom.instance) {
this.resumingFrom = undefined;
}
}
createProjectionDeltas() {
this.prevProjectionDelta = createDelta();
this.projectionDelta = createDelta();
this.projectionDeltaWithTransform = createDelta();
}
setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {
const snapshot = this.snapshot;
const snapshotLatestValues = snapshot
? snapshot.latestValues
: {};
const mixedValues = { ...this.latestValues };
const targetDelta = createDelta();
if (!this.relativeParent ||
!this.relativeParent.options.layoutRoot) {
this.relativeTarget = this.relativeTargetOrigin = undefined;
}
this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;
const relativeLayout = createBox();
const snapshotSource = snapshot ? snapshot.source : undefined;
const layoutSource = this.layout ? this.layout.source : undefined;
const isSharedLayoutAnimation = snapshotSource !== layoutSource;
const stack = this.getStack();
const isOnlyMember = !stack || stack.members.length <= 1;
const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&
!isOnlyMember &&
this.options.crossfade === true &&
!this.path.some(hasOpacityCrossfade));
this.animationProgress = 0;
let prevRelativeTarget;
this.mixTargetDelta = (latest) => {
const progress = latest / 1000;
mixAxisDelta(targetDelta.x, delta.x, progress);
mixAxisDelta(targetDelta.y, delta.y, progress);
this.setTargetDelta(targetDelta);
if (this.relativeTarget &&
this.relativeTargetOrigin &&
this.layout &&
this.relativeParent &&
this.relativeParent.layout) {
calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);
mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);
/**
* If this is an unchanged relative target we can consider the
* projection not dirty.
*/
if (prevRelativeTarget &&
boxEquals(this.relativeTarget, prevRelativeTarget)) {
this.isProjectionDirty = false;
}
if (!prevRelativeTarget)
prevRelativeTarget = createBox();
copyBoxInto(prevRelativeTarget, this.relativeTarget);
}
if (isSharedLayoutAnimation) {
this.animationValues = mixedValues;
mixValues(mixedValues, snapshotLatestValues, this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);
}
this.root.scheduleUpdateProjection();
this.scheduleRender();
this.animationProgress = progress;
};
this.mixTargetDelta(this.options.layoutRoot ? 1000 : 0);
}
startAnimation(options) {
this.notifyListeners("animationStart");
this.currentAnimation && this.currentAnimation.stop();
if (this.resumingFrom && this.resumingFrom.currentAnimation) {
this.resumingFrom.currentAnimation.stop();
}
if (this.pendingAnimation) {
cancelFrame(this.pendingAnimation);
this.pendingAnimation = undefined;
}
/**
* Start the animation in the next frame to have a frame with progress 0,
* where the target is the same as when the animation started, so we can
* calculate the relative positions correctly for instant transitions.
*/
this.pendingAnimation = frame_frame.update(() => {
globalProjectionState.hasAnimatedSinceResize = true;
this.currentAnimation = animateSingleValue(0, animationTarget, {
...options,
onUpdate: (latest) => {
this.mixTargetDelta(latest);
options.onUpdate && options.onUpdate(latest);
},
onComplete: () => {
options.onComplete && options.onComplete();
this.completeAnimation();
},
});
if (this.resumingFrom) {
this.resumingFrom.currentAnimation = this.currentAnimation;
}
this.pendingAnimation = undefined;
});
}
completeAnimation() {
if (this.resumingFrom) {
this.resumingFrom.currentAnimation = undefined;
this.resumingFrom.preserveOpacity = undefined;
}
const stack = this.getStack();
stack && stack.exitAnimationComplete();
this.resumingFrom =
this.currentAnimation =
this.animationValues =
undefined;
this.notifyListeners("animationComplete");
}
finishAnimation() {
if (this.currentAnimation) {
this.mixTargetDelta && this.mixTargetDelta(animationTarget);
this.currentAnimation.stop();
}
this.completeAnimation();
}
applyTransformsToTarget() {
const lead = this.getLead();
let { targetWithTransforms, target, layout, latestValues } = lead;
if (!targetWithTransforms || !target || !layout)
return;
/**
* If we're only animating position, and this element isn't the lead element,
* then instead of projecting into the lead box we instead want to calculate
* a new target that aligns the two boxes but maintains the layout shape.
*/
if (this !== lead &&
this.layout &&
layout &&
shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout.layoutBox)) {
target = this.target || createBox();
const xLength = calcLength(this.layout.layoutBox.x);
target.x.min = lead.target.x.min;
target.x.max = target.x.min + xLength;
const yLength = calcLength(this.layout.layoutBox.y);
target.y.min = lead.target.y.min;
target.y.max = target.y.min + yLength;
}
copyBoxInto(targetWithTransforms, target);
/**
* Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.
* This is the final box that we will then project into by calculating a transform delta and
* applying it to the corrected box.
*/
transformBox(targetWithTransforms, latestValues);
/**
* Update the delta between the corrected box and the final target box, after
* user-set transforms are applied to it. This will be used by the renderer to
* create a transform style that will reproject the element from its layout layout
* into the desired bounding box.
*/
calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);
}
registerSharedNode(layoutId, node) {
if (!this.sharedNodes.has(layoutId)) {
this.sharedNodes.set(layoutId, new NodeStack());
}
const stack = this.sharedNodes.get(layoutId);
stack.add(node);
const config = node.options.initialPromotionConfig;
node.promote({
transition: config ? config.transition : undefined,
preserveFollowOpacity: config && config.shouldPreserveFollowOpacity
? config.shouldPreserveFollowOpacity(node)
: undefined,
});
}
isLead() {
const stack = this.getStack();
return stack ? stack.lead === this : true;
}
getLead() {
var _a;
const { layoutId } = this.options;
return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;
}
getPrevLead() {
var _a;
const { layoutId } = this.options;
return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;
}
getStack() {
const { layoutId } = this.options;
if (layoutId)
return this.root.sharedNodes.get(layoutId);
}
promote({ needsReset, transition, preserveFollowOpacity, } = {}) {
const stack = this.getStack();
if (stack)
stack.promote(this, preserveFollowOpacity);
if (needsReset) {
this.projectionDelta = undefined;
this.needsReset = true;
}
if (transition)
this.setOptions({ transition });
}
relegate() {
const stack = this.getStack();
if (stack) {
return stack.relegate(this);
}
else {
return false;
}
}
resetSkewAndRotation() {
const { visualElement } = this.options;
if (!visualElement)
return;
// If there's no detected skew or rotation values, we can early return without a forced render.
let hasDistortingTransform = false;
/**
* An unrolled check for rotation values. Most elements don't have any rotation and
* skipping the nested loop and new object creation is 50% faster.
*/
const { latestValues } = visualElement;
if (latestValues.z ||
latestValues.rotate ||
latestValues.rotateX ||
latestValues.rotateY ||
latestValues.rotateZ ||
latestValues.skewX ||
latestValues.skewY) {
hasDistortingTransform = true;
}
// If there's no distorting values, we don't need to do any more.
if (!hasDistortingTransform)
return;
const resetValues = {};
if (latestValues.z) {
resetDistortingTransform("z", visualElement, resetValues, this.animationValues);
}
// Check the skew and rotate value of all axes and reset to 0
for (let i = 0; i < transformAxes.length; i++) {
resetDistortingTransform(`rotate${transformAxes[i]}`, visualElement, resetValues, this.animationValues);
resetDistortingTransform(`skew${transformAxes[i]}`, visualElement, resetValues, this.animationValues);
}
// Force a render of this element to apply the transform with all skews and rotations
// set to 0.
visualElement.render();
// Put back all the values we reset
for (const key in resetValues) {
visualElement.setStaticValue(key, resetValues[key]);
if (this.animationValues) {
this.animationValues[key] = resetValues[key];
}
}
// Schedule a render for the next frame. This ensures we won't visually
// see the element with the reset rotate value applied.
visualElement.scheduleRender();
}
getProjectionStyles(styleProp) {
var _a, _b;
if (!this.instance || this.isSVG)
return undefined;
if (!this.isVisible) {
return hiddenVisibility;
}
const styles = {
visibility: "",
};
const transformTemplate = this.getTransformTemplate();
if (this.needsReset) {
this.needsReset = false;
styles.opacity = "";
styles.pointerEvents =
resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || "";
styles.transform = transformTemplate
? transformTemplate(this.latestValues, "")
: "none";
return styles;
}
const lead = this.getLead();
if (!this.projectionDelta || !this.layout || !lead.target) {
const emptyStyles = {};
if (this.options.layoutId) {
emptyStyles.opacity =
this.latestValues.opacity !== undefined
? this.latestValues.opacity
: 1;
emptyStyles.pointerEvents =
resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || "";
}
if (this.hasProjected && !hasTransform(this.latestValues)) {
emptyStyles.transform = transformTemplate
? transformTemplate({}, "")
: "none";
this.hasProjected = false;
}
return emptyStyles;
}
const valuesToRender = lead.animationValues || lead.latestValues;
this.applyTransformsToTarget();
styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);
if (transformTemplate) {
styles.transform = transformTemplate(valuesToRender, styles.transform);
}
const { x, y } = this.projectionDelta;
styles.transformOrigin = `${x.origin * 100}% ${y.origin * 100}% 0`;
if (lead.animationValues) {
/**
* If the lead component is animating, assign this either the entering/leaving
* opacity
*/
styles.opacity =
lead === this
? (_b = (_a = valuesToRender.opacity) !== null && _a !== void 0 ? _a : this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1
: this.preserveOpacity
? this.latestValues.opacity
: valuesToRender.opacityExit;
}
else {
/**
* Or we're not animating at all, set the lead component to its layout
* opacity and other components to hidden.
*/
styles.opacity =
lead === this
? valuesToRender.opacity !== undefined
? valuesToRender.opacity
: ""
: valuesToRender.opacityExit !== undefined
? valuesToRender.opacityExit
: 0;
}
/**
* Apply scale correction
*/
for (const key in scaleCorrectors) {
if (valuesToRender[key] === undefined)
continue;
const { correct, applyTo } = scaleCorrectors[key];
/**
* Only apply scale correction to the value if we have an
* active projection transform. Otherwise these values become
* vulnerable to distortion if the element changes size without
* a corresponding layout animation.
*/
const corrected = styles.transform === "none"
? valuesToRender[key]
: correct(valuesToRender[key], lead);
if (applyTo) {
const num = applyTo.length;
for (let i = 0; i < num; i++) {
styles[applyTo[i]] = corrected;
}
}
else {
styles[key] = corrected;
}
}
/**
* Disable pointer events on follow components. This is to ensure
* that if a follow component covers a lead component it doesn't block
* pointer events on the lead.
*/
if (this.options.layoutId) {
styles.pointerEvents =
lead === this
? resolveMotionValue(styleProp === null || styleProp === void 0 ? void 0 : styleProp.pointerEvents) || ""
: "none";
}
return styles;
}
clearSnapshot() {
this.resumeFrom = this.snapshot = undefined;
}
// Only run on root
resetTree() {
this.root.nodes.forEach((node) => { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });
this.root.nodes.forEach(clearMeasurements);
this.root.sharedNodes.clear();
}
};
}
function updateLayout(node) {
node.updateLayout();
}
function notifyLayoutUpdate(node) {
var _a;
const snapshot = ((_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) || node.snapshot;
if (node.isLead() &&
node.layout &&
snapshot &&
node.hasListeners("didUpdate")) {
const { layoutBox: layout, measuredBox: measuredLayout } = node.layout;
const { animationType } = node.options;
const isShared = snapshot.source !== node.layout.source;
// TODO Maybe we want to also resize the layout snapshot so we don't trigger
// animations for instance if layout="size" and an element has only changed position
if (animationType === "size") {
eachAxis((axis) => {
const axisSnapshot = isShared
? snapshot.measuredBox[axis]
: snapshot.layoutBox[axis];
const length = calcLength(axisSnapshot);
axisSnapshot.min = layout[axis].min;
axisSnapshot.max = axisSnapshot.min + length;
});
}
else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout)) {
eachAxis((axis) => {
const axisSnapshot = isShared
? snapshot.measuredBox[axis]
: snapshot.layoutBox[axis];
const length = calcLength(layout[axis]);
axisSnapshot.max = axisSnapshot.min + length;
/**
* Ensure relative target gets resized and rerendererd
*/
if (node.relativeTarget && !node.currentAnimation) {
node.isProjectionDirty = true;
node.relativeTarget[axis].max =
node.relativeTarget[axis].min + length;
}
});
}
const layoutDelta = createDelta();
calcBoxDelta(layoutDelta, layout, snapshot.layoutBox);
const visualDelta = createDelta();
if (isShared) {
calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measuredBox);
}
else {
calcBoxDelta(visualDelta, layout, snapshot.layoutBox);
}
const hasLayoutChanged = !isDeltaZero(layoutDelta);
let hasRelativeTargetChanged = false;
if (!node.resumeFrom) {
const relativeParent = node.getClosestProjectingParent();
/**
* If the relativeParent is itself resuming from a different element then
* the relative snapshot is not relavent
*/
if (relativeParent && !relativeParent.resumeFrom) {
const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;
if (parentSnapshot && parentLayout) {
const relativeSnapshot = createBox();
calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox);
const relativeLayout = createBox();
calcRelativePosition(relativeLayout, layout, parentLayout.layoutBox);
if (!boxEqualsRounded(relativeSnapshot, relativeLayout)) {
hasRelativeTargetChanged = true;
}
if (relativeParent.options.layoutRoot) {
node.relativeTarget = relativeLayout;
node.relativeTargetOrigin = relativeSnapshot;
node.relativeParent = relativeParent;
}
}
}
}
node.notifyListeners("didUpdate", {
layout,
snapshot,
delta: visualDelta,
layoutDelta,
hasLayoutChanged,
hasRelativeTargetChanged,
});
}
else if (node.isLead()) {
const { onExitComplete } = node.options;
onExitComplete && onExitComplete();
}
/**
* Clearing transition
* TODO: Investigate why this transition is being passed in as {type: false } from Framer
* and why we need it at all
*/
node.options.transition = undefined;
}
function propagateDirtyNodes(node) {
/**
* Increase debug counter for nodes encountered this frame
*/
if (isDebug) {
metrics.totalNodes++;
}
if (!node.parent)
return;
/**
* If this node isn't projecting, propagate isProjectionDirty. It will have
* no performance impact but it will allow the next child that *is* projecting
* but *isn't* dirty to just check its parent to see if *any* ancestor needs
* correcting.
*/
if (!node.isProjecting()) {
node.isProjectionDirty = node.parent.isProjectionDirty;
}
/**
* Propagate isSharedProjectionDirty and isTransformDirty
* throughout the whole tree. A future revision can take another look at
* this but for safety we still recalcualte shared nodes.
*/
node.isSharedProjectionDirty || (node.isSharedProjectionDirty = Boolean(node.isProjectionDirty ||
node.parent.isProjectionDirty ||
node.parent.isSharedProjectionDirty));
node.isTransformDirty || (node.isTransformDirty = node.parent.isTransformDirty);
}
function cleanDirtyNodes(node) {
node.isProjectionDirty =
node.isSharedProjectionDirty =
node.isTransformDirty =
false;
}
function clearSnapshot(node) {
node.clearSnapshot();
}
function clearMeasurements(node) {
node.clearMeasurements();
}
function clearIsLayoutDirty(node) {
node.isLayoutDirty = false;
}
function resetTransformStyle(node) {
const { visualElement } = node.options;
if (visualElement && visualElement.getProps().onBeforeLayoutMeasure) {
visualElement.notify("BeforeLayoutMeasure");
}
node.resetTransform();
}
function finishAnimation(node) {
node.finishAnimation();
node.targetDelta = node.relativeTarget = node.target = undefined;
node.isProjectionDirty = true;
}
function resolveTargetDelta(node) {
node.resolveTargetDelta();
}
function calcProjection(node) {
node.calcProjection();
}
function resetSkewAndRotation(node) {
node.resetSkewAndRotation();
}
function removeLeadSnapshots(stack) {
stack.removeLeadSnapshot();
}
function mixAxisDelta(output, delta, p) {
output.translate = mixNumber(delta.translate, 0, p);
output.scale = mixNumber(delta.scale, 1, p);
output.origin = delta.origin;
output.originPoint = delta.originPoint;
}
function mixAxis(output, from, to, p) {
output.min = mixNumber(from.min, to.min, p);
output.max = mixNumber(from.max, to.max, p);
}
function mixBox(output, from, to, p) {
mixAxis(output.x, from.x, to.x, p);
mixAxis(output.y, from.y, to.y, p);
}
function hasOpacityCrossfade(node) {
return (node.animationValues && node.animationValues.opacityExit !== undefined);
}
const defaultLayoutTransition = {
duration: 0.45,
ease: [0.4, 0, 0.1, 1],
};
const userAgentContains = (string) => typeof navigator !== "undefined" &&
navigator.userAgent &&
navigator.userAgent.toLowerCase().includes(string);
/**
* Measured bounding boxes must be rounded in Safari and
* left untouched in Chrome, otherwise non-integer layouts within scaled-up elements
* can appear to jump.
*/
const roundPoint = userAgentContains("applewebkit/") && !userAgentContains("chrome/")
? Math.round
: noop_noop;
function roundAxis(axis) {
// Round to the nearest .5 pixels to support subpixel layouts
axis.min = roundPoint(axis.min);
axis.max = roundPoint(axis.max);
}
function roundBox(box) {
roundAxis(box.x);
roundAxis(box.y);
}
function shouldAnimatePositionOnly(animationType, snapshot, layout) {
return (animationType === "position" ||
(animationType === "preserve-aspect" &&
!isNear(aspectRatio(snapshot), aspectRatio(layout), 0.2)));
}
function checkNodeWasScrollRoot(node) {
var _a;
return node !== node.root && ((_a = node.scroll) === null || _a === void 0 ? void 0 : _a.wasRoot);
}
;// ./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs
const DocumentProjectionNode = createProjectionNode({
attachResizeListener: (ref, notify) => addDomEvent(ref, "resize", notify),
measureScroll: () => ({
x: document.documentElement.scrollLeft || document.body.scrollLeft,
y: document.documentElement.scrollTop || document.body.scrollTop,
}),
checkIsScrollRoot: () => true,
});
;// ./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs
const rootProjectionNode = {
current: undefined,
};
const HTMLProjectionNode = createProjectionNode({
measureScroll: (instance) => ({
x: instance.scrollLeft,
y: instance.scrollTop,
}),
defaultParent: () => {
if (!rootProjectionNode.current) {
const documentNode = new DocumentProjectionNode({});
documentNode.mount(window);
documentNode.setOptions({ layoutScroll: true });
rootProjectionNode.current = documentNode;
}
return rootProjectionNode.current;
},
resetTransform: (instance, value) => {
instance.style.transform = value !== undefined ? value : "none";
},
checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === "fixed"),
});
;// ./node_modules/framer-motion/dist/es/motion/features/drag.mjs
const drag = {
pan: {
Feature: PanGesture,
},
drag: {
Feature: DragGesture,
ProjectionNode: HTMLProjectionNode,
MeasureLayout: MeasureLayout,
},
};
;// ./node_modules/framer-motion/dist/es/gestures/hover.mjs
function handleHoverEvent(node, event, lifecycle) {
const { props } = node;
if (node.animationState && props.whileHover) {
node.animationState.setActive("whileHover", lifecycle === "Start");
}
const eventName = ("onHover" + lifecycle);
const callback = props[eventName];
if (callback) {
frame_frame.postRender(() => callback(event, extractEventInfo(event)));
}
}
class HoverGesture extends Feature {
mount() {
const { current } = this.node;
if (!current)
return;
this.unmount = hover(current, (startEvent) => {
handleHoverEvent(this.node, startEvent, "Start");
return (endEvent) => handleHoverEvent(this.node, endEvent, "End");
});
}
unmount() { }
}
;// ./node_modules/framer-motion/dist/es/gestures/focus.mjs
class FocusGesture extends Feature {
constructor() {
super(...arguments);
this.isActive = false;
}
onFocus() {
let isFocusVisible = false;
/**
* If this element doesn't match focus-visible then don't
* apply whileHover. But, if matches throws that focus-visible
* is not a valid selector then in that browser outline styles will be applied
* to the element by default and we want to match that behaviour with whileFocus.
*/
try {
isFocusVisible = this.node.current.matches(":focus-visible");
}
catch (e) {
isFocusVisible = true;
}
if (!isFocusVisible || !this.node.animationState)
return;
this.node.animationState.setActive("whileFocus", true);
this.isActive = true;
}
onBlur() {
if (!this.isActive || !this.node.animationState)
return;
this.node.animationState.setActive("whileFocus", false);
this.isActive = false;
}
mount() {
this.unmount = pipe(addDomEvent(this.node.current, "focus", () => this.onFocus()), addDomEvent(this.node.current, "blur", () => this.onBlur()));
}
unmount() { }
}
;// ./node_modules/framer-motion/dist/es/gestures/press.mjs
function handlePressEvent(node, event, lifecycle) {
const { props } = node;
if (node.animationState && props.whileTap) {
node.animationState.setActive("whileTap", lifecycle === "Start");
}
const eventName = ("onTap" + (lifecycle === "End" ? "" : lifecycle));
const callback = props[eventName];
if (callback) {
frame_frame.postRender(() => callback(event, extractEventInfo(event)));
}
}
class PressGesture extends Feature {
mount() {
const { current } = this.node;
if (!current)
return;
this.unmount = press(current, (startEvent) => {
handlePressEvent(this.node, startEvent, "Start");
return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? "End" : "Cancel");
}, { useGlobalTarget: this.node.props.globalTapTarget });
}
unmount() { }
}
;// ./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs
/**
* Map an IntersectionHandler callback to an element. We only ever make one handler for one
* element, so even though these handlers might all be triggered by different
* observers, we can keep them in the same map.
*/
const observerCallbacks = new WeakMap();
/**
* Multiple observers can be created for multiple element/document roots. Each with
* different settings. So here we store dictionaries of observers to each root,
* using serialised settings (threshold/margin) as lookup keys.
*/
const observers = new WeakMap();
const fireObserverCallback = (entry) => {
const callback = observerCallbacks.get(entry.target);
callback && callback(entry);
};
const fireAllObserverCallbacks = (entries) => {
entries.forEach(fireObserverCallback);
};
function initIntersectionObserver({ root, ...options }) {
const lookupRoot = root || document;
/**
* If we don't have an observer lookup map for this root, create one.
*/
if (!observers.has(lookupRoot)) {
observers.set(lookupRoot, {});
}
const rootObservers = observers.get(lookupRoot);
const key = JSON.stringify(options);
/**
* If we don't have an observer for this combination of root and settings,
* create one.
*/
if (!rootObservers[key]) {
rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });
}
return rootObservers[key];
}
function observeIntersection(element, options, callback) {
const rootInteresectionObserver = initIntersectionObserver(options);
observerCallbacks.set(element, callback);
rootInteresectionObserver.observe(element);
return () => {
observerCallbacks.delete(element);
rootInteresectionObserver.unobserve(element);
};
}
;// ./node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs
const thresholdNames = {
some: 0,
all: 1,
};
class InViewFeature extends Feature {
constructor() {
super(...arguments);
this.hasEnteredView = false;
this.isInView = false;
}
startObserver() {
this.unmount();
const { viewport = {} } = this.node.getProps();
const { root, margin: rootMargin, amount = "some", once } = viewport;
const options = {
root: root ? root.current : undefined,
rootMargin,
threshold: typeof amount === "number" ? amount : thresholdNames[amount],
};
const onIntersectionUpdate = (entry) => {
const { isIntersecting } = entry;
/**
* If there's been no change in the viewport state, early return.
*/
if (this.isInView === isIntersecting)
return;
this.isInView = isIntersecting;
/**
* Handle hasEnteredView. If this is only meant to run once, and
* element isn't visible, early return. Otherwise set hasEnteredView to true.
*/
if (once && !isIntersecting && this.hasEnteredView) {
return;
}
else if (isIntersecting) {
this.hasEnteredView = true;
}
if (this.node.animationState) {
this.node.animationState.setActive("whileInView", isIntersecting);
}
/**
* Use the latest committed props rather than the ones in scope
* when this observer is created
*/
const { onViewportEnter, onViewportLeave } = this.node.getProps();
const callback = isIntersecting ? onViewportEnter : onViewportLeave;
callback && callback(entry);
};
return observeIntersection(this.node.current, options, onIntersectionUpdate);
}
mount() {
this.startObserver();
}
update() {
if (typeof IntersectionObserver === "undefined")
return;
const { props, prevProps } = this.node;
const hasOptionsChanged = ["amount", "margin", "root"].some(hasViewportOptionChanged(props, prevProps));
if (hasOptionsChanged) {
this.startObserver();
}
}
unmount() { }
}
function hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {
return (name) => viewport[name] !== prevViewport[name];
}
;// ./node_modules/framer-motion/dist/es/motion/features/gestures.mjs
const gestureAnimations = {
inView: {
Feature: InViewFeature,
},
tap: {
Feature: PressGesture,
},
focus: {
Feature: FocusGesture,
},
hover: {
Feature: HoverGesture,
},
};
;// ./node_modules/framer-motion/dist/es/motion/features/layout.mjs
const layout = {
layout: {
ProjectionNode: HTMLProjectionNode,
MeasureLayout: MeasureLayout,
},
};
;// ./node_modules/framer-motion/dist/es/context/LazyContext.mjs
"use client";
const LazyContext = (0,external_React_.createContext)({ strict: false });
;// ./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs
"use client";
const MotionContext = (0,external_React_.createContext)({});
;// ./node_modules/framer-motion/dist/es/render/utils/is-controlling-variants.mjs
function isControllingVariants(props) {
return (isAnimationControls(props.animate) ||
variantProps.some((name) => isVariantLabel(props[name])));
}
function isVariantNode(props) {
return Boolean(isControllingVariants(props) || props.variants);
}
;// ./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs
function getCurrentTreeVariants(props, context) {
if (isControllingVariants(props)) {
const { initial, animate } = props;
return {
initial: initial === false || isVariantLabel(initial)
? initial
: undefined,
animate: isVariantLabel(animate) ? animate : undefined,
};
}
return props.inherit !== false ? context : {};
}
;// ./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs
function useCreateMotionContext(props) {
const { initial, animate } = getCurrentTreeVariants(props, (0,external_React_.useContext)(MotionContext));
return (0,external_React_.useMemo)(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
}
function variantLabelsAsDependency(prop) {
return Array.isArray(prop) ? prop.join(" ") : prop;
}
;// ./node_modules/framer-motion/dist/es/motion/features/definitions.mjs
const featureProps = {
animation: [
"animate",
"variants",
"whileHover",
"whileTap",
"exit",
"whileInView",
"whileFocus",
"whileDrag",
],
exit: ["exit"],
drag: ["drag", "dragControls"],
focus: ["whileFocus"],
hover: ["whileHover", "onHoverStart", "onHoverEnd"],
tap: ["whileTap", "onTap", "onTapStart", "onTapCancel"],
pan: ["onPan", "onPanStart", "onPanSessionStart", "onPanEnd"],
inView: ["whileInView", "onViewportEnter", "onViewportLeave"],
layout: ["layout", "layoutId"],
};
const featureDefinitions = {};
for (const key in featureProps) {
featureDefinitions[key] = {
isEnabled: (props) => featureProps[key].some((name) => !!props[name]),
};
}
;// ./node_modules/framer-motion/dist/es/motion/features/load-features.mjs
function loadFeatures(features) {
for (const key in features) {
featureDefinitions[key] = {
...featureDefinitions[key],
...features[key],
};
}
}
;// ./node_modules/framer-motion/dist/es/motion/utils/symbol.mjs
const motionComponentSymbol = Symbol.for("motionComponentSymbol");
;// ./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs
/**
* Creates a ref function that, when called, hydrates the provided
* external ref and VisualElement.
*/
function useMotionRef(visualState, visualElement, externalRef) {
return (0,external_React_.useCallback)((instance) => {
if (instance) {
visualState.onMount && visualState.onMount(instance);
}
if (visualElement) {
if (instance) {
visualElement.mount(instance);
}
else {
visualElement.unmount();
}
}
if (externalRef) {
if (typeof externalRef === "function") {
externalRef(instance);
}
else if (isRefObject(externalRef)) {
externalRef.current = instance;
}
}
},
/**
* Only pass a new ref callback to React if we've received a visual element
* factory. Otherwise we'll be mounting/remounting every time externalRef
* or other dependencies change.
*/
[visualElement]);
}
;// ./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs
function useVisualElement(Component, visualState, props, createVisualElement, ProjectionNodeConstructor) {
var _a, _b;
const { visualElement: parent } = (0,external_React_.useContext)(MotionContext);
const lazyContext = (0,external_React_.useContext)(LazyContext);
const presenceContext = (0,external_React_.useContext)(PresenceContext_PresenceContext);
const reducedMotionConfig = (0,external_React_.useContext)(MotionConfigContext).reducedMotion;
const visualElementRef = (0,external_React_.useRef)(null);
/**
* If we haven't preloaded a renderer, check to see if we have one lazy-loaded
*/
createVisualElement = createVisualElement || lazyContext.renderer;
if (!visualElementRef.current && createVisualElement) {
visualElementRef.current = createVisualElement(Component, {
visualState,
parent,
props,
presenceContext,
blockInitialAnimation: presenceContext
? presenceContext.initial === false
: false,
reducedMotionConfig,
});
}
const visualElement = visualElementRef.current;
/**
* Load Motion gesture and animation features. These are rendered as renderless
* components so each feature can optionally make use of React lifecycle methods.
*/
const initialLayoutGroupConfig = (0,external_React_.useContext)(SwitchLayoutGroupContext);
if (visualElement &&
!visualElement.projection &&
ProjectionNodeConstructor &&
(visualElement.type === "html" || visualElement.type === "svg")) {
use_visual_element_createProjectionNode(visualElementRef.current, props, ProjectionNodeConstructor, initialLayoutGroupConfig);
}
const isMounted = (0,external_React_.useRef)(false);
(0,external_React_.useInsertionEffect)(() => {
/**
* Check the component has already mounted before calling
* `update` unnecessarily. This ensures we skip the initial update.
*/
if (visualElement && isMounted.current) {
visualElement.update(props, presenceContext);
}
});
/**
* Cache this value as we want to know whether HandoffAppearAnimations
* was present on initial render - it will be deleted after this.
*/
const optimisedAppearId = props[optimizedAppearDataAttribute];
const wantsHandoff = (0,external_React_.useRef)(Boolean(optimisedAppearId) &&
!((_a = window.MotionHandoffIsComplete) === null || _a === void 0 ? void 0 : _a.call(window, optimisedAppearId)) &&
((_b = window.MotionHasOptimisedAnimation) === null || _b === void 0 ? void 0 : _b.call(window, optimisedAppearId)));
useIsomorphicLayoutEffect(() => {
if (!visualElement)
return;
isMounted.current = true;
window.MotionIsMounted = true;
visualElement.updateFeatures();
microtask.render(visualElement.render);
/**
* Ideally this function would always run in a useEffect.
*
* However, if we have optimised appear animations to handoff from,
* it needs to happen synchronously to ensure there's no flash of
* incorrect styles in the event of a hydration error.
*
* So if we detect a situtation where optimised appear animations
* are running, we use useLayoutEffect to trigger animations.
*/
if (wantsHandoff.current && visualElement.animationState) {
visualElement.animationState.animateChanges();
}
});
(0,external_React_.useEffect)(() => {
if (!visualElement)
return;
if (!wantsHandoff.current && visualElement.animationState) {
visualElement.animationState.animateChanges();
}
if (wantsHandoff.current) {
// This ensures all future calls to animateChanges() in this component will run in useEffect
queueMicrotask(() => {
var _a;
(_a = window.MotionHandoffMarkAsComplete) === null || _a === void 0 ? void 0 : _a.call(window, optimisedAppearId);
});
wantsHandoff.current = false;
}
});
return visualElement;
}
function use_visual_element_createProjectionNode(visualElement, props, ProjectionNodeConstructor, initialPromotionConfig) {
const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, } = props;
visualElement.projection = new ProjectionNodeConstructor(visualElement.latestValues, props["data-framer-portal-id"]
? undefined
: getClosestProjectingNode(visualElement.parent));
visualElement.projection.setOptions({
layoutId,
layout,
alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),
visualElement,
/**
* TODO: Update options in an effect. This could be tricky as it'll be too late
* to update by the time layout animations run.
* We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
* ensuring it gets called if there's no potential layout animations.
*
*/
animationType: typeof layout === "string" ? layout : "both",
initialPromotionConfig,
layoutScroll,
layoutRoot,
});
}
function getClosestProjectingNode(visualElement) {
if (!visualElement)
return undefined;
return visualElement.options.allowProjection !== false
? visualElement.projection
: getClosestProjectingNode(visualElement.parent);
}
;// ./node_modules/framer-motion/dist/es/motion/index.mjs
"use client";
/**
* Create a `motion` component.
*
* This function accepts a Component argument, which can be either a string (ie "div"
* for `motion.div`), or an actual React component.
*
* Alongside this is a config option which provides a way of rendering the provided
* component "offline", or outside the React render cycle.
*/
function createRendererMotionComponent({ preloadedFeatures, createVisualElement, useRender, useVisualState, Component, }) {
var _a, _b;
preloadedFeatures && loadFeatures(preloadedFeatures);
function MotionComponent(props, externalRef) {
/**
* If we need to measure the element we load this functionality in a
* separate class component in order to gain access to getSnapshotBeforeUpdate.
*/
let MeasureLayout;
const configAndProps = {
...(0,external_React_.useContext)(MotionConfigContext),
...props,
layoutId: useLayoutId(props),
};
const { isStatic } = configAndProps;
const context = useCreateMotionContext(props);
const visualState = useVisualState(props, isStatic);
if (!isStatic && is_browser_isBrowser) {
useStrictMode(configAndProps, preloadedFeatures);
const layoutProjection = getProjectionFunctionality(configAndProps);
MeasureLayout = layoutProjection.MeasureLayout;
/**
* Create a VisualElement for this component. A VisualElement provides a common
* interface to renderer-specific APIs (ie DOM/Three.js etc) as well as
* providing a way of rendering to these APIs outside of the React render loop
* for more performant animations and interactions
*/
context.visualElement = useVisualElement(Component, visualState, configAndProps, createVisualElement, layoutProjection.ProjectionNode);
}
/**
* The mount order and hierarchy is specific to ensure our element ref
* is hydrated by the time features fire their effects.
*/
return ((0,external_ReactJSXRuntime_namespaceObject.jsxs)(MotionContext.Provider, { value: context, children: [MeasureLayout && context.visualElement ? ((0,external_ReactJSXRuntime_namespaceObject.jsx)(MeasureLayout, { visualElement: context.visualElement, ...configAndProps })) : null, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, context.visualElement)] }));
}
MotionComponent.displayName = `motion.${typeof Component === "string"
? Component
: `create(${(_b = (_a = Component.displayName) !== null && _a !== void 0 ? _a : Component.name) !== null && _b !== void 0 ? _b : ""})`}`;
const ForwardRefMotionComponent = (0,external_React_.forwardRef)(MotionComponent);
ForwardRefMotionComponent[motionComponentSymbol] = Component;
return ForwardRefMotionComponent;
}
function useLayoutId({ layoutId }) {
const layoutGroupId = (0,external_React_.useContext)(LayoutGroupContext).id;
return layoutGroupId && layoutId !== undefined
? layoutGroupId + "-" + layoutId
: layoutId;
}
function useStrictMode(configAndProps, preloadedFeatures) {
const isStrict = (0,external_React_.useContext)(LazyContext).strict;
/**
* If we're in development mode, check to make sure we're not rendering a motion component
* as a child of LazyMotion, as this will break the file-size benefits of using it.
*/
if (false) {}
}
function getProjectionFunctionality(props) {
const { drag, layout } = featureDefinitions;
if (!drag && !layout)
return {};
const combined = { ...drag, ...layout };
return {
MeasureLayout: (drag === null || drag === void 0 ? void 0 : drag.isEnabled(props)) || (layout === null || layout === void 0 ? void 0 : layout.isEnabled(props))
? combined.MeasureLayout
: undefined,
ProjectionNode: combined.ProjectionNode,
};
}
;// ./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs
/**
* We keep these listed separately as we use the lowercase tag names as part
* of the runtime bundle to detect SVG components
*/
const lowercaseSVGElements = [
"animate",
"circle",
"defs",
"desc",
"ellipse",
"g",
"image",
"line",
"filter",
"marker",
"mask",
"metadata",
"path",
"pattern",
"polygon",
"polyline",
"rect",
"stop",
"switch",
"symbol",
"svg",
"text",
"tspan",
"use",
"view",
];
;// ./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs
function isSVGComponent(Component) {
if (
/**
* If it's not a string, it's a custom React component. Currently we only support
* HTML custom React components.
*/
typeof Component !== "string" ||
/**
* If it contains a dash, the element is a custom HTML webcomponent.
*/
Component.includes("-")) {
return false;
}
else if (
/**
* If it's in our list of lowercase SVG tags, it's an SVG component
*/
lowercaseSVGElements.indexOf(Component) > -1 ||
/**
* If it contains a capital letter, it's an SVG component
*/
/[A-Z]/u.test(Component)) {
return true;
}
return false;
}
;// ./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs
function makeState({ scrapeMotionValuesFromProps, createRenderState, onUpdate, }, props, context, presenceContext) {
const state = {
latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),
renderState: createRenderState(),
};
if (onUpdate) {
/**
* onMount works without the VisualElement because it could be
* called before the VisualElement payload has been hydrated.
* (e.g. if someone is using m components <m.circle />)
*/
state.onMount = (instance) => onUpdate({ props, current: instance, ...state });
state.onUpdate = (visualElement) => onUpdate(visualElement);
}
return state;
}
const makeUseVisualState = (config) => (props, isStatic) => {
const context = (0,external_React_.useContext)(MotionContext);
const presenceContext = (0,external_React_.useContext)(PresenceContext_PresenceContext);
const make = () => makeState(config, props, context, presenceContext);
return isStatic ? make() : useConstant(make);
};
function makeLatestValues(props, context, presenceContext, scrapeMotionValues) {
const values = {};
const motionValues = scrapeMotionValues(props, {});
for (const key in motionValues) {
values[key] = resolveMotionValue(motionValues[key]);
}
let { initial, animate } = props;
const isControllingVariants$1 = isControllingVariants(props);
const isVariantNode$1 = isVariantNode(props);
if (context &&
isVariantNode$1 &&
!isControllingVariants$1 &&
props.inherit !== false) {
if (initial === undefined)
initial = context.initial;
if (animate === undefined)
animate = context.animate;
}
let isInitialAnimationBlocked = presenceContext
? presenceContext.initial === false
: false;
isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;
const variantToSet = isInitialAnimationBlocked ? animate : initial;
if (variantToSet &&
typeof variantToSet !== "boolean" &&
!isAnimationControls(variantToSet)) {
const list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];
for (let i = 0; i < list.length; i++) {
const resolved = resolveVariantFromProps(props, list[i]);
if (resolved) {
const { transitionEnd, transition, ...target } = resolved;
for (const key in target) {
let valueTarget = target[key];
if (Array.isArray(valueTarget)) {
/**
* Take final keyframe if the initial animation is blocked because
* we want to initialise at the end of that blocked animation.
*/
const index = isInitialAnimationBlocked
? valueTarget.length - 1
: 0;
valueTarget = valueTarget[index];
}
if (valueTarget !== null) {
values[key] = valueTarget;
}
}
for (const key in transitionEnd) {
values[key] = transitionEnd[key];
}
}
}
}
return values;
}
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs
/**
* Provided a value and a ValueType, returns the value as that value type.
*/
const getValueAsType = (value, type) => {
return type && typeof value === "number"
? type.transform(value)
: value;
};
;// ./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs
const translateAlias = {
x: "translateX",
y: "translateY",
z: "translateZ",
transformPerspective: "perspective",
};
const numTransforms = transformPropOrder.length;
/**
* Build a CSS transform style from individual x/y/scale etc properties.
*
* This outputs with a default order of transforms/scales/rotations, this can be customised by
* providing a transformTemplate function.
*/
function buildTransform(latestValues, transform, transformTemplate) {
// The transform string we're going to build into.
let transformString = "";
let transformIsDefault = true;
/**
* Loop over all possible transforms in order, adding the ones that
* are present to the transform string.
*/
for (let i = 0; i < numTransforms; i++) {
const key = transformPropOrder[i];
const value = latestValues[key];
if (value === undefined)
continue;
let valueIsDefault = true;
if (typeof value === "number") {
valueIsDefault = value === (key.startsWith("scale") ? 1 : 0);
}
else {
valueIsDefault = parseFloat(value) === 0;
}
if (!valueIsDefault || transformTemplate) {
const valueAsType = getValueAsType(value, numberValueTypes[key]);
if (!valueIsDefault) {
transformIsDefault = false;
const transformName = translateAlias[key] || key;
transformString += `${transformName}(${valueAsType}) `;
}
if (transformTemplate) {
transform[key] = valueAsType;
}
}
}
transformString = transformString.trim();
// If we have a custom `transform` template, pass our transform values and
// generated transformString to that before returning
if (transformTemplate) {
transformString = transformTemplate(transform, transformIsDefault ? "" : transformString);
}
else if (transformIsDefault) {
transformString = "none";
}
return transformString;
}
;// ./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs
function buildHTMLStyles(state, latestValues, transformTemplate) {
const { style, vars, transformOrigin } = state;
// Track whether we encounter any transform or transformOrigin values.
let hasTransform = false;
let hasTransformOrigin = false;
/**
* Loop over all our latest animated values and decide whether to handle them
* as a style or CSS variable.
*
* Transforms and transform origins are kept separately for further processing.
*/
for (const key in latestValues) {
const value = latestValues[key];
if (transformProps.has(key)) {
// If this is a transform, flag to enable further transform processing
hasTransform = true;
continue;
}
else if (isCSSVariableName(key)) {
vars[key] = value;
continue;
}
else {
// Convert the value to its default value type, ie 0 -> "0px"
const valueAsType = getValueAsType(value, numberValueTypes[key]);
if (key.startsWith("origin")) {
// If this is a transform origin, flag and enable further transform-origin processing
hasTransformOrigin = true;
transformOrigin[key] =
valueAsType;
}
else {
style[key] = valueAsType;
}
}
}
if (!latestValues.transform) {
if (hasTransform || transformTemplate) {
style.transform = buildTransform(latestValues, state.transform, transformTemplate);
}
else if (style.transform) {
/**
* If we have previously created a transform but currently don't have any,
* reset transform style to none.
*/
style.transform = "none";
}
}
/**
* Build a transformOrigin style. Uses the same defaults as the browser for
* undefined origins.
*/
if (hasTransformOrigin) {
const { originX = "50%", originY = "50%", originZ = 0, } = transformOrigin;
style.transformOrigin = `${originX} ${originY} ${originZ}`;
}
}
;// ./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs
const dashKeys = {
offset: "stroke-dashoffset",
array: "stroke-dasharray",
};
const camelKeys = {
offset: "strokeDashoffset",
array: "strokeDasharray",
};
/**
* Build SVG path properties. Uses the path's measured length to convert
* our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset
* and stroke-dasharray attributes.
*
* This function is mutative to reduce per-frame GC.
*/
function buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {
// Normalise path length by setting SVG attribute pathLength to 1
attrs.pathLength = 1;
// We use dash case when setting attributes directly to the DOM node and camel case
// when defining props on a React component.
const keys = useDashCase ? dashKeys : camelKeys;
// Build the dash offset
attrs[keys.offset] = px.transform(-offset);
// Build the dash array
const pathLength = px.transform(length);
const pathSpacing = px.transform(spacing);
attrs[keys.array] = `${pathLength} ${pathSpacing}`;
}
;// ./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs
function transform_origin_calcOrigin(origin, offset, size) {
return typeof origin === "string"
? origin
: px.transform(offset + size * origin);
}
/**
* The SVG transform origin defaults are different to CSS and is less intuitive,
* so we use the measured dimensions of the SVG to reconcile these.
*/
function calcSVGTransformOrigin(dimensions, originX, originY) {
const pxOriginX = transform_origin_calcOrigin(originX, dimensions.x, dimensions.width);
const pxOriginY = transform_origin_calcOrigin(originY, dimensions.y, dimensions.height);
return `${pxOriginX} ${pxOriginY}`;
}
;// ./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs
/**
* Build SVG visual attrbutes, like cx and style.transform
*/
function buildSVGAttrs(state, { attrX, attrY, attrScale, originX, originY, pathLength, pathSpacing = 1, pathOffset = 0,
// This is object creation, which we try to avoid per-frame.
...latest }, isSVGTag, transformTemplate) {
buildHTMLStyles(state, latest, transformTemplate);
/**
* For svg tags we just want to make sure viewBox is animatable and treat all the styles
* as normal HTML tags.
*/
if (isSVGTag) {
if (state.style.viewBox) {
state.attrs.viewBox = state.style.viewBox;
}
return;
}
state.attrs = state.style;
state.style = {};
const { attrs, style, dimensions } = state;
/**
* However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs
* and copy it into style.
*/
if (attrs.transform) {
if (dimensions)
style.transform = attrs.transform;
delete attrs.transform;
}
// Parse transformOrigin
if (dimensions &&
(originX !== undefined || originY !== undefined || style.transform)) {
style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);
}
// Render attrX/attrY/attrScale as attributes
if (attrX !== undefined)
attrs.x = attrX;
if (attrY !== undefined)
attrs.y = attrY;
if (attrScale !== undefined)
attrs.scale = attrScale;
// Build SVG path if one has been defined
if (pathLength !== undefined) {
buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);
}
}
;// ./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs
const createHtmlRenderState = () => ({
style: {},
transform: {},
transformOrigin: {},
vars: {},
});
;// ./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs
const createSvgRenderState = () => ({
...createHtmlRenderState(),
attrs: {},
});
;// ./node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.mjs
const isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";
;// ./node_modules/framer-motion/dist/es/render/html/utils/render.mjs
function renderHTML(element, { style, vars }, styleProp, projection) {
Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));
// Loop over any CSS variables and assign those.
for (const key in vars) {
element.style.setProperty(key, vars[key]);
}
}
;// ./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs
/**
* A set of attribute names that are always read/written as camel case.
*/
const camelCaseAttributes = new Set([
"baseFrequency",
"diffuseConstant",
"kernelMatrix",
"kernelUnitLength",
"keySplines",
"keyTimes",
"limitingConeAngle",
"markerHeight",
"markerWidth",
"numOctaves",
"targetX",
"targetY",
"surfaceScale",
"specularConstant",
"specularExponent",
"stdDeviation",
"tableValues",
"viewBox",
"gradientTransform",
"pathLength",
"startOffset",
"textLength",
"lengthAdjust",
]);
;// ./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs
function renderSVG(element, renderState, _styleProp, projection) {
renderHTML(element, renderState, undefined, projection);
for (const key in renderState.attrs) {
element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
}
}
;// ./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs
function isForcedMotionValue(key, { layout, layoutId }) {
return (transformProps.has(key) ||
key.startsWith("origin") ||
((layout || layoutId !== undefined) &&
(!!scaleCorrectors[key] || key === "opacity")));
}
;// ./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs
function scrapeMotionValuesFromProps(props, prevProps, visualElement) {
var _a;
const { style } = props;
const newValues = {};
for (const key in style) {
if (isMotionValue(style[key]) ||
(prevProps.style &&
isMotionValue(prevProps.style[key])) ||
isForcedMotionValue(key, props) ||
((_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.getValue(key)) === null || _a === void 0 ? void 0 : _a.liveStyle) !== undefined) {
newValues[key] = style[key];
}
}
return newValues;
}
;// ./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs
function scrape_motion_values_scrapeMotionValuesFromProps(props, prevProps, visualElement) {
const newValues = scrapeMotionValuesFromProps(props, prevProps, visualElement);
for (const key in props) {
if (isMotionValue(props[key]) ||
isMotionValue(prevProps[key])) {
const targetKey = transformPropOrder.indexOf(key) !== -1
? "attr" + key.charAt(0).toUpperCase() + key.substring(1)
: key;
newValues[targetKey] = props[key];
}
}
return newValues;
}
;// ./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs
function updateSVGDimensions(instance, renderState) {
try {
renderState.dimensions =
typeof instance.getBBox === "function"
? instance.getBBox()
: instance.getBoundingClientRect();
}
catch (e) {
// Most likely trying to measure an unrendered element under Firefox
renderState.dimensions = {
x: 0,
y: 0,
width: 0,
height: 0,
};
}
}
const layoutProps = ["x", "y", "width", "height", "cx", "cy", "r"];
const svgMotionConfig = {
useVisualState: makeUseVisualState({
scrapeMotionValuesFromProps: scrape_motion_values_scrapeMotionValuesFromProps,
createRenderState: createSvgRenderState,
onUpdate: ({ props, prevProps, current, renderState, latestValues, }) => {
if (!current)
return;
let hasTransform = !!props.drag;
if (!hasTransform) {
for (const key in latestValues) {
if (transformProps.has(key)) {
hasTransform = true;
break;
}
}
}
if (!hasTransform)
return;
let needsMeasure = !prevProps;
if (prevProps) {
/**
* Check the layout props for changes, if any are found we need to
* measure the element again.
*/
for (let i = 0; i < layoutProps.length; i++) {
const key = layoutProps[i];
if (props[key] !==
prevProps[key]) {
needsMeasure = true;
}
}
}
if (!needsMeasure)
return;
frame_frame.read(() => {
updateSVGDimensions(current, renderState);
frame_frame.render(() => {
buildSVGAttrs(renderState, latestValues, isSVGTag(current.tagName), props.transformTemplate);
renderSVG(current, renderState);
});
});
},
}),
};
;// ./node_modules/framer-motion/dist/es/render/html/config-motion.mjs
const htmlMotionConfig = {
useVisualState: makeUseVisualState({
scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,
createRenderState: createHtmlRenderState,
}),
};
;// ./node_modules/framer-motion/dist/es/render/html/use-props.mjs
function copyRawValuesOnly(target, source, props) {
for (const key in source) {
if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {
target[key] = source[key];
}
}
}
function useInitialMotionValues({ transformTemplate }, visualState) {
return (0,external_React_.useMemo)(() => {
const state = createHtmlRenderState();
buildHTMLStyles(state, visualState, transformTemplate);
return Object.assign({}, state.vars, state.style);
}, [visualState]);
}
function useStyle(props, visualState) {
const styleProp = props.style || {};
const style = {};
/**
* Copy non-Motion Values straight into style
*/
copyRawValuesOnly(style, styleProp, props);
Object.assign(style, useInitialMotionValues(props, visualState));
return style;
}
function useHTMLProps(props, visualState) {
// The `any` isn't ideal but it is the type of createElement props argument
const htmlProps = {};
const style = useStyle(props, visualState);
if (props.drag && props.dragListener !== false) {
// Disable the ghost element when a user drags
htmlProps.draggable = false;
// Disable text selection
style.userSelect =
style.WebkitUserSelect =
style.WebkitTouchCallout =
"none";
// Disable scrolling on the draggable direction
style.touchAction =
props.drag === true
? "none"
: `pan-${props.drag === "x" ? "y" : "x"}`;
}
if (props.tabIndex === undefined &&
(props.onTap || props.onTapStart || props.whileTap)) {
htmlProps.tabIndex = 0;
}
htmlProps.style = style;
return htmlProps;
}
;// ./node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs
/**
* A list of all valid MotionProps.
*
* @privateRemarks
* This doesn't throw if a `MotionProp` name is missing - it should.
*/
const validMotionProps = new Set([
"animate",
"exit",
"variants",
"initial",
"style",
"values",
"variants",
"transition",
"transformTemplate",
"custom",
"inherit",
"onBeforeLayoutMeasure",
"onAnimationStart",
"onAnimationComplete",
"onUpdate",
"onDragStart",
"onDrag",
"onDragEnd",
"onMeasureDragConstraints",
"onDirectionLock",
"onDragTransitionEnd",
"_dragX",
"_dragY",
"onHoverStart",
"onHoverEnd",
"onViewportEnter",
"onViewportLeave",
"globalTapTarget",
"ignoreStrict",
"viewport",
]);
/**
* Check whether a prop name is a valid `MotionProp` key.
*
* @param key - Name of the property to check
* @returns `true` is key is a valid `MotionProp`.
*
* @public
*/
function isValidMotionProp(key) {
return (key.startsWith("while") ||
(key.startsWith("drag") && key !== "draggable") ||
key.startsWith("layout") ||
key.startsWith("onTap") ||
key.startsWith("onPan") ||
key.startsWith("onLayout") ||
validMotionProps.has(key));
}
;// ./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs
let shouldForward = (key) => !isValidMotionProp(key);
function loadExternalIsValidProp(isValidProp) {
if (!isValidProp)
return;
// Explicitly filter our events
shouldForward = (key) => key.startsWith("on") ? !isValidMotionProp(key) : isValidProp(key);
}
/**
* Emotion and Styled Components both allow users to pass through arbitrary props to their components
* to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which
* of these should be passed to the underlying DOM node.
*
* However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props
* as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props
* passed through the `custom` prop so it doesn't *need* the payload or computational overhead of
* `@emotion/is-prop-valid`, however to fix this problem we need to use it.
*
* By making it an optionalDependency we can offer this functionality only in the situations where it's
* actually required.
*/
try {
/**
* We attempt to import this package but require won't be defined in esm environments, in that case
* isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed
* in favour of explicit injection.
*/
loadExternalIsValidProp(require("@emotion/is-prop-valid").default);
}
catch (_a) {
// We don't need to actually do anything here - the fallback is the existing `isPropValid`.
}
function filterProps(props, isDom, forwardMotionProps) {
const filteredProps = {};
for (const key in props) {
/**
* values is considered a valid prop by Emotion, so if it's present
* this will be rendered out to the DOM unless explicitly filtered.
*
* We check the type as it could be used with the `feColorMatrix`
* element, which we support.
*/
if (key === "values" && typeof props.values === "object")
continue;
if (shouldForward(key) ||
(forwardMotionProps === true && isValidMotionProp(key)) ||
(!isDom && !isValidMotionProp(key)) ||
// If trying to use native HTML drag events, forward drag listeners
(props["draggable"] &&
key.startsWith("onDrag"))) {
filteredProps[key] =
props[key];
}
}
return filteredProps;
}
;// ./node_modules/framer-motion/dist/es/render/svg/use-props.mjs
function useSVGProps(props, visualState, _isStatic, Component) {
const visualProps = (0,external_React_.useMemo)(() => {
const state = createSvgRenderState();
buildSVGAttrs(state, visualState, isSVGTag(Component), props.transformTemplate);
return {
...state.attrs,
style: { ...state.style },
};
}, [visualState]);
if (props.style) {
const rawStyles = {};
copyRawValuesOnly(rawStyles, props.style, props);
visualProps.style = { ...rawStyles, ...visualProps.style };
}
return visualProps;
}
;// ./node_modules/framer-motion/dist/es/render/dom/use-render.mjs
function createUseRender(forwardMotionProps = false) {
const useRender = (Component, props, ref, { latestValues }, isStatic) => {
const useVisualProps = isSVGComponent(Component)
? useSVGProps
: useHTMLProps;
const visualProps = useVisualProps(props, latestValues, isStatic, Component);
const filteredProps = filterProps(props, typeof Component === "string", forwardMotionProps);
const elementProps = Component !== external_React_.Fragment
? { ...filteredProps, ...visualProps, ref }
: {};
/**
* If component has been handed a motion value as its child,
* memoise its initial value and render that. Subsequent updates
* will be handled by the onChange handler
*/
const { children } = props;
const renderedChildren = (0,external_React_.useMemo)(() => (isMotionValue(children) ? children.get() : children), [children]);
return (0,external_React_.createElement)(Component, {
...elementProps,
children: renderedChildren,
});
};
return useRender;
}
;// ./node_modules/framer-motion/dist/es/render/components/create-factory.mjs
function createMotionComponentFactory(preloadedFeatures, createVisualElement) {
return function createMotionComponent(Component, { forwardMotionProps } = { forwardMotionProps: false }) {
const baseConfig = isSVGComponent(Component)
? svgMotionConfig
: htmlMotionConfig;
const config = {
...baseConfig,
preloadedFeatures,
useRender: createUseRender(forwardMotionProps),
createVisualElement,
Component,
};
return createRendererMotionComponent(config);
};
}
;// ./node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs
// Does this device prefer reduced motion? Returns `null` server-side.
const prefersReducedMotion = { current: null };
const hasReducedMotionListener = { current: false };
;// ./node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs
function initPrefersReducedMotion() {
hasReducedMotionListener.current = true;
if (!is_browser_isBrowser)
return;
if (window.matchMedia) {
const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);
motionMediaQuery.addListener(setReducedMotionPreferences);
setReducedMotionPreferences();
}
else {
prefersReducedMotion.current = false;
}
}
;// ./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs
/**
* A list of all ValueTypes
*/
const valueTypes = [...dimensionValueTypes, color, complex];
/**
* Tests a value against the list of ValueTypes
*/
const findValueType = (v) => valueTypes.find(testValueType(v));
;// ./node_modules/framer-motion/dist/es/render/store.mjs
const visualElementStore = new WeakMap();
;// ./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs
function updateMotionValuesFromProps(element, next, prev) {
for (const key in next) {
const nextValue = next[key];
const prevValue = prev[key];
if (isMotionValue(nextValue)) {
/**
* If this is a motion value found in props or style, we want to add it
* to our visual element's motion value map.
*/
element.addValue(key, nextValue);
/**
* Check the version of the incoming motion value with this version
* and warn against mismatches.
*/
if (false) {}
}
else if (isMotionValue(prevValue)) {
/**
* If we're swapping from a motion value to a static value,
* create a new motion value from that
*/
element.addValue(key, motionValue(nextValue, { owner: element }));
}
else if (prevValue !== nextValue) {
/**
* If this is a flat value that has changed, update the motion value
* or create one if it doesn't exist. We only want to do this if we're
* not handling the value with our animation state.
*/
if (element.hasValue(key)) {
const existingValue = element.getValue(key);
if (existingValue.liveStyle === true) {
existingValue.jump(nextValue);
}
else if (!existingValue.hasAnimated) {
existingValue.set(nextValue);
}
}
else {
const latestValue = element.getStaticValue(key);
element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));
}
}
}
// Handle removed values
for (const key in prev) {
if (next[key] === undefined)
element.removeValue(key);
}
return next;
}
;// ./node_modules/framer-motion/dist/es/render/VisualElement.mjs
const propEventHandlers = [
"AnimationStart",
"AnimationComplete",
"Update",
"BeforeLayoutMeasure",
"LayoutMeasure",
"LayoutAnimationStart",
"LayoutAnimationComplete",
];
/**
* A VisualElement is an imperative abstraction around UI elements such as
* HTMLElement, SVGElement, Three.Object3D etc.
*/
class VisualElement {
/**
* This method takes React props and returns found MotionValues. For example, HTML
* MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.
*
* This isn't an abstract method as it needs calling in the constructor, but it is
* intended to be one.
*/
scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {
return {};
}
constructor({ parent, props, presenceContext, reducedMotionConfig, blockInitialAnimation, visualState, }, options = {}) {
/**
* A reference to the current underlying Instance, e.g. a HTMLElement
* or Three.Mesh etc.
*/
this.current = null;
/**
* A set containing references to this VisualElement's children.
*/
this.children = new Set();
/**
* Determine what role this visual element should take in the variant tree.
*/
this.isVariantNode = false;
this.isControllingVariants = false;
/**
* Decides whether this VisualElement should animate in reduced motion
* mode.
*
* TODO: This is currently set on every individual VisualElement but feels
* like it could be set globally.
*/
this.shouldReduceMotion = null;
/**
* A map of all motion values attached to this visual element. Motion
* values are source of truth for any given animated value. A motion
* value might be provided externally by the component via props.
*/
this.values = new Map();
this.KeyframeResolver = KeyframeResolver;
/**
* Cleanup functions for active features (hover/tap/exit etc)
*/
this.features = {};
/**
* A map of every subscription that binds the provided or generated
* motion values onChange listeners to this visual element.
*/
this.valueSubscriptions = new Map();
/**
* A reference to the previously-provided motion values as returned
* from scrapeMotionValuesFromProps. We use the keys in here to determine
* if any motion values need to be removed after props are updated.
*/
this.prevMotionValues = {};
/**
* An object containing a SubscriptionManager for each active event.
*/
this.events = {};
/**
* An object containing an unsubscribe function for each prop event subscription.
* For example, every "Update" event can have multiple subscribers via
* VisualElement.on(), but only one of those can be defined via the onUpdate prop.
*/
this.propEventSubscriptions = {};
this.notifyUpdate = () => this.notify("Update", this.latestValues);
this.render = () => {
if (!this.current)
return;
this.triggerBuild();
this.renderInstance(this.current, this.renderState, this.props.style, this.projection);
};
this.renderScheduledAt = 0.0;
this.scheduleRender = () => {
const now = time.now();
if (this.renderScheduledAt < now) {
this.renderScheduledAt = now;
frame_frame.render(this.render, false, true);
}
};
const { latestValues, renderState, onUpdate } = visualState;
this.onUpdate = onUpdate;
this.latestValues = latestValues;
this.baseTarget = { ...latestValues };
this.initialValues = props.initial ? { ...latestValues } : {};
this.renderState = renderState;
this.parent = parent;
this.props = props;
this.presenceContext = presenceContext;
this.depth = parent ? parent.depth + 1 : 0;
this.reducedMotionConfig = reducedMotionConfig;
this.options = options;
this.blockInitialAnimation = Boolean(blockInitialAnimation);
this.isControllingVariants = isControllingVariants(props);
this.isVariantNode = isVariantNode(props);
if (this.isVariantNode) {
this.variantChildren = new Set();
}
this.manuallyAnimateOnMount = Boolean(parent && parent.current);
/**
* Any motion values that are provided to the element when created
* aren't yet bound to the element, as this would technically be impure.
* However, we iterate through the motion values and set them to the
* initial values for this component.
*
* TODO: This is impure and we should look at changing this to run on mount.
* Doing so will break some tests but this isn't necessarily a breaking change,
* more a reflection of the test.
*/
const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);
for (const key in initialMotionValues) {
const value = initialMotionValues[key];
if (latestValues[key] !== undefined && isMotionValue(value)) {
value.set(latestValues[key], false);
}
}
}
mount(instance) {
this.current = instance;
visualElementStore.set(instance, this);
if (this.projection && !this.projection.instance) {
this.projection.mount(instance);
}
if (this.parent && this.isVariantNode && !this.isControllingVariants) {
this.removeFromVariantTree = this.parent.addVariantChild(this);
}
this.values.forEach((value, key) => this.bindToMotionValue(key, value));
if (!hasReducedMotionListener.current) {
initPrefersReducedMotion();
}
this.shouldReduceMotion =
this.reducedMotionConfig === "never"
? false
: this.reducedMotionConfig === "always"
? true
: prefersReducedMotion.current;
if (false) {}
if (this.parent)
this.parent.children.add(this);
this.update(this.props, this.presenceContext);
}
unmount() {
visualElementStore.delete(this.current);
this.projection && this.projection.unmount();
cancelFrame(this.notifyUpdate);
cancelFrame(this.render);
this.valueSubscriptions.forEach((remove) => remove());
this.valueSubscriptions.clear();
this.removeFromVariantTree && this.removeFromVariantTree();
this.parent && this.parent.children.delete(this);
for (const key in this.events) {
this.events[key].clear();
}
for (const key in this.features) {
const feature = this.features[key];
if (feature) {
feature.unmount();
feature.isMounted = false;
}
}
this.current = null;
}
bindToMotionValue(key, value) {
if (this.valueSubscriptions.has(key)) {
this.valueSubscriptions.get(key)();
}
const valueIsTransform = transformProps.has(key);
const removeOnChange = value.on("change", (latestValue) => {
this.latestValues[key] = latestValue;
this.props.onUpdate && frame_frame.preRender(this.notifyUpdate);
if (valueIsTransform && this.projection) {
this.projection.isTransformDirty = true;
}
});
const removeOnRenderRequest = value.on("renderRequest", this.scheduleRender);
let removeSyncCheck;
if (window.MotionCheckAppearSync) {
removeSyncCheck = window.MotionCheckAppearSync(this, key, value);
}
this.valueSubscriptions.set(key, () => {
removeOnChange();
removeOnRenderRequest();
if (removeSyncCheck)
removeSyncCheck();
if (value.owner)
value.stop();
});
}
sortNodePosition(other) {
/**
* If these nodes aren't even of the same type we can't compare their depth.
*/
if (!this.current ||
!this.sortInstanceNodePosition ||
this.type !== other.type) {
return 0;
}
return this.sortInstanceNodePosition(this.current, other.current);
}
updateFeatures() {
let key = "animation";
for (key in featureDefinitions) {
const featureDefinition = featureDefinitions[key];
if (!featureDefinition)
continue;
const { isEnabled, Feature: FeatureConstructor } = featureDefinition;
/**
* If this feature is enabled but not active, make a new instance.
*/
if (!this.features[key] &&
FeatureConstructor &&
isEnabled(this.props)) {
this.features[key] = new FeatureConstructor(this);
}
/**
* If we have a feature, mount or update it.
*/
if (this.features[key]) {
const feature = this.features[key];
if (feature.isMounted) {
feature.update();
}
else {
feature.mount();
feature.isMounted = true;
}
}
}
}
triggerBuild() {
this.build(this.renderState, this.latestValues, this.props);
}
/**
* Measure the current viewport box with or without transforms.
* Only measures axis-aligned boxes, rotate and skew must be manually
* removed with a re-render to work.
*/
measureViewportBox() {
return this.current
? this.measureInstanceViewportBox(this.current, this.props)
: createBox();
}
getStaticValue(key) {
return this.latestValues[key];
}
setStaticValue(key, value) {
this.latestValues[key] = value;
}
/**
* Update the provided props. Ensure any newly-added motion values are
* added to our map, old ones removed, and listeners updated.
*/
update(props, presenceContext) {
if (props.transformTemplate || this.props.transformTemplate) {
this.scheduleRender();
}
this.prevProps = this.props;
this.props = props;
this.prevPresenceContext = this.presenceContext;
this.presenceContext = presenceContext;
/**
* Update prop event handlers ie onAnimationStart, onAnimationComplete
*/
for (let i = 0; i < propEventHandlers.length; i++) {
const key = propEventHandlers[i];
if (this.propEventSubscriptions[key]) {
this.propEventSubscriptions[key]();
delete this.propEventSubscriptions[key];
}
const listenerName = ("on" + key);
const listener = props[listenerName];
if (listener) {
this.propEventSubscriptions[key] = this.on(key, listener);
}
}
this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps, this), this.prevMotionValues);
if (this.handleChildMotionValue) {
this.handleChildMotionValue();
}
this.onUpdate && this.onUpdate(this);
}
getProps() {
return this.props;
}
/**
* Returns the variant definition with a given name.
*/
getVariant(name) {
return this.props.variants ? this.props.variants[name] : undefined;
}
/**
* Returns the defined default transition on this component.
*/
getDefaultTransition() {
return this.props.transition;
}
getTransformPagePoint() {
return this.props.transformPagePoint;
}
getClosestVariantNode() {
return this.isVariantNode
? this
: this.parent
? this.parent.getClosestVariantNode()
: undefined;
}
/**
* Add a child visual element to our set of children.
*/
addVariantChild(child) {
const closestVariantNode = this.getClosestVariantNode();
if (closestVariantNode) {
closestVariantNode.variantChildren &&
closestVariantNode.variantChildren.add(child);
return () => closestVariantNode.variantChildren.delete(child);
}
}
/**
* Add a motion value and bind it to this visual element.
*/
addValue(key, value) {
// Remove existing value if it exists
const existingValue = this.values.get(key);
if (value !== existingValue) {
if (existingValue)
this.removeValue(key);
this.bindToMotionValue(key, value);
this.values.set(key, value);
this.latestValues[key] = value.get();
}
}
/**
* Remove a motion value and unbind any active subscriptions.
*/
removeValue(key) {
this.values.delete(key);
const unsubscribe = this.valueSubscriptions.get(key);
if (unsubscribe) {
unsubscribe();
this.valueSubscriptions.delete(key);
}
delete this.latestValues[key];
this.removeValueFromRenderState(key, this.renderState);
}
/**
* Check whether we have a motion value for this key
*/
hasValue(key) {
return this.values.has(key);
}
getValue(key, defaultValue) {
if (this.props.values && this.props.values[key]) {
return this.props.values[key];
}
let value = this.values.get(key);
if (value === undefined && defaultValue !== undefined) {
value = motionValue(defaultValue === null ? undefined : defaultValue, { owner: this });
this.addValue(key, value);
}
return value;
}
/**
* If we're trying to animate to a previously unencountered value,
* we need to check for it in our state and as a last resort read it
* directly from the instance (which might have performance implications).
*/
readValue(key, target) {
var _a;
let value = this.latestValues[key] !== undefined || !this.current
? this.latestValues[key]
: (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);
if (value !== undefined && value !== null) {
if (typeof value === "string" &&
(isNumericalString(value) || isZeroValueString(value))) {
// If this is a number read as a string, ie "0" or "200", convert it to a number
value = parseFloat(value);
}
else if (!findValueType(value) && complex.test(target)) {
value = animatable_none_getAnimatableNone(key, target);
}
this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);
}
return isMotionValue(value) ? value.get() : value;
}
/**
* Set the base target to later animate back to. This is currently
* only hydrated on creation and when we first read a value.
*/
setBaseTarget(key, value) {
this.baseTarget[key] = value;
}
/**
* Find the base target for a value thats been removed from all animation
* props.
*/
getBaseTarget(key) {
var _a;
const { initial } = this.props;
let valueFromInitial;
if (typeof initial === "string" || typeof initial === "object") {
const variant = resolveVariantFromProps(this.props, initial, (_a = this.presenceContext) === null || _a === void 0 ? void 0 : _a.custom);
if (variant) {
valueFromInitial = variant[key];
}
}
/**
* If this value still exists in the current initial variant, read that.
*/
if (initial && valueFromInitial !== undefined) {
return valueFromInitial;
}
/**
* Alternatively, if this VisualElement config has defined a getBaseTarget
* so we can read the value from an alternative source, try that.
*/
const target = this.getBaseTargetFromProps(this.props, key);
if (target !== undefined && !isMotionValue(target))
return target;
/**
* If the value was initially defined on initial, but it doesn't any more,
* return undefined. Otherwise return the value as initially read from the DOM.
*/
return this.initialValues[key] !== undefined &&
valueFromInitial === undefined
? undefined
: this.baseTarget[key];
}
on(eventName, callback) {
if (!this.events[eventName]) {
this.events[eventName] = new SubscriptionManager();
}
return this.events[eventName].add(callback);
}
notify(eventName, ...args) {
if (this.events[eventName]) {
this.events[eventName].notify(...args);
}
}
}
;// ./node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs
class DOMVisualElement extends VisualElement {
constructor() {
super(...arguments);
this.KeyframeResolver = DOMKeyframesResolver;
}
sortInstanceNodePosition(a, b) {
/**
* compareDocumentPosition returns a bitmask, by using the bitwise &
* we're returning true if 2 in that bitmask is set to true. 2 is set
* to true if b preceeds a.
*/
return a.compareDocumentPosition(b) & 2 ? 1 : -1;
}
getBaseTargetFromProps(props, key) {
return props.style
? props.style[key]
: undefined;
}
removeValueFromRenderState(key, { vars, style }) {
delete vars[key];
delete style[key];
}
handleChildMotionValue() {
if (this.childSubscription) {
this.childSubscription();
delete this.childSubscription;
}
const { children } = this.props;
if (isMotionValue(children)) {
this.childSubscription = children.on("change", (latest) => {
if (this.current) {
this.current.textContent = `${latest}`;
}
});
}
}
}
;// ./node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs
function HTMLVisualElement_getComputedStyle(element) {
return window.getComputedStyle(element);
}
class HTMLVisualElement extends DOMVisualElement {
constructor() {
super(...arguments);
this.type = "html";
this.renderInstance = renderHTML;
}
readValueFromInstance(instance, key) {
if (transformProps.has(key)) {
const defaultType = getDefaultValueType(key);
return defaultType ? defaultType.default || 0 : 0;
}
else {
const computedStyle = HTMLVisualElement_getComputedStyle(instance);
const value = (isCSSVariableName(key)
? computedStyle.getPropertyValue(key)
: computedStyle[key]) || 0;
return typeof value === "string" ? value.trim() : value;
}
}
measureInstanceViewportBox(instance, { transformPagePoint }) {
return measureViewportBox(instance, transformPagePoint);
}
build(renderState, latestValues, props) {
buildHTMLStyles(renderState, latestValues, props.transformTemplate);
}
scrapeMotionValuesFromProps(props, prevProps, visualElement) {
return scrapeMotionValuesFromProps(props, prevProps, visualElement);
}
}
;// ./node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs
class SVGVisualElement extends DOMVisualElement {
constructor() {
super(...arguments);
this.type = "svg";
this.isSVGTag = false;
this.measureInstanceViewportBox = createBox;
}
getBaseTargetFromProps(props, key) {
return props[key];
}
readValueFromInstance(instance, key) {
if (transformProps.has(key)) {
const defaultType = getDefaultValueType(key);
return defaultType ? defaultType.default || 0 : 0;
}
key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
return instance.getAttribute(key);
}
scrapeMotionValuesFromProps(props, prevProps, visualElement) {
return scrape_motion_values_scrapeMotionValuesFromProps(props, prevProps, visualElement);
}
build(renderState, latestValues, props) {
buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate);
}
renderInstance(instance, renderState, styleProp, projection) {
renderSVG(instance, renderState, styleProp, projection);
}
mount(instance) {
this.isSVGTag = isSVGTag(instance.tagName);
super.mount(instance);
}
}
;// ./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs
const createDomVisualElement = (Component, options) => {
return isSVGComponent(Component)
? new SVGVisualElement(options)
: new HTMLVisualElement(options, {
allowProjection: Component !== external_React_.Fragment,
});
};
;// ./node_modules/framer-motion/dist/es/render/components/motion/create.mjs
const createMotionComponent = /*@__PURE__*/ createMotionComponentFactory({
...animations,
...gestureAnimations,
...drag,
...layout,
}, createDomVisualElement);
;// ./node_modules/framer-motion/dist/es/render/components/motion/proxy.mjs
const motion = /*@__PURE__*/ createDOMMotionComponentProxy(createMotionComponent);
;// ./node_modules/@wordpress/components/build-module/utils/use-responsive-value.js
const breakpoints = ["40em", "52em", "64em"];
const useBreakpointIndex = (options = {}) => {
const {
defaultIndex = 0
} = options;
if (typeof defaultIndex !== "number") {
throw new TypeError(`Default breakpoint index should be a number. Got: ${defaultIndex}, ${typeof defaultIndex}`);
} else if (defaultIndex < 0 || defaultIndex > breakpoints.length - 1) {
throw new RangeError(`Default breakpoint index out of range. Theme has ${breakpoints.length} breakpoints, got index ${defaultIndex}`);
}
const [value, setValue] = (0,external_wp_element_namespaceObject.useState)(defaultIndex);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const getIndex = () => breakpoints.filter((bp) => {
return typeof window !== "undefined" ? window.matchMedia(`screen and (min-width: ${bp})`).matches : false;
}).length;
const onResize = () => {
const newValue = getIndex();
if (value !== newValue) {
setValue(newValue);
}
};
onResize();
if (typeof window !== "undefined") {
window.addEventListener("resize", onResize);
}
return () => {
if (typeof window !== "undefined") {
window.removeEventListener("resize", onResize);
}
};
}, [value]);
return value;
};
function useResponsiveValue(values, options = {}) {
const index = useBreakpointIndex(options);
if (!Array.isArray(values) && typeof values !== "function") {
return values;
}
const array = values || [];
return (
/** @type {T[]} */
array[
/* eslint-enable jsdoc/no-undefined-types */
index >= array.length ? array.length - 1 : index
]
);
}
;// ./node_modules/@wordpress/components/build-module/flex/styles.js
function styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const Flex = true ? {
name: "zjik7",
styles: "display:flex"
} : 0;
const Item = true ? {
name: "qgaee5",
styles: "display:block;max-height:100%;max-width:100%;min-height:0;min-width:0"
} : 0;
const block = true ? {
name: "82a6rk",
styles: "flex:1"
} : 0;
const ItemsColumn = true ? {
name: "13nosa1",
styles: ">*{min-height:0;}"
} : 0;
const ItemsRow = true ? {
name: "1pwxzk4",
styles: ">*{min-width:0;}"
} : 0;
;// ./node_modules/@wordpress/components/build-module/flex/flex/hook.js
function useDeprecatedProps(props) {
const {
isReversed,
...otherProps
} = props;
if (typeof isReversed !== "undefined") {
external_wp_deprecated_default()("Flex isReversed", {
alternative: 'Flex direction="row-reverse" or "column-reverse"',
since: "5.9"
});
return {
...otherProps,
direction: isReversed ? "row-reverse" : "row"
};
}
return otherProps;
}
function useFlex(props) {
const {
align,
className,
direction: directionProp = "row",
expanded = true,
gap = 2,
justify = "space-between",
wrap = false,
...otherProps
} = useContextSystem(useDeprecatedProps(props), "Flex");
const directionAsArray = Array.isArray(directionProp) ? directionProp : [directionProp];
const direction = useResponsiveValue(directionAsArray);
const isColumn = typeof direction === "string" && !!direction.includes("column");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
const base = /* @__PURE__ */ emotion_react_browser_esm_css({
alignItems: align !== null && align !== void 0 ? align : isColumn ? "normal" : "center",
flexDirection: direction,
flexWrap: wrap ? "wrap" : void 0,
gap: space(gap),
justifyContent: justify,
height: isColumn && expanded ? "100%" : void 0,
width: !isColumn && expanded ? "100%" : void 0
}, true ? "" : 0, true ? "" : 0);
return cx(Flex, base, isColumn ? ItemsColumn : ItemsRow, className);
}, [align, className, cx, direction, expanded, gap, isColumn, justify, wrap]);
return {
...otherProps,
className: classes,
isColumn
};
}
;// ./node_modules/@wordpress/components/build-module/flex/context.js
const FlexContext = (0,external_wp_element_namespaceObject.createContext)({
flexItemDisplay: void 0
});
const useFlexContext = () => (0,external_wp_element_namespaceObject.useContext)(FlexContext);
;// ./node_modules/@wordpress/components/build-module/flex/flex/component.js
function UnconnectedFlex(props, forwardedRef) {
const {
children,
isColumn,
...otherProps
} = useFlex(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexContext.Provider, {
value: {
flexItemDisplay: isColumn ? "block" : void 0
},
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...otherProps,
ref: forwardedRef,
children
})
});
}
const component_Flex = contextConnect(UnconnectedFlex, "Flex");
var flex_component_component_default = component_Flex;
;// ./node_modules/@wordpress/components/build-module/flex/flex-item/hook.js
function useFlexItem(props) {
const {
className,
display: displayProp,
isBlock = false,
...otherProps
} = useContextSystem(props, "FlexItem");
const sx = {};
const contextDisplay = useFlexContext().flexItemDisplay;
sx.Base = /* @__PURE__ */ emotion_react_browser_esm_css({
display: displayProp || contextDisplay
}, true ? "" : 0, true ? "" : 0);
const cx = useCx();
const classes = cx(Item, sx.Base, isBlock && block, className);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/flex/flex-block/hook.js
function useFlexBlock(props) {
const otherProps = useContextSystem(props, "FlexBlock");
const flexItemProps = useFlexItem({
isBlock: true,
...otherProps
});
return flexItemProps;
}
;// ./node_modules/@wordpress/components/build-module/flex/flex-block/component.js
function UnconnectedFlexBlock(props, forwardedRef) {
const flexBlockProps = useFlexBlock(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...flexBlockProps,
ref: forwardedRef
});
}
const FlexBlock = contextConnect(UnconnectedFlexBlock, "FlexBlock");
var flex_block_component_component_default = FlexBlock;
;// ./node_modules/@wordpress/components/build-module/utils/rtl.js
const LOWER_LEFT_REGEXP = new RegExp(/-left/g);
const LOWER_RIGHT_REGEXP = new RegExp(/-right/g);
const UPPER_LEFT_REGEXP = new RegExp(/Left/g);
const UPPER_RIGHT_REGEXP = new RegExp(/Right/g);
function getConvertedKey(key) {
if (key === "left") {
return "right";
}
if (key === "right") {
return "left";
}
if (LOWER_LEFT_REGEXP.test(key)) {
return key.replace(LOWER_LEFT_REGEXP, "-right");
}
if (LOWER_RIGHT_REGEXP.test(key)) {
return key.replace(LOWER_RIGHT_REGEXP, "-left");
}
if (UPPER_LEFT_REGEXP.test(key)) {
return key.replace(UPPER_LEFT_REGEXP, "Right");
}
if (UPPER_RIGHT_REGEXP.test(key)) {
return key.replace(UPPER_RIGHT_REGEXP, "Left");
}
return key;
}
const convertLTRToRTL = (ltrStyles = {}) => {
return Object.fromEntries(Object.entries(ltrStyles).map(([key, value]) => [getConvertedKey(key), value]));
};
function rtl(ltrStyles = {}, rtlStyles) {
return () => {
if (rtlStyles) {
return (0,external_wp_i18n_namespaceObject.isRTL)() ? /* @__PURE__ */ emotion_react_browser_esm_css(rtlStyles, true ? "" : 0, true ? "" : 0) : /* @__PURE__ */ emotion_react_browser_esm_css(ltrStyles, true ? "" : 0, true ? "" : 0);
}
return (0,external_wp_i18n_namespaceObject.isRTL)() ? /* @__PURE__ */ emotion_react_browser_esm_css(convertLTRToRTL(ltrStyles), true ? "" : 0, true ? "" : 0) : /* @__PURE__ */ emotion_react_browser_esm_css(ltrStyles, true ? "" : 0, true ? "" : 0);
};
}
rtl.watch = () => (0,external_wp_i18n_namespaceObject.isRTL)();
;// ./node_modules/@wordpress/components/build-module/spacer/hook.js
function isDefined(o) {
return typeof o !== "undefined" && o !== null;
}
function useSpacer(props) {
const {
className,
margin,
marginBottom = 2,
marginLeft,
marginRight,
marginTop,
marginX,
marginY,
padding,
paddingBottom,
paddingLeft,
paddingRight,
paddingTop,
paddingX,
paddingY,
...otherProps
} = useContextSystem(props, "Spacer");
const cx = useCx();
const classes = cx(isDefined(margin) && /* @__PURE__ */ emotion_react_browser_esm_css("margin:", space(margin), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(marginY) && /* @__PURE__ */ emotion_react_browser_esm_css("margin-bottom:", space(marginY), ";margin-top:", space(marginY), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(marginX) && /* @__PURE__ */ emotion_react_browser_esm_css("margin-left:", space(marginX), ";margin-right:", space(marginX), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(marginTop) && /* @__PURE__ */ emotion_react_browser_esm_css("margin-top:", space(marginTop), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(marginBottom) && /* @__PURE__ */ emotion_react_browser_esm_css("margin-bottom:", space(marginBottom), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(marginLeft) && rtl({
marginLeft: space(marginLeft)
})(), isDefined(marginRight) && rtl({
marginRight: space(marginRight)
})(), isDefined(padding) && /* @__PURE__ */ emotion_react_browser_esm_css("padding:", space(padding), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(paddingY) && /* @__PURE__ */ emotion_react_browser_esm_css("padding-bottom:", space(paddingY), ";padding-top:", space(paddingY), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(paddingX) && /* @__PURE__ */ emotion_react_browser_esm_css("padding-left:", space(paddingX), ";padding-right:", space(paddingX), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(paddingTop) && /* @__PURE__ */ emotion_react_browser_esm_css("padding-top:", space(paddingTop), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(paddingBottom) && /* @__PURE__ */ emotion_react_browser_esm_css("padding-bottom:", space(paddingBottom), ";" + ( true ? "" : 0), true ? "" : 0), isDefined(paddingLeft) && rtl({
paddingLeft: space(paddingLeft)
})(), isDefined(paddingRight) && rtl({
paddingRight: space(paddingRight)
})(), className);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/spacer/component.js
function UnconnectedSpacer(props, forwardedRef) {
const spacerProps = useSpacer(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...spacerProps,
ref: forwardedRef
});
}
const Spacer = contextConnect(UnconnectedSpacer, "Spacer");
var spacer_component_component_default = Spacer;
;// ./node_modules/@wordpress/icons/build-module/library/plus.js
var plus_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M11 12.5V17.5H12.5V12.5H17.5V11H12.5V6H11V11H6V12.5H11Z" }) });
;// ./node_modules/@wordpress/icons/build-module/library/reset.js
var reset_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M7 11.5h10V13H7z" }) });
;// ./node_modules/@wordpress/components/build-module/flex/flex-item/component.js
function UnconnectedFlexItem(props, forwardedRef) {
const flexItemProps = useFlexItem(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...flexItemProps,
ref: forwardedRef
});
}
const FlexItem = contextConnect(UnconnectedFlexItem, "FlexItem");
var flex_item_component_component_default = FlexItem;
;// ./node_modules/@wordpress/components/build-module/truncate/styles.js
function truncate_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const Truncate = true ? {
name: "hdknak",
styles: "display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap"
} : 0;
;// ./node_modules/@wordpress/components/build-module/utils/values.js
function isValueDefined(value) {
return value !== void 0 && value !== null;
}
function isValueEmpty(value) {
const isEmptyString = value === "";
return !isValueDefined(value) || isEmptyString;
}
function getDefinedValue(values = [], fallbackValue) {
var _values$find;
return (_values$find = values.find(isValueDefined)) !== null && _values$find !== void 0 ? _values$find : fallbackValue;
}
const stringToNumber = (value) => {
return parseFloat(value);
};
const ensureNumber = (value) => {
return typeof value === "string" ? stringToNumber(value) : value;
};
;// ./node_modules/@wordpress/components/build-module/truncate/utils.js
const TRUNCATE_ELLIPSIS = "\u2026";
const TRUNCATE_TYPE = {
auto: "auto",
head: "head",
middle: "middle",
tail: "tail",
none: "none"
};
const TRUNCATE_DEFAULT_PROPS = {
ellipsis: TRUNCATE_ELLIPSIS,
ellipsizeMode: TRUNCATE_TYPE.auto,
limit: 0,
numberOfLines: 0
};
function truncateMiddle(word, headLength, tailLength, ellipsis) {
if (typeof word !== "string") {
return "";
}
const wordLength = word.length;
const frontLength = ~~headLength;
const backLength = ~~tailLength;
const truncateStr = isValueDefined(ellipsis) ? ellipsis : TRUNCATE_ELLIPSIS;
if (frontLength === 0 && backLength === 0 || frontLength >= wordLength || backLength >= wordLength || frontLength + backLength >= wordLength) {
return word;
} else if (backLength === 0) {
return word.slice(0, frontLength) + truncateStr;
}
return word.slice(0, frontLength) + truncateStr + word.slice(wordLength - backLength);
}
function truncateContent(words = "", props) {
const mergedProps = {
...TRUNCATE_DEFAULT_PROPS,
...props
};
const {
ellipsis,
ellipsizeMode,
limit
} = mergedProps;
if (ellipsizeMode === TRUNCATE_TYPE.none) {
return words;
}
let truncateHead;
let truncateTail;
switch (ellipsizeMode) {
case TRUNCATE_TYPE.head:
truncateHead = 0;
truncateTail = limit;
break;
case TRUNCATE_TYPE.middle:
truncateHead = Math.floor(limit / 2);
truncateTail = Math.floor(limit / 2);
break;
default:
truncateHead = limit;
truncateTail = 0;
}
const truncatedContent = ellipsizeMode !== TRUNCATE_TYPE.auto ? truncateMiddle(words, truncateHead, truncateTail, ellipsis) : words;
return truncatedContent;
}
;// ./node_modules/@wordpress/components/build-module/truncate/hook.js
function useTruncate(props) {
const {
className,
children,
ellipsis = TRUNCATE_ELLIPSIS,
ellipsizeMode = TRUNCATE_TYPE.auto,
limit = 0,
numberOfLines = 0,
...otherProps
} = useContextSystem(props, "Truncate");
const cx = useCx();
let childrenAsText;
if (typeof children === "string") {
childrenAsText = children;
} else if (typeof children === "number") {
childrenAsText = children.toString();
}
const truncatedContent = childrenAsText ? truncateContent(childrenAsText, {
ellipsis,
ellipsizeMode,
limit,
numberOfLines
}) : children;
const shouldTruncate = !!childrenAsText && ellipsizeMode === TRUNCATE_TYPE.auto;
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
const truncateLines = /* @__PURE__ */ emotion_react_browser_esm_css(numberOfLines === 1 ? "word-break: break-all;" : "", " -webkit-box-orient:vertical;-webkit-line-clamp:", numberOfLines, ";display:-webkit-box;overflow:hidden;" + ( true ? "" : 0), true ? "" : 0);
return cx(shouldTruncate && !numberOfLines && Truncate, shouldTruncate && !!numberOfLines && truncateLines, className);
}, [className, cx, numberOfLines, shouldTruncate]);
return {
...otherProps,
className: classes,
children: truncatedContent
};
}
;// ./node_modules/colord/index.mjs
var colord_r={grad:.9,turn:360,rad:360/(2*Math.PI)},t=function(r){return"string"==typeof r?r.length>0:"number"==typeof r},colord_n=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=Math.pow(10,t)),Math.round(n*r)/n+0},colord_e=function(r,t,n){return void 0===t&&(t=0),void 0===n&&(n=1),r>n?n:r>t?r:t},u=function(r){return(r=isFinite(r)?r%360:0)>0?r:r+360},colord_a=function(r){return{r:colord_e(r.r,0,255),g:colord_e(r.g,0,255),b:colord_e(r.b,0,255),a:colord_e(r.a)}},colord_o=function(r){return{r:colord_n(r.r),g:colord_n(r.g),b:colord_n(r.b),a:colord_n(r.a,3)}},i=/^#([0-9a-f]{3,8})$/i,s=function(r){var t=r.toString(16);return t.length<2?"0"+t:t},h=function(r){var t=r.r,n=r.g,e=r.b,u=r.a,a=Math.max(t,n,e),o=a-Math.min(t,n,e),i=o?a===t?(n-e)/o:a===n?2+(e-t)/o:4+(t-n)/o:0;return{h:60*(i<0?i+6:i),s:a?o/a*100:0,v:a/255*100,a:u}},b=function(r){var t=r.h,n=r.s,e=r.v,u=r.a;t=t/360*6,n/=100,e/=100;var a=Math.floor(t),o=e*(1-n),i=e*(1-(t-a)*n),s=e*(1-(1-t+a)*n),h=a%6;return{r:255*[e,i,o,o,s,e][h],g:255*[s,e,e,i,o,o][h],b:255*[o,o,s,e,e,i][h],a:u}},g=function(r){return{h:u(r.h),s:colord_e(r.s,0,100),l:colord_e(r.l,0,100),a:colord_e(r.a)}},d=function(r){return{h:colord_n(r.h),s:colord_n(r.s),l:colord_n(r.l),a:colord_n(r.a,3)}},f=function(r){return b((n=(t=r).s,{h:t.h,s:(n*=((e=t.l)<50?e:100-e)/100)>0?2*n/(e+n)*100:0,v:e+n,a:t.a}));var t,n,e},c=function(r){return{h:(t=h(r)).h,s:(u=(200-(n=t.s))*(e=t.v)/100)>0&&u<200?n*e/100/(u<=100?u:200-u)*100:0,l:u/2,a:t.a};var t,n,e,u},l=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,p=/^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,v=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,m=/^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i,y={string:[[function(r){var t=i.exec(r);return t?(r=t[1]).length<=4?{r:parseInt(r[0]+r[0],16),g:parseInt(r[1]+r[1],16),b:parseInt(r[2]+r[2],16),a:4===r.length?colord_n(parseInt(r[3]+r[3],16)/255,2):1}:6===r.length||8===r.length?{r:parseInt(r.substr(0,2),16),g:parseInt(r.substr(2,2),16),b:parseInt(r.substr(4,2),16),a:8===r.length?colord_n(parseInt(r.substr(6,2),16)/255,2):1}:null:null},"hex"],[function(r){var t=v.exec(r)||m.exec(r);return t?t[2]!==t[4]||t[4]!==t[6]?null:colord_a({r:Number(t[1])/(t[2]?100/255:1),g:Number(t[3])/(t[4]?100/255:1),b:Number(t[5])/(t[6]?100/255:1),a:void 0===t[7]?1:Number(t[7])/(t[8]?100:1)}):null},"rgb"],[function(t){var n=l.exec(t)||p.exec(t);if(!n)return null;var e,u,a=g({h:(e=n[1],u=n[2],void 0===u&&(u="deg"),Number(e)*(colord_r[u]||1)),s:Number(n[3]),l:Number(n[4]),a:void 0===n[5]?1:Number(n[5])/(n[6]?100:1)});return f(a)},"hsl"]],object:[[function(r){var n=r.r,e=r.g,u=r.b,o=r.a,i=void 0===o?1:o;return t(n)&&t(e)&&t(u)?colord_a({r:Number(n),g:Number(e),b:Number(u),a:Number(i)}):null},"rgb"],[function(r){var n=r.h,e=r.s,u=r.l,a=r.a,o=void 0===a?1:a;if(!t(n)||!t(e)||!t(u))return null;var i=g({h:Number(n),s:Number(e),l:Number(u),a:Number(o)});return f(i)},"hsl"],[function(r){var n=r.h,a=r.s,o=r.v,i=r.a,s=void 0===i?1:i;if(!t(n)||!t(a)||!t(o))return null;var h=function(r){return{h:u(r.h),s:colord_e(r.s,0,100),v:colord_e(r.v,0,100),a:colord_e(r.a)}}({h:Number(n),s:Number(a),v:Number(o),a:Number(s)});return b(h)},"hsv"]]},N=function(r,t){for(var n=0;n<t.length;n++){var e=t[n][0](r);if(e)return[e,t[n][1]]}return[null,void 0]},x=function(r){return"string"==typeof r?N(r.trim(),y.string):"object"==typeof r&&null!==r?N(r,y.object):[null,void 0]},I=function(r){return x(r)[1]},M=function(r,t){var n=c(r);return{h:n.h,s:colord_e(n.s+100*t,0,100),l:n.l,a:n.a}},H=function(r){return(299*r.r+587*r.g+114*r.b)/1e3/255},$=function(r,t){var n=c(r);return{h:n.h,s:n.s,l:colord_e(n.l+100*t,0,100),a:n.a}},j=function(){function r(r){this.parsed=x(r)[0],this.rgba=this.parsed||{r:0,g:0,b:0,a:1}}return r.prototype.isValid=function(){return null!==this.parsed},r.prototype.brightness=function(){return colord_n(H(this.rgba),2)},r.prototype.isDark=function(){return H(this.rgba)<.5},r.prototype.isLight=function(){return H(this.rgba)>=.5},r.prototype.toHex=function(){return r=colord_o(this.rgba),t=r.r,e=r.g,u=r.b,i=(a=r.a)<1?s(colord_n(255*a)):"","#"+s(t)+s(e)+s(u)+i;var r,t,e,u,a,i},r.prototype.toRgb=function(){return colord_o(this.rgba)},r.prototype.toRgbString=function(){return r=colord_o(this.rgba),t=r.r,n=r.g,e=r.b,(u=r.a)<1?"rgba("+t+", "+n+", "+e+", "+u+")":"rgb("+t+", "+n+", "+e+")";var r,t,n,e,u},r.prototype.toHsl=function(){return d(c(this.rgba))},r.prototype.toHslString=function(){return r=d(c(this.rgba)),t=r.h,n=r.s,e=r.l,(u=r.a)<1?"hsla("+t+", "+n+"%, "+e+"%, "+u+")":"hsl("+t+", "+n+"%, "+e+"%)";var r,t,n,e,u},r.prototype.toHsv=function(){return r=h(this.rgba),{h:colord_n(r.h),s:colord_n(r.s),v:colord_n(r.v),a:colord_n(r.a,3)};var r},r.prototype.invert=function(){return w({r:255-(r=this.rgba).r,g:255-r.g,b:255-r.b,a:r.a});var r},r.prototype.saturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,r))},r.prototype.desaturate=function(r){return void 0===r&&(r=.1),w(M(this.rgba,-r))},r.prototype.grayscale=function(){return w(M(this.rgba,-1))},r.prototype.lighten=function(r){return void 0===r&&(r=.1),w($(this.rgba,r))},r.prototype.darken=function(r){return void 0===r&&(r=.1),w($(this.rgba,-r))},r.prototype.rotate=function(r){return void 0===r&&(r=15),this.hue(this.hue()+r)},r.prototype.alpha=function(r){return"number"==typeof r?w({r:(t=this.rgba).r,g:t.g,b:t.b,a:r}):colord_n(this.rgba.a,3);var t},r.prototype.hue=function(r){var t=c(this.rgba);return"number"==typeof r?w({h:r,s:t.s,l:t.l,a:t.a}):colord_n(t.h)},r.prototype.isEqual=function(r){return this.toHex()===w(r).toHex()},r}(),w=function(r){return r instanceof j?r:new j(r)},S=[],k=function(r){r.forEach(function(r){S.indexOf(r)<0&&(r(j,y),S.push(r))})},E=function(){return new j({r:255*Math.random(),g:255*Math.random(),b:255*Math.random()})};
;// ./node_modules/colord/plugins/names.mjs
/* harmony default export */ function names(e,f){var a={white:"#ffffff",bisque:"#ffe4c4",blue:"#0000ff",cadetblue:"#5f9ea0",chartreuse:"#7fff00",chocolate:"#d2691e",coral:"#ff7f50",antiquewhite:"#faebd7",aqua:"#00ffff",azure:"#f0ffff",whitesmoke:"#f5f5f5",papayawhip:"#ffefd5",plum:"#dda0dd",blanchedalmond:"#ffebcd",black:"#000000",gold:"#ffd700",goldenrod:"#daa520",gainsboro:"#dcdcdc",cornsilk:"#fff8dc",cornflowerblue:"#6495ed",burlywood:"#deb887",aquamarine:"#7fffd4",beige:"#f5f5dc",crimson:"#dc143c",cyan:"#00ffff",darkblue:"#00008b",darkcyan:"#008b8b",darkgoldenrod:"#b8860b",darkkhaki:"#bdb76b",darkgray:"#a9a9a9",darkgreen:"#006400",darkgrey:"#a9a9a9",peachpuff:"#ffdab9",darkmagenta:"#8b008b",darkred:"#8b0000",darkorchid:"#9932cc",darkorange:"#ff8c00",darkslateblue:"#483d8b",gray:"#808080",darkslategray:"#2f4f4f",darkslategrey:"#2f4f4f",deeppink:"#ff1493",deepskyblue:"#00bfff",wheat:"#f5deb3",firebrick:"#b22222",floralwhite:"#fffaf0",ghostwhite:"#f8f8ff",darkviolet:"#9400d3",magenta:"#ff00ff",green:"#008000",dodgerblue:"#1e90ff",grey:"#808080",honeydew:"#f0fff0",hotpink:"#ff69b4",blueviolet:"#8a2be2",forestgreen:"#228b22",lawngreen:"#7cfc00",indianred:"#cd5c5c",indigo:"#4b0082",fuchsia:"#ff00ff",brown:"#a52a2a",maroon:"#800000",mediumblue:"#0000cd",lightcoral:"#f08080",darkturquoise:"#00ced1",lightcyan:"#e0ffff",ivory:"#fffff0",lightyellow:"#ffffe0",lightsalmon:"#ffa07a",lightseagreen:"#20b2aa",linen:"#faf0e6",mediumaquamarine:"#66cdaa",lemonchiffon:"#fffacd",lime:"#00ff00",khaki:"#f0e68c",mediumseagreen:"#3cb371",limegreen:"#32cd32",mediumspringgreen:"#00fa9a",lightskyblue:"#87cefa",lightblue:"#add8e6",midnightblue:"#191970",lightpink:"#ffb6c1",mistyrose:"#ffe4e1",moccasin:"#ffe4b5",mintcream:"#f5fffa",lightslategray:"#778899",lightslategrey:"#778899",navajowhite:"#ffdead",navy:"#000080",mediumvioletred:"#c71585",powderblue:"#b0e0e6",palegoldenrod:"#eee8aa",oldlace:"#fdf5e6",paleturquoise:"#afeeee",mediumturquoise:"#48d1cc",mediumorchid:"#ba55d3",rebeccapurple:"#663399",lightsteelblue:"#b0c4de",mediumslateblue:"#7b68ee",thistle:"#d8bfd8",tan:"#d2b48c",orchid:"#da70d6",mediumpurple:"#9370db",purple:"#800080",pink:"#ffc0cb",skyblue:"#87ceeb",springgreen:"#00ff7f",palegreen:"#98fb98",red:"#ff0000",yellow:"#ffff00",slateblue:"#6a5acd",lavenderblush:"#fff0f5",peru:"#cd853f",palevioletred:"#db7093",violet:"#ee82ee",teal:"#008080",slategray:"#708090",slategrey:"#708090",aliceblue:"#f0f8ff",darkseagreen:"#8fbc8f",darkolivegreen:"#556b2f",greenyellow:"#adff2f",seagreen:"#2e8b57",seashell:"#fff5ee",tomato:"#ff6347",silver:"#c0c0c0",sienna:"#a0522d",lavender:"#e6e6fa",lightgreen:"#90ee90",orange:"#ffa500",orangered:"#ff4500",steelblue:"#4682b4",royalblue:"#4169e1",turquoise:"#40e0d0",yellowgreen:"#9acd32",salmon:"#fa8072",saddlebrown:"#8b4513",sandybrown:"#f4a460",rosybrown:"#bc8f8f",darksalmon:"#e9967a",lightgoldenrodyellow:"#fafad2",snow:"#fffafa",lightgrey:"#d3d3d3",lightgray:"#d3d3d3",dimgray:"#696969",dimgrey:"#696969",olivedrab:"#6b8e23",olive:"#808000"},r={};for(var d in a)r[a[d]]=d;var l={};e.prototype.toName=function(f){if(!(this.rgba.a||this.rgba.r||this.rgba.g||this.rgba.b))return"transparent";var d,i,n=r[this.toHex()];if(n)return n;if(null==f?void 0:f.closest){var o=this.toRgb(),t=1/0,b="black";if(!l.length)for(var c in a)l[c]=new e(a[c]).toRgb();for(var g in a){var u=(d=o,i=l[g],Math.pow(d.r-i.r,2)+Math.pow(d.g-i.g,2)+Math.pow(d.b-i.b,2));u<t&&(t=u,b=g)}return b}};f.string.push([function(f){var r=f.toLowerCase(),d="transparent"===r?"#0000":a[r];return d?new e(d).toRgb():null},"name"])}
;// ./node_modules/@wordpress/components/build-module/utils/colors.js
let colorComputationNode;
k([names]);
function colors_rgba(hexValue = "", alpha = 1) {
return colord(hexValue).alpha(alpha).toRgbString();
}
function getColorComputationNode() {
if (typeof document === "undefined") {
return;
}
if (!colorComputationNode) {
const el = document.createElement("div");
el.setAttribute("data-g2-color-computation-node", "");
document.body.appendChild(el);
colorComputationNode = el;
}
return colorComputationNode;
}
function isColor(value) {
if (typeof value !== "string") {
return false;
}
const test = w(value);
return test.isValid();
}
function _getComputedBackgroundColor(backgroundColor) {
if (typeof backgroundColor !== "string") {
return "";
}
if (isColor(backgroundColor)) {
return backgroundColor;
}
if (!backgroundColor.includes("var(")) {
return "";
}
if (typeof document === "undefined") {
return "";
}
const el = getColorComputationNode();
if (!el) {
return "";
}
el.style.background = backgroundColor;
const computedColor = window?.getComputedStyle(el).background;
el.style.background = "";
return computedColor || "";
}
const getComputedBackgroundColor = memize(_getComputedBackgroundColor);
function getOptimalTextColor(backgroundColor) {
const background = getComputedBackgroundColor(backgroundColor);
return w(background).isLight() ? "#000000" : "#ffffff";
}
function getOptimalTextShade(backgroundColor) {
const result = getOptimalTextColor(backgroundColor);
return result === "#000000" ? "dark" : "light";
}
;// ./node_modules/@wordpress/components/build-module/text/styles.js
function text_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const Text = /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.theme.foreground, ";line-height:", config_values_default.fontLineHeightBase, ";margin:0;text-wrap:balance;text-wrap:pretty;" + ( true ? "" : 0), true ? "" : 0);
const styles_block = true ? {
name: "4zleql",
styles: "display:block"
} : 0;
const positive = /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.alert.green, ";" + ( true ? "" : 0), true ? "" : 0);
const destructive = /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.alert.red, ";" + ( true ? "" : 0), true ? "" : 0);
const muted = /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.gray[700], ";" + ( true ? "" : 0), true ? "" : 0);
const highlighterText = /* @__PURE__ */ emotion_react_browser_esm_css("mark{background:", COLORS.alert.yellow, ";border-radius:", config_values_default.radiusSmall, ";box-shadow:0 0 0 1px rgba( 0, 0, 0, 0.05 ) inset,0 -1px 0 rgba( 0, 0, 0, 0.1 ) inset;}" + ( true ? "" : 0), true ? "" : 0);
const upperCase = true ? {
name: "50zrmy",
styles: "text-transform:uppercase"
} : 0;
// EXTERNAL MODULE: ./node_modules/highlight-words-core/dist/index.js
var dist = __webpack_require__(9664);
;// ./node_modules/@wordpress/components/build-module/text/utils.js
const lowercaseProps = (object) => {
const mapped = {};
for (const key in object) {
mapped[key.toLowerCase()] = object[key];
}
return mapped;
};
const memoizedLowercaseProps = memize(lowercaseProps);
function createHighlighterText({
activeClassName = "",
activeIndex = -1,
activeStyle,
autoEscape,
caseSensitive = false,
children,
findChunks,
highlightClassName = "",
highlightStyle = {},
highlightTag = "mark",
sanitize,
searchWords = [],
unhighlightClassName = "",
unhighlightStyle
}) {
if (!children) {
return null;
}
if (typeof children !== "string") {
return children;
}
const textToHighlight = children;
const chunks = (0,dist.findAll)({
autoEscape,
caseSensitive,
findChunks,
sanitize,
searchWords,
textToHighlight
});
const HighlightTag = highlightTag;
let highlightIndex = -1;
let highlightClassNames = "";
let highlightStyles;
const textContent = chunks.map((chunk, index) => {
const text = textToHighlight.substr(chunk.start, chunk.end - chunk.start);
if (chunk.highlight) {
highlightIndex++;
let highlightClass;
if (typeof highlightClassName === "object") {
if (!caseSensitive) {
highlightClassName = memoizedLowercaseProps(highlightClassName);
highlightClass = highlightClassName[text.toLowerCase()];
} else {
highlightClass = highlightClassName[text];
}
} else {
highlightClass = highlightClassName;
}
const isActive = highlightIndex === +activeIndex;
highlightClassNames = `${highlightClass} ${isActive ? activeClassName : ""}`;
highlightStyles = isActive === true && activeStyle !== null ? Object.assign({}, highlightStyle, activeStyle) : highlightStyle;
const props = {
children: text,
className: highlightClassNames,
key: index,
style: highlightStyles
};
if (typeof HighlightTag !== "string") {
props.highlightIndex = highlightIndex;
}
return (0,external_wp_element_namespaceObject.createElement)(HighlightTag, props);
}
return (0,external_wp_element_namespaceObject.createElement)("span", {
children: text,
className: unhighlightClassName,
key: index,
style: unhighlightStyle
});
});
return textContent;
}
;// ./node_modules/@wordpress/components/build-module/utils/font-size.js
const BASE_FONT_SIZE = 13;
const PRESET_FONT_SIZES = {
body: BASE_FONT_SIZE,
caption: 10,
footnote: 11,
largeTitle: 28,
subheadline: 12,
title: 20
};
const HEADING_FONT_SIZES = [1, 2, 3, 4, 5, 6].flatMap((n) => [n, n.toString()]);
function getFontSize(size = BASE_FONT_SIZE) {
if (size in PRESET_FONT_SIZES) {
return getFontSize(PRESET_FONT_SIZES[size]);
}
if (typeof size !== "number") {
const parsed = parseFloat(size);
if (Number.isNaN(parsed)) {
return size;
}
size = parsed;
}
const ratio = `(${size} / ${BASE_FONT_SIZE})`;
return `calc(${ratio} * ${config_values_default.fontSize})`;
}
function getHeadingFontSize(size = 3) {
if (!HEADING_FONT_SIZES.includes(size)) {
return getFontSize(size);
}
const headingSize = `fontSizeH${size}`;
return config_values_default[headingSize];
}
;// ./node_modules/@wordpress/components/build-module/text/get-line-height.js
function getLineHeight(adjustLineHeightForInnerControls, lineHeight) {
if (lineHeight) {
return lineHeight;
}
if (!adjustLineHeightForInnerControls) {
return;
}
let value = `calc(${config_values_default.controlHeight} + ${space(2)})`;
switch (adjustLineHeightForInnerControls) {
case "large":
value = `calc(${config_values_default.controlHeightLarge} + ${space(2)})`;
break;
case "small":
value = `calc(${config_values_default.controlHeightSmall} + ${space(2)})`;
break;
case "xSmall":
value = `calc(${config_values_default.controlHeightXSmall} + ${space(2)})`;
break;
default:
break;
}
return value;
}
;// ./node_modules/@wordpress/components/build-module/text/hook.js
function hook_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
var hook_ref = true ? {
name: "50zrmy",
styles: "text-transform:uppercase"
} : 0;
function useText(props) {
const {
adjustLineHeightForInnerControls,
align,
children,
className,
color,
ellipsizeMode,
isDestructive = false,
display,
highlightEscape = false,
highlightCaseSensitive = false,
highlightWords,
highlightSanitize,
isBlock = false,
letterSpacing,
lineHeight: lineHeightProp,
optimizeReadabilityFor,
size,
truncate = false,
upperCase = false,
variant,
weight = config_values_default.fontWeight,
...otherProps
} = useContextSystem(props, "Text");
let content = children;
const isHighlighter = Array.isArray(highlightWords);
const isCaption = size === "caption";
if (isHighlighter) {
if (typeof children !== "string") {
throw new TypeError("`children` of `Text` must only be `string` types when `highlightWords` is defined");
}
content = createHighlighterText({
autoEscape: highlightEscape,
children,
caseSensitive: highlightCaseSensitive,
searchWords: highlightWords,
sanitize: highlightSanitize
});
}
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
const sx = {};
const lineHeight = getLineHeight(adjustLineHeightForInnerControls, lineHeightProp);
sx.Base = /* @__PURE__ */ emotion_react_browser_esm_css({
color,
display,
fontSize: getFontSize(size),
fontWeight: weight,
lineHeight,
letterSpacing,
textAlign: align
}, true ? "" : 0, true ? "" : 0);
sx.upperCase = hook_ref;
sx.optimalTextColor = null;
if (optimizeReadabilityFor) {
const isOptimalTextColorDark = getOptimalTextShade(optimizeReadabilityFor) === "dark";
sx.optimalTextColor = isOptimalTextColorDark ? /* @__PURE__ */ emotion_react_browser_esm_css({
color: COLORS.gray[900]
}, true ? "" : 0, true ? "" : 0) : /* @__PURE__ */ emotion_react_browser_esm_css({
color: COLORS.white
}, true ? "" : 0, true ? "" : 0);
}
return cx(Text, sx.Base, sx.optimalTextColor, isDestructive && destructive, !!isHighlighter && highlighterText, isBlock && styles_block, isCaption && muted, variant && text_styles_namespaceObject[variant], upperCase && sx.upperCase, className);
}, [adjustLineHeightForInnerControls, align, className, color, cx, display, isBlock, isCaption, isDestructive, isHighlighter, letterSpacing, lineHeightProp, optimizeReadabilityFor, size, upperCase, variant, weight]);
let finalEllipsizeMode;
if (truncate === true) {
finalEllipsizeMode = "auto";
}
if (truncate === false) {
finalEllipsizeMode = "none";
}
const finalComponentProps = {
...otherProps,
className: classes,
children,
ellipsizeMode: ellipsizeMode || finalEllipsizeMode
};
const truncateProps = useTruncate(finalComponentProps);
if (!truncate && Array.isArray(children)) {
content = external_wp_element_namespaceObject.Children.map(children, (child) => {
if (typeof child !== "object" || child === null || !("props" in child)) {
return child;
}
const isLink = hasConnectNamespace(child, ["Link"]);
if (isLink) {
return (0,external_wp_element_namespaceObject.cloneElement)(child, {
size: child.props.size || "inherit"
});
}
return child;
});
}
return {
...truncateProps,
children: truncate ? truncateProps.children : content
};
}
;// ./node_modules/@wordpress/components/build-module/text/component.js
function UnconnectedText(props, forwardedRef) {
const textProps = useText(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
as: "span",
...textProps,
ref: forwardedRef
});
}
const component_Text = contextConnect(UnconnectedText, "Text");
var text_component_component_default = component_Text;
;// ./node_modules/@wordpress/components/build-module/utils/base-label.js
function base_label_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const baseLabelTypography = true ? {
name: "9amh4a",
styles: "font-size:11px;font-weight:500;line-height:1.4;text-transform:uppercase"
} : 0;
;// ./node_modules/@wordpress/components/build-module/input-control/styles/input-control-styles.js
function input_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const Prefix = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "em5sgkm8"
} : 0)( true ? {
name: "pvvbxf",
styles: "box-sizing:border-box;display:block"
} : 0);
const Suffix = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "em5sgkm7"
} : 0)( true ? {
name: "jgf79h",
styles: "align-items:center;align-self:stretch;box-sizing:border-box;display:flex"
} : 0);
const backdropBorderColor = ({
disabled,
isBorderless
}) => {
if (isBorderless) {
return "transparent";
}
if (disabled) {
return COLORS.ui.borderDisabled;
}
return COLORS.ui.border;
};
const BackdropUI = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "em5sgkm6"
} : 0)("&&&{box-sizing:border-box;border-color:", backdropBorderColor, ";border-radius:inherit;border-style:solid;border-width:1px;bottom:0;left:0;margin:0;padding:0;pointer-events:none;position:absolute;right:0;top:0;", rtl({
paddingLeft: 2
}), ";}" + ( true ? "" : 0));
const Root = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_component_component_default, true ? {
target: "em5sgkm5"
} : 0)("box-sizing:border-box;position:relative;border-radius:", config_values_default.radiusSmall, ";padding-top:0;&:focus-within:not( :has( :is( ", Prefix, ", ", Suffix, " ):focus-within ) ){", BackdropUI, "{border-color:", COLORS.ui.borderFocus, ";box-shadow:", config_values_default.controlBoxShadowFocus, ";outline:2px solid transparent;outline-offset:-2px;}}" + ( true ? "" : 0));
const containerDisabledStyles = ({
disabled
}) => {
const backgroundColor = disabled ? COLORS.ui.backgroundDisabled : COLORS.ui.background;
return /* @__PURE__ */ emotion_react_browser_esm_css({
backgroundColor
}, true ? "" : 0, true ? "" : 0);
};
var input_control_styles_ref = true ? {
name: "1d3w5wq",
styles: "width:100%"
} : 0;
const containerWidthStyles = ({
__unstableInputWidth,
labelPosition
}) => {
if (!__unstableInputWidth) {
return input_control_styles_ref;
}
if (labelPosition === "side") {
return "";
}
if (labelPosition === "edge") {
return /* @__PURE__ */ emotion_react_browser_esm_css({
flex: `0 0 ${__unstableInputWidth}`
}, true ? "" : 0, true ? "" : 0);
}
return /* @__PURE__ */ emotion_react_browser_esm_css({
width: __unstableInputWidth
}, true ? "" : 0, true ? "" : 0);
};
const Container = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "em5sgkm4"
} : 0)("align-items:center;box-sizing:border-box;border-radius:inherit;display:flex;flex:1;position:relative;", containerDisabledStyles, " ", containerWidthStyles, ";" + ( true ? "" : 0));
const disabledStyles = ({
disabled
}) => {
if (!disabled) {
return "";
}
return /* @__PURE__ */ emotion_react_browser_esm_css({
color: COLORS.ui.textDisabled
}, true ? "" : 0, true ? "" : 0);
};
const fontSizeStyles = ({
inputSize: size
}) => {
const sizes = {
default: "13px",
small: "11px",
compact: "13px",
"__unstable-large": "13px"
};
const fontSize = sizes[size] || sizes.default;
const fontSizeMobile = "16px";
if (!fontSize) {
return "";
}
return /* @__PURE__ */ emotion_react_browser_esm_css("font-size:", fontSizeMobile, ";@media ( min-width: 600px ){font-size:", fontSize, ";}" + ( true ? "" : 0), true ? "" : 0);
};
const getSizeConfig = ({
inputSize: size,
__next40pxDefaultSize
}) => {
const sizes = {
default: {
height: 40,
lineHeight: 1,
minHeight: 40,
paddingLeft: config_values_default.controlPaddingX,
paddingRight: config_values_default.controlPaddingX
},
small: {
height: 24,
lineHeight: 1,
minHeight: 24,
paddingLeft: config_values_default.controlPaddingXSmall,
paddingRight: config_values_default.controlPaddingXSmall
},
compact: {
height: 32,
lineHeight: 1,
minHeight: 32,
paddingLeft: config_values_default.controlPaddingXSmall,
paddingRight: config_values_default.controlPaddingXSmall
},
"__unstable-large": {
height: 40,
lineHeight: 1,
minHeight: 40,
paddingLeft: config_values_default.controlPaddingX,
paddingRight: config_values_default.controlPaddingX
}
};
if (!__next40pxDefaultSize) {
sizes.default = sizes.compact;
}
return sizes[size] || sizes.default;
};
const sizeStyles = (props) => {
return /* @__PURE__ */ emotion_react_browser_esm_css(getSizeConfig(props), true ? "" : 0, true ? "" : 0);
};
const customPaddings = ({
paddingInlineStart,
paddingInlineEnd
}) => {
return /* @__PURE__ */ emotion_react_browser_esm_css({
paddingInlineStart,
paddingInlineEnd
}, true ? "" : 0, true ? "" : 0);
};
const dragStyles = ({
isDragging,
dragCursor
}) => {
let defaultArrowStyles;
let activeDragCursorStyles;
if (isDragging) {
defaultArrowStyles = /* @__PURE__ */ emotion_react_browser_esm_css("cursor:", dragCursor, ";user-select:none;&::-webkit-outer-spin-button,&::-webkit-inner-spin-button{-webkit-appearance:none!important;margin:0!important;}" + ( true ? "" : 0), true ? "" : 0);
}
if (isDragging && dragCursor) {
activeDragCursorStyles = /* @__PURE__ */ emotion_react_browser_esm_css("&:active{cursor:", dragCursor, ";}" + ( true ? "" : 0), true ? "" : 0);
}
return /* @__PURE__ */ emotion_react_browser_esm_css(defaultArrowStyles, " ", activeDragCursorStyles, ";" + ( true ? "" : 0), true ? "" : 0);
};
const Input = /* @__PURE__ */ emotion_styled_base_browser_esm("input", true ? {
target: "em5sgkm3"
} : 0)("&&&{background-color:transparent;box-sizing:border-box;border:none;box-shadow:none!important;color:", COLORS.theme.foreground, ";display:block;font-family:inherit;margin:0;outline:none;width:100%;", dragStyles, " ", disabledStyles, " ", fontSizeStyles, " ", sizeStyles, " ", customPaddings, " &::-webkit-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&::-moz-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&:-ms-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&[type='email'],&[type='url']{direction:ltr;}}" + ( true ? "" : 0));
const BaseLabel = /* @__PURE__ */ emotion_styled_base_browser_esm(text_component_component_default, true ? {
target: "em5sgkm2"
} : 0)("&&&{", baseLabelTypography, ";box-sizing:border-box;display:block;padding-top:0;padding-bottom:0;max-width:100%;z-index:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}" + ( true ? "" : 0));
const Label = (props) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BaseLabel, {
...props,
as: "label"
});
const LabelWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_item_component_component_default, true ? {
target: "em5sgkm1"
} : 0)( true ? {
name: "1b6uupn",
styles: "max-width:calc( 100% - 10px )"
} : 0);
const prefixSuffixWrapperStyles = ({
variant = "default",
size,
__next40pxDefaultSize,
isPrefix
}) => {
const {
paddingLeft: padding
} = getSizeConfig({
inputSize: size,
__next40pxDefaultSize
});
const paddingProperty = isPrefix ? "paddingInlineStart" : "paddingInlineEnd";
if (variant === "default") {
return /* @__PURE__ */ emotion_react_browser_esm_css({
[paddingProperty]: padding
}, true ? "" : 0, true ? "" : 0);
}
return /* @__PURE__ */ emotion_react_browser_esm_css({
display: "flex",
[paddingProperty]: padding - 4
}, true ? "" : 0, true ? "" : 0);
};
const PrefixSuffixWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "em5sgkm0"
} : 0)(prefixSuffixWrapperStyles, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/input-control/backdrop.js
function Backdrop({
disabled = false,
isBorderless = false
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BackdropUI, {
"aria-hidden": "true",
className: "components-input-control__backdrop",
disabled,
isBorderless
});
}
const MemoizedBackdrop = (0,external_wp_element_namespaceObject.memo)(Backdrop);
var backdrop_default = MemoizedBackdrop;
;// ./node_modules/@wordpress/components/build-module/input-control/label.js
function label_Label({
children,
hideLabelFromVision,
htmlFor,
...props
}) {
if (!children) {
return null;
}
if (hideLabelFromVision) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "label",
htmlFor,
children
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LabelWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Label, {
htmlFor,
...props,
children
})
});
}
;// ./node_modules/@wordpress/components/build-module/utils/use-deprecated-props.js
function useDeprecated36pxDefaultSizeProp(props) {
const {
__next36pxDefaultSize,
__next40pxDefaultSize,
...otherProps
} = props;
return {
...otherProps,
__next40pxDefaultSize: __next40pxDefaultSize !== null && __next40pxDefaultSize !== void 0 ? __next40pxDefaultSize : __next36pxDefaultSize
};
}
;// ./node_modules/@wordpress/components/build-module/input-control/input-base.js
function useUniqueId(idProp) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(InputBase);
const id = `input-base-control-${instanceId}`;
return idProp || id;
}
function getUIFlexProps(labelPosition) {
const props = {};
switch (labelPosition) {
case "top":
props.direction = "column";
props.expanded = false;
props.gap = 0;
break;
case "bottom":
props.direction = "column-reverse";
props.expanded = false;
props.gap = 0;
break;
case "edge":
props.justify = "space-between";
break;
}
return props;
}
function InputBase(props, ref) {
const {
__next40pxDefaultSize,
__unstableInputWidth,
children,
className,
disabled = false,
hideLabelFromVision = false,
labelPosition,
id: idProp,
isBorderless = false,
label,
prefix,
size = "default",
suffix,
...restProps
} = useDeprecated36pxDefaultSizeProp(useContextSystem(props, "InputBase"));
const id = useUniqueId(idProp);
const hideLabel = hideLabelFromVision || !label;
const prefixSuffixContextValue = (0,external_wp_element_namespaceObject.useMemo)(() => {
return {
InputControlPrefixWrapper: {
__next40pxDefaultSize,
size
},
InputControlSuffixWrapper: {
__next40pxDefaultSize,
size
}
};
}, [__next40pxDefaultSize, size]);
return (
// @ts-expect-error The `direction` prop from Flex (FlexDirection) conflicts with legacy SVGAttributes `direction` (string) that come from React intrinsic prop definitions.
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Root, {
...restProps,
...getUIFlexProps(labelPosition),
className,
gap: 2,
ref,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(label_Label, {
className: "components-input-control__label",
hideLabelFromVision,
labelPosition,
htmlFor: id,
children: label
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Container, {
__unstableInputWidth,
className: "components-input-control__container",
disabled,
hideLabel,
labelPosition,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ContextSystemProvider, {
value: prefixSuffixContextValue,
children: [prefix && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Prefix, {
className: "components-input-control__prefix",
children: prefix
}), children, suffix && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Suffix, {
className: "components-input-control__suffix",
children: suffix
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(backdrop_default, {
disabled,
isBorderless
})]
})]
})
);
}
var input_base_default = contextConnect(InputBase, "InputBase");
;// ./node_modules/@use-gesture/core/dist/maths-0ab39ae9.esm.js
function maths_0ab39ae9_esm_clamp(v, min, max) {
return Math.max(min, Math.min(v, max));
}
const V = {
toVector(v, fallback) {
if (v === undefined) v = fallback;
return Array.isArray(v) ? v : [v, v];
},
add(v1, v2) {
return [v1[0] + v2[0], v1[1] + v2[1]];
},
sub(v1, v2) {
return [v1[0] - v2[0], v1[1] - v2[1]];
},
addTo(v1, v2) {
v1[0] += v2[0];
v1[1] += v2[1];
},
subTo(v1, v2) {
v1[0] -= v2[0];
v1[1] -= v2[1];
}
};
function rubberband(distance, dimension, constant) {
if (dimension === 0 || Math.abs(dimension) === Infinity) return Math.pow(distance, constant * 5);
return distance * dimension * constant / (dimension + constant * distance);
}
function rubberbandIfOutOfBounds(position, min, max, constant = 0.15) {
if (constant === 0) return maths_0ab39ae9_esm_clamp(position, min, max);
if (position < min) return -rubberband(min - position, max - min, constant) + min;
if (position > max) return +rubberband(position - max, max - min, constant) + max;
return position;
}
function computeRubberband(bounds, [Vx, Vy], [Rx, Ry]) {
const [[X0, X1], [Y0, Y1]] = bounds;
return [rubberbandIfOutOfBounds(Vx, X0, X1, Rx), rubberbandIfOutOfBounds(Vy, Y0, Y1, Ry)];
}
;// ./node_modules/@use-gesture/core/dist/actions-fe213e88.esm.js
function _toPrimitive(input, hint) {
if (typeof input !== "object" || input === null) return input;
var prim = input[Symbol.toPrimitive];
if (prim !== undefined) {
var res = prim.call(input, hint || "default");
if (typeof res !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (hint === "string" ? String : Number)(input);
}
function _toPropertyKey(arg) {
var key = _toPrimitive(arg, "string");
return typeof key === "symbol" ? key : String(key);
}
function _defineProperty(obj, key, value) {
key = _toPropertyKey(key);
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function actions_fe213e88_esm_ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function (r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread2(e) {
for (var r = 1; r < arguments.length; r++) {
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? actions_fe213e88_esm_ownKeys(Object(t), !0).forEach(function (r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : actions_fe213e88_esm_ownKeys(Object(t)).forEach(function (r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
const EVENT_TYPE_MAP = {
pointer: {
start: 'down',
change: 'move',
end: 'up'
},
mouse: {
start: 'down',
change: 'move',
end: 'up'
},
touch: {
start: 'start',
change: 'move',
end: 'end'
},
gesture: {
start: 'start',
change: 'change',
end: 'end'
}
};
function capitalize(string) {
if (!string) return '';
return string[0].toUpperCase() + string.slice(1);
}
const actionsWithoutCaptureSupported = ['enter', 'leave'];
function hasCapture(capture = false, actionKey) {
return capture && !actionsWithoutCaptureSupported.includes(actionKey);
}
function toHandlerProp(device, action = '', capture = false) {
const deviceProps = EVENT_TYPE_MAP[device];
const actionKey = deviceProps ? deviceProps[action] || action : action;
return 'on' + capitalize(device) + capitalize(actionKey) + (hasCapture(capture, actionKey) ? 'Capture' : '');
}
const pointerCaptureEvents = ['gotpointercapture', 'lostpointercapture'];
function parseProp(prop) {
let eventKey = prop.substring(2).toLowerCase();
const passive = !!~eventKey.indexOf('passive');
if (passive) eventKey = eventKey.replace('passive', '');
const captureKey = pointerCaptureEvents.includes(eventKey) ? 'capturecapture' : 'capture';
const capture = !!~eventKey.indexOf(captureKey);
if (capture) eventKey = eventKey.replace('capture', '');
return {
device: eventKey,
capture,
passive
};
}
function toDomEventType(device, action = '') {
const deviceProps = EVENT_TYPE_MAP[device];
const actionKey = deviceProps ? deviceProps[action] || action : action;
return device + actionKey;
}
function isTouch(event) {
return 'touches' in event;
}
function getPointerType(event) {
if (isTouch(event)) return 'touch';
if ('pointerType' in event) return event.pointerType;
return 'mouse';
}
function getCurrentTargetTouchList(event) {
return Array.from(event.touches).filter(e => {
var _event$currentTarget, _event$currentTarget$;
return e.target === event.currentTarget || ((_event$currentTarget = event.currentTarget) === null || _event$currentTarget === void 0 || (_event$currentTarget$ = _event$currentTarget.contains) === null || _event$currentTarget$ === void 0 ? void 0 : _event$currentTarget$.call(_event$currentTarget, e.target));
});
}
function getTouchList(event) {
return event.type === 'touchend' || event.type === 'touchcancel' ? event.changedTouches : event.targetTouches;
}
function getValueEvent(event) {
return isTouch(event) ? getTouchList(event)[0] : event;
}
function distanceAngle(P1, P2) {
try {
const dx = P2.clientX - P1.clientX;
const dy = P2.clientY - P1.clientY;
const cx = (P2.clientX + P1.clientX) / 2;
const cy = (P2.clientY + P1.clientY) / 2;
const distance = Math.hypot(dx, dy);
const angle = -(Math.atan2(dx, dy) * 180) / Math.PI;
const origin = [cx, cy];
return {
angle,
distance,
origin
};
} catch (_unused) {}
return null;
}
function touchIds(event) {
return getCurrentTargetTouchList(event).map(touch => touch.identifier);
}
function touchDistanceAngle(event, ids) {
const [P1, P2] = Array.from(event.touches).filter(touch => ids.includes(touch.identifier));
return distanceAngle(P1, P2);
}
function pointerId(event) {
const valueEvent = getValueEvent(event);
return isTouch(event) ? valueEvent.identifier : valueEvent.pointerId;
}
function pointerValues(event) {
const valueEvent = getValueEvent(event);
return [valueEvent.clientX, valueEvent.clientY];
}
const LINE_HEIGHT = 40;
const PAGE_HEIGHT = 800;
function wheelValues(event) {
let {
deltaX,
deltaY,
deltaMode
} = event;
if (deltaMode === 1) {
deltaX *= LINE_HEIGHT;
deltaY *= LINE_HEIGHT;
} else if (deltaMode === 2) {
deltaX *= PAGE_HEIGHT;
deltaY *= PAGE_HEIGHT;
}
return [deltaX, deltaY];
}
function scrollValues(event) {
var _ref, _ref2;
const {
scrollX,
scrollY,
scrollLeft,
scrollTop
} = event.currentTarget;
return [(_ref = scrollX !== null && scrollX !== void 0 ? scrollX : scrollLeft) !== null && _ref !== void 0 ? _ref : 0, (_ref2 = scrollY !== null && scrollY !== void 0 ? scrollY : scrollTop) !== null && _ref2 !== void 0 ? _ref2 : 0];
}
function getEventDetails(event) {
const payload = {};
if ('buttons' in event) payload.buttons = event.buttons;
if ('shiftKey' in event) {
const {
shiftKey,
altKey,
metaKey,
ctrlKey
} = event;
Object.assign(payload, {
shiftKey,
altKey,
metaKey,
ctrlKey
});
}
return payload;
}
function call(v, ...args) {
if (typeof v === 'function') {
return v(...args);
} else {
return v;
}
}
function actions_fe213e88_esm_noop() {}
function actions_fe213e88_esm_chain(...fns) {
if (fns.length === 0) return actions_fe213e88_esm_noop;
if (fns.length === 1) return fns[0];
return function () {
let result;
for (const fn of fns) {
result = fn.apply(this, arguments) || result;
}
return result;
};
}
function assignDefault(value, fallback) {
return Object.assign({}, fallback, value || {});
}
const BEFORE_LAST_KINEMATICS_DELAY = 32;
class Engine {
constructor(ctrl, args, key) {
this.ctrl = ctrl;
this.args = args;
this.key = key;
if (!this.state) {
this.state = {};
this.computeValues([0, 0]);
this.computeInitial();
if (this.init) this.init();
this.reset();
}
}
get state() {
return this.ctrl.state[this.key];
}
set state(state) {
this.ctrl.state[this.key] = state;
}
get shared() {
return this.ctrl.state.shared;
}
get eventStore() {
return this.ctrl.gestureEventStores[this.key];
}
get timeoutStore() {
return this.ctrl.gestureTimeoutStores[this.key];
}
get config() {
return this.ctrl.config[this.key];
}
get sharedConfig() {
return this.ctrl.config.shared;
}
get handler() {
return this.ctrl.handlers[this.key];
}
reset() {
const {
state,
shared,
ingKey,
args
} = this;
shared[ingKey] = state._active = state.active = state._blocked = state._force = false;
state._step = [false, false];
state.intentional = false;
state._movement = [0, 0];
state._distance = [0, 0];
state._direction = [0, 0];
state._delta = [0, 0];
state._bounds = [[-Infinity, Infinity], [-Infinity, Infinity]];
state.args = args;
state.axis = undefined;
state.memo = undefined;
state.elapsedTime = state.timeDelta = 0;
state.direction = [0, 0];
state.distance = [0, 0];
state.overflow = [0, 0];
state._movementBound = [false, false];
state.velocity = [0, 0];
state.movement = [0, 0];
state.delta = [0, 0];
state.timeStamp = 0;
}
start(event) {
const state = this.state;
const config = this.config;
if (!state._active) {
this.reset();
this.computeInitial();
state._active = true;
state.target = event.target;
state.currentTarget = event.currentTarget;
state.lastOffset = config.from ? call(config.from, state) : state.offset;
state.offset = state.lastOffset;
state.startTime = state.timeStamp = event.timeStamp;
}
}
computeValues(values) {
const state = this.state;
state._values = values;
state.values = this.config.transform(values);
}
computeInitial() {
const state = this.state;
state._initial = state._values;
state.initial = state.values;
}
compute(event) {
const {
state,
config,
shared
} = this;
state.args = this.args;
let dt = 0;
if (event) {
state.event = event;
if (config.preventDefault && event.cancelable) state.event.preventDefault();
state.type = event.type;
shared.touches = this.ctrl.pointerIds.size || this.ctrl.touchIds.size;
shared.locked = !!document.pointerLockElement;
Object.assign(shared, getEventDetails(event));
shared.down = shared.pressed = shared.buttons % 2 === 1 || shared.touches > 0;
dt = event.timeStamp - state.timeStamp;
state.timeStamp = event.timeStamp;
state.elapsedTime = state.timeStamp - state.startTime;
}
if (state._active) {
const _absoluteDelta = state._delta.map(Math.abs);
V.addTo(state._distance, _absoluteDelta);
}
if (this.axisIntent) this.axisIntent(event);
const [_m0, _m1] = state._movement;
const [t0, t1] = config.threshold;
const {
_step,
values
} = state;
if (config.hasCustomTransform) {
if (_step[0] === false) _step[0] = Math.abs(_m0) >= t0 && values[0];
if (_step[1] === false) _step[1] = Math.abs(_m1) >= t1 && values[1];
} else {
if (_step[0] === false) _step[0] = Math.abs(_m0) >= t0 && Math.sign(_m0) * t0;
if (_step[1] === false) _step[1] = Math.abs(_m1) >= t1 && Math.sign(_m1) * t1;
}
state.intentional = _step[0] !== false || _step[1] !== false;
if (!state.intentional) return;
const movement = [0, 0];
if (config.hasCustomTransform) {
const [v0, v1] = values;
movement[0] = _step[0] !== false ? v0 - _step[0] : 0;
movement[1] = _step[1] !== false ? v1 - _step[1] : 0;
} else {
movement[0] = _step[0] !== false ? _m0 - _step[0] : 0;
movement[1] = _step[1] !== false ? _m1 - _step[1] : 0;
}
if (this.restrictToAxis && !state._blocked) this.restrictToAxis(movement);
const previousOffset = state.offset;
const gestureIsActive = state._active && !state._blocked || state.active;
if (gestureIsActive) {
state.first = state._active && !state.active;
state.last = !state._active && state.active;
state.active = shared[this.ingKey] = state._active;
if (event) {
if (state.first) {
if ('bounds' in config) state._bounds = call(config.bounds, state);
if (this.setup) this.setup();
}
state.movement = movement;
this.computeOffset();
}
}
const [ox, oy] = state.offset;
const [[x0, x1], [y0, y1]] = state._bounds;
state.overflow = [ox < x0 ? -1 : ox > x1 ? 1 : 0, oy < y0 ? -1 : oy > y1 ? 1 : 0];
state._movementBound[0] = state.overflow[0] ? state._movementBound[0] === false ? state._movement[0] : state._movementBound[0] : false;
state._movementBound[1] = state.overflow[1] ? state._movementBound[1] === false ? state._movement[1] : state._movementBound[1] : false;
const rubberband = state._active ? config.rubberband || [0, 0] : [0, 0];
state.offset = computeRubberband(state._bounds, state.offset, rubberband);
state.delta = V.sub(state.offset, previousOffset);
this.computeMovement();
if (gestureIsActive && (!state.last || dt > BEFORE_LAST_KINEMATICS_DELAY)) {
state.delta = V.sub(state.offset, previousOffset);
const absoluteDelta = state.delta.map(Math.abs);
V.addTo(state.distance, absoluteDelta);
state.direction = state.delta.map(Math.sign);
state._direction = state._delta.map(Math.sign);
if (!state.first && dt > 0) {
state.velocity = [absoluteDelta[0] / dt, absoluteDelta[1] / dt];
state.timeDelta = dt;
}
}
}
emit() {
const state = this.state;
const shared = this.shared;
const config = this.config;
if (!state._active) this.clean();
if ((state._blocked || !state.intentional) && !state._force && !config.triggerAllEvents) return;
const memo = this.handler(_objectSpread2(_objectSpread2(_objectSpread2({}, shared), state), {}, {
[this.aliasKey]: state.values
}));
if (memo !== undefined) state.memo = memo;
}
clean() {
this.eventStore.clean();
this.timeoutStore.clean();
}
}
function selectAxis([dx, dy], threshold) {
const absDx = Math.abs(dx);
const absDy = Math.abs(dy);
if (absDx > absDy && absDx > threshold) {
return 'x';
}
if (absDy > absDx && absDy > threshold) {
return 'y';
}
return undefined;
}
class CoordinatesEngine extends Engine {
constructor(...args) {
super(...args);
_defineProperty(this, "aliasKey", 'xy');
}
reset() {
super.reset();
this.state.axis = undefined;
}
init() {
this.state.offset = [0, 0];
this.state.lastOffset = [0, 0];
}
computeOffset() {
this.state.offset = V.add(this.state.lastOffset, this.state.movement);
}
computeMovement() {
this.state.movement = V.sub(this.state.offset, this.state.lastOffset);
}
axisIntent(event) {
const state = this.state;
const config = this.config;
if (!state.axis && event) {
const threshold = typeof config.axisThreshold === 'object' ? config.axisThreshold[getPointerType(event)] : config.axisThreshold;
state.axis = selectAxis(state._movement, threshold);
}
state._blocked = (config.lockDirection || !!config.axis) && !state.axis || !!config.axis && config.axis !== state.axis;
}
restrictToAxis(v) {
if (this.config.axis || this.config.lockDirection) {
switch (this.state.axis) {
case 'x':
v[1] = 0;
break;
case 'y':
v[0] = 0;
break;
}
}
}
}
const actions_fe213e88_esm_identity = v => v;
const DEFAULT_RUBBERBAND = 0.15;
const commonConfigResolver = {
enabled(value = true) {
return value;
},
eventOptions(value, _k, config) {
return _objectSpread2(_objectSpread2({}, config.shared.eventOptions), value);
},
preventDefault(value = false) {
return value;
},
triggerAllEvents(value = false) {
return value;
},
rubberband(value = 0) {
switch (value) {
case true:
return [DEFAULT_RUBBERBAND, DEFAULT_RUBBERBAND];
case false:
return [0, 0];
default:
return V.toVector(value);
}
},
from(value) {
if (typeof value === 'function') return value;
if (value != null) return V.toVector(value);
},
transform(value, _k, config) {
const transform = value || config.shared.transform;
this.hasCustomTransform = !!transform;
if (false) {}
return transform || actions_fe213e88_esm_identity;
},
threshold(value) {
return V.toVector(value, 0);
}
};
if (false) {}
const DEFAULT_AXIS_THRESHOLD = 0;
const coordinatesConfigResolver = _objectSpread2(_objectSpread2({}, commonConfigResolver), {}, {
axis(_v, _k, {
axis
}) {
this.lockDirection = axis === 'lock';
if (!this.lockDirection) return axis;
},
axisThreshold(value = DEFAULT_AXIS_THRESHOLD) {
return value;
},
bounds(value = {}) {
if (typeof value === 'function') {
return state => coordinatesConfigResolver.bounds(value(state));
}
if ('current' in value) {
return () => value.current;
}
if (typeof HTMLElement === 'function' && value instanceof HTMLElement) {
return value;
}
const {
left = -Infinity,
right = Infinity,
top = -Infinity,
bottom = Infinity
} = value;
return [[left, right], [top, bottom]];
}
});
const KEYS_DELTA_MAP = {
ArrowRight: (displacement, factor = 1) => [displacement * factor, 0],
ArrowLeft: (displacement, factor = 1) => [-1 * displacement * factor, 0],
ArrowUp: (displacement, factor = 1) => [0, -1 * displacement * factor],
ArrowDown: (displacement, factor = 1) => [0, displacement * factor]
};
class DragEngine extends CoordinatesEngine {
constructor(...args) {
super(...args);
_defineProperty(this, "ingKey", 'dragging');
}
reset() {
super.reset();
const state = this.state;
state._pointerId = undefined;
state._pointerActive = false;
state._keyboardActive = false;
state._preventScroll = false;
state._delayed = false;
state.swipe = [0, 0];
state.tap = false;
state.canceled = false;
state.cancel = this.cancel.bind(this);
}
setup() {
const state = this.state;
if (state._bounds instanceof HTMLElement) {
const boundRect = state._bounds.getBoundingClientRect();
const targetRect = state.currentTarget.getBoundingClientRect();
const _bounds = {
left: boundRect.left - targetRect.left + state.offset[0],
right: boundRect.right - targetRect.right + state.offset[0],
top: boundRect.top - targetRect.top + state.offset[1],
bottom: boundRect.bottom - targetRect.bottom + state.offset[1]
};
state._bounds = coordinatesConfigResolver.bounds(_bounds);
}
}
cancel() {
const state = this.state;
if (state.canceled) return;
state.canceled = true;
state._active = false;
setTimeout(() => {
this.compute();
this.emit();
}, 0);
}
setActive() {
this.state._active = this.state._pointerActive || this.state._keyboardActive;
}
clean() {
this.pointerClean();
this.state._pointerActive = false;
this.state._keyboardActive = false;
super.clean();
}
pointerDown(event) {
const config = this.config;
const state = this.state;
if (event.buttons != null && (Array.isArray(config.pointerButtons) ? !config.pointerButtons.includes(event.buttons) : config.pointerButtons !== -1 && config.pointerButtons !== event.buttons)) return;
const ctrlIds = this.ctrl.setEventIds(event);
if (config.pointerCapture) {
event.target.setPointerCapture(event.pointerId);
}
if (ctrlIds && ctrlIds.size > 1 && state._pointerActive) return;
this.start(event);
this.setupPointer(event);
state._pointerId = pointerId(event);
state._pointerActive = true;
this.computeValues(pointerValues(event));
this.computeInitial();
if (config.preventScrollAxis && getPointerType(event) !== 'mouse') {
state._active = false;
this.setupScrollPrevention(event);
} else if (config.delay > 0) {
this.setupDelayTrigger(event);
if (config.triggerAllEvents) {
this.compute(event);
this.emit();
}
} else {
this.startPointerDrag(event);
}
}
startPointerDrag(event) {
const state = this.state;
state._active = true;
state._preventScroll = true;
state._delayed = false;
this.compute(event);
this.emit();
}
pointerMove(event) {
const state = this.state;
const config = this.config;
if (!state._pointerActive) return;
const id = pointerId(event);
if (state._pointerId !== undefined && id !== state._pointerId) return;
const _values = pointerValues(event);
if (document.pointerLockElement === event.target) {
state._delta = [event.movementX, event.movementY];
} else {
state._delta = V.sub(_values, state._values);
this.computeValues(_values);
}
V.addTo(state._movement, state._delta);
this.compute(event);
if (state._delayed && state.intentional) {
this.timeoutStore.remove('dragDelay');
state.active = false;
this.startPointerDrag(event);
return;
}
if (config.preventScrollAxis && !state._preventScroll) {
if (state.axis) {
if (state.axis === config.preventScrollAxis || config.preventScrollAxis === 'xy') {
state._active = false;
this.clean();
return;
} else {
this.timeoutStore.remove('startPointerDrag');
this.startPointerDrag(event);
return;
}
} else {
return;
}
}
this.emit();
}
pointerUp(event) {
this.ctrl.setEventIds(event);
try {
if (this.config.pointerCapture && event.target.hasPointerCapture(event.pointerId)) {
;
event.target.releasePointerCapture(event.pointerId);
}
} catch (_unused) {
if (false) {}
}
const state = this.state;
const config = this.config;
if (!state._active || !state._pointerActive) return;
const id = pointerId(event);
if (state._pointerId !== undefined && id !== state._pointerId) return;
this.state._pointerActive = false;
this.setActive();
this.compute(event);
const [dx, dy] = state._distance;
state.tap = dx <= config.tapsThreshold && dy <= config.tapsThreshold;
if (state.tap && config.filterTaps) {
state._force = true;
} else {
const [_dx, _dy] = state._delta;
const [_mx, _my] = state._movement;
const [svx, svy] = config.swipe.velocity;
const [sx, sy] = config.swipe.distance;
const sdt = config.swipe.duration;
if (state.elapsedTime < sdt) {
const _vx = Math.abs(_dx / state.timeDelta);
const _vy = Math.abs(_dy / state.timeDelta);
if (_vx > svx && Math.abs(_mx) > sx) state.swipe[0] = Math.sign(_dx);
if (_vy > svy && Math.abs(_my) > sy) state.swipe[1] = Math.sign(_dy);
}
}
this.emit();
}
pointerClick(event) {
if (!this.state.tap && event.detail > 0) {
event.preventDefault();
event.stopPropagation();
}
}
setupPointer(event) {
const config = this.config;
const device = config.device;
if (false) {}
if (config.pointerLock) {
event.currentTarget.requestPointerLock();
}
if (!config.pointerCapture) {
this.eventStore.add(this.sharedConfig.window, device, 'change', this.pointerMove.bind(this));
this.eventStore.add(this.sharedConfig.window, device, 'end', this.pointerUp.bind(this));
this.eventStore.add(this.sharedConfig.window, device, 'cancel', this.pointerUp.bind(this));
}
}
pointerClean() {
if (this.config.pointerLock && document.pointerLockElement === this.state.currentTarget) {
document.exitPointerLock();
}
}
preventScroll(event) {
if (this.state._preventScroll && event.cancelable) {
event.preventDefault();
}
}
setupScrollPrevention(event) {
this.state._preventScroll = false;
persistEvent(event);
const remove = this.eventStore.add(this.sharedConfig.window, 'touch', 'change', this.preventScroll.bind(this), {
passive: false
});
this.eventStore.add(this.sharedConfig.window, 'touch', 'end', remove);
this.eventStore.add(this.sharedConfig.window, 'touch', 'cancel', remove);
this.timeoutStore.add('startPointerDrag', this.startPointerDrag.bind(this), this.config.preventScrollDelay, event);
}
setupDelayTrigger(event) {
this.state._delayed = true;
this.timeoutStore.add('dragDelay', () => {
this.state._step = [0, 0];
this.startPointerDrag(event);
}, this.config.delay);
}
keyDown(event) {
const deltaFn = KEYS_DELTA_MAP[event.key];
if (deltaFn) {
const state = this.state;
const factor = event.shiftKey ? 10 : event.altKey ? 0.1 : 1;
this.start(event);
state._delta = deltaFn(this.config.keyboardDisplacement, factor);
state._keyboardActive = true;
V.addTo(state._movement, state._delta);
this.compute(event);
this.emit();
}
}
keyUp(event) {
if (!(event.key in KEYS_DELTA_MAP)) return;
this.state._keyboardActive = false;
this.setActive();
this.compute(event);
this.emit();
}
bind(bindFunction) {
const device = this.config.device;
bindFunction(device, 'start', this.pointerDown.bind(this));
if (this.config.pointerCapture) {
bindFunction(device, 'change', this.pointerMove.bind(this));
bindFunction(device, 'end', this.pointerUp.bind(this));
bindFunction(device, 'cancel', this.pointerUp.bind(this));
bindFunction('lostPointerCapture', '', this.pointerUp.bind(this));
}
if (this.config.keys) {
bindFunction('key', 'down', this.keyDown.bind(this));
bindFunction('key', 'up', this.keyUp.bind(this));
}
if (this.config.filterTaps) {
bindFunction('click', '', this.pointerClick.bind(this), {
capture: true,
passive: false
});
}
}
}
function persistEvent(event) {
'persist' in event && typeof event.persist === 'function' && event.persist();
}
const actions_fe213e88_esm_isBrowser = typeof window !== 'undefined' && window.document && window.document.createElement;
function supportsTouchEvents() {
return actions_fe213e88_esm_isBrowser && 'ontouchstart' in window;
}
function isTouchScreen() {
return supportsTouchEvents() || actions_fe213e88_esm_isBrowser && window.navigator.maxTouchPoints > 1;
}
function supportsPointerEvents() {
return actions_fe213e88_esm_isBrowser && 'onpointerdown' in window;
}
function supportsPointerLock() {
return actions_fe213e88_esm_isBrowser && 'exitPointerLock' in window.document;
}
function supportsGestureEvents() {
try {
return 'constructor' in GestureEvent;
} catch (e) {
return false;
}
}
const SUPPORT = {
isBrowser: actions_fe213e88_esm_isBrowser,
gesture: supportsGestureEvents(),
touch: supportsTouchEvents(),
touchscreen: isTouchScreen(),
pointer: supportsPointerEvents(),
pointerLock: supportsPointerLock()
};
const DEFAULT_PREVENT_SCROLL_DELAY = 250;
const DEFAULT_DRAG_DELAY = 180;
const DEFAULT_SWIPE_VELOCITY = 0.5;
const DEFAULT_SWIPE_DISTANCE = 50;
const DEFAULT_SWIPE_DURATION = 250;
const DEFAULT_KEYBOARD_DISPLACEMENT = 10;
const DEFAULT_DRAG_AXIS_THRESHOLD = {
mouse: 0,
touch: 0,
pen: 8
};
const dragConfigResolver = _objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
device(_v, _k, {
pointer: {
touch = false,
lock = false,
mouse = false
} = {}
}) {
this.pointerLock = lock && SUPPORT.pointerLock;
if (SUPPORT.touch && touch) return 'touch';
if (this.pointerLock) return 'mouse';
if (SUPPORT.pointer && !mouse) return 'pointer';
if (SUPPORT.touch) return 'touch';
return 'mouse';
},
preventScrollAxis(value, _k, {
preventScroll
}) {
this.preventScrollDelay = typeof preventScroll === 'number' ? preventScroll : preventScroll || preventScroll === undefined && value ? DEFAULT_PREVENT_SCROLL_DELAY : undefined;
if (!SUPPORT.touchscreen || preventScroll === false) return undefined;
return value ? value : preventScroll !== undefined ? 'y' : undefined;
},
pointerCapture(_v, _k, {
pointer: {
capture = true,
buttons = 1,
keys = true
} = {}
}) {
this.pointerButtons = buttons;
this.keys = keys;
return !this.pointerLock && this.device === 'pointer' && capture;
},
threshold(value, _k, {
filterTaps = false,
tapsThreshold = 3,
axis = undefined
}) {
const threshold = V.toVector(value, filterTaps ? tapsThreshold : axis ? 1 : 0);
this.filterTaps = filterTaps;
this.tapsThreshold = tapsThreshold;
return threshold;
},
swipe({
velocity = DEFAULT_SWIPE_VELOCITY,
distance = DEFAULT_SWIPE_DISTANCE,
duration = DEFAULT_SWIPE_DURATION
} = {}) {
return {
velocity: this.transform(V.toVector(velocity)),
distance: this.transform(V.toVector(distance)),
duration
};
},
delay(value = 0) {
switch (value) {
case true:
return DEFAULT_DRAG_DELAY;
case false:
return 0;
default:
return value;
}
},
axisThreshold(value) {
if (!value) return DEFAULT_DRAG_AXIS_THRESHOLD;
return _objectSpread2(_objectSpread2({}, DEFAULT_DRAG_AXIS_THRESHOLD), value);
},
keyboardDisplacement(value = DEFAULT_KEYBOARD_DISPLACEMENT) {
return value;
}
});
if (false) {}
function clampStateInternalMovementToBounds(state) {
const [ox, oy] = state.overflow;
const [dx, dy] = state._delta;
const [dirx, diry] = state._direction;
if (ox < 0 && dx > 0 && dirx < 0 || ox > 0 && dx < 0 && dirx > 0) {
state._movement[0] = state._movementBound[0];
}
if (oy < 0 && dy > 0 && diry < 0 || oy > 0 && dy < 0 && diry > 0) {
state._movement[1] = state._movementBound[1];
}
}
const SCALE_ANGLE_RATIO_INTENT_DEG = 30;
const PINCH_WHEEL_RATIO = 100;
class PinchEngine extends Engine {
constructor(...args) {
super(...args);
_defineProperty(this, "ingKey", 'pinching');
_defineProperty(this, "aliasKey", 'da');
}
init() {
this.state.offset = [1, 0];
this.state.lastOffset = [1, 0];
this.state._pointerEvents = new Map();
}
reset() {
super.reset();
const state = this.state;
state._touchIds = [];
state.canceled = false;
state.cancel = this.cancel.bind(this);
state.turns = 0;
}
computeOffset() {
const {
type,
movement,
lastOffset
} = this.state;
if (type === 'wheel') {
this.state.offset = V.add(movement, lastOffset);
} else {
this.state.offset = [(1 + movement[0]) * lastOffset[0], movement[1] + lastOffset[1]];
}
}
computeMovement() {
const {
offset,
lastOffset
} = this.state;
this.state.movement = [offset[0] / lastOffset[0], offset[1] - lastOffset[1]];
}
axisIntent() {
const state = this.state;
const [_m0, _m1] = state._movement;
if (!state.axis) {
const axisMovementDifference = Math.abs(_m0) * SCALE_ANGLE_RATIO_INTENT_DEG - Math.abs(_m1);
if (axisMovementDifference < 0) state.axis = 'angle';else if (axisMovementDifference > 0) state.axis = 'scale';
}
}
restrictToAxis(v) {
if (this.config.lockDirection) {
if (this.state.axis === 'scale') v[1] = 0;else if (this.state.axis === 'angle') v[0] = 0;
}
}
cancel() {
const state = this.state;
if (state.canceled) return;
setTimeout(() => {
state.canceled = true;
state._active = false;
this.compute();
this.emit();
}, 0);
}
touchStart(event) {
this.ctrl.setEventIds(event);
const state = this.state;
const ctrlTouchIds = this.ctrl.touchIds;
if (state._active) {
if (state._touchIds.every(id => ctrlTouchIds.has(id))) return;
}
if (ctrlTouchIds.size < 2) return;
this.start(event);
state._touchIds = Array.from(ctrlTouchIds).slice(0, 2);
const payload = touchDistanceAngle(event, state._touchIds);
if (!payload) return;
this.pinchStart(event, payload);
}
pointerStart(event) {
if (event.buttons != null && event.buttons % 2 !== 1) return;
this.ctrl.setEventIds(event);
event.target.setPointerCapture(event.pointerId);
const state = this.state;
const _pointerEvents = state._pointerEvents;
const ctrlPointerIds = this.ctrl.pointerIds;
if (state._active) {
if (Array.from(_pointerEvents.keys()).every(id => ctrlPointerIds.has(id))) return;
}
if (_pointerEvents.size < 2) {
_pointerEvents.set(event.pointerId, event);
}
if (state._pointerEvents.size < 2) return;
this.start(event);
const payload = distanceAngle(...Array.from(_pointerEvents.values()));
if (!payload) return;
this.pinchStart(event, payload);
}
pinchStart(event, payload) {
const state = this.state;
state.origin = payload.origin;
this.computeValues([payload.distance, payload.angle]);
this.computeInitial();
this.compute(event);
this.emit();
}
touchMove(event) {
if (!this.state._active) return;
const payload = touchDistanceAngle(event, this.state._touchIds);
if (!payload) return;
this.pinchMove(event, payload);
}
pointerMove(event) {
const _pointerEvents = this.state._pointerEvents;
if (_pointerEvents.has(event.pointerId)) {
_pointerEvents.set(event.pointerId, event);
}
if (!this.state._active) return;
const payload = distanceAngle(...Array.from(_pointerEvents.values()));
if (!payload) return;
this.pinchMove(event, payload);
}
pinchMove(event, payload) {
const state = this.state;
const prev_a = state._values[1];
const delta_a = payload.angle - prev_a;
let delta_turns = 0;
if (Math.abs(delta_a) > 270) delta_turns += Math.sign(delta_a);
this.computeValues([payload.distance, payload.angle - 360 * delta_turns]);
state.origin = payload.origin;
state.turns = delta_turns;
state._movement = [state._values[0] / state._initial[0] - 1, state._values[1] - state._initial[1]];
this.compute(event);
this.emit();
}
touchEnd(event) {
this.ctrl.setEventIds(event);
if (!this.state._active) return;
if (this.state._touchIds.some(id => !this.ctrl.touchIds.has(id))) {
this.state._active = false;
this.compute(event);
this.emit();
}
}
pointerEnd(event) {
const state = this.state;
this.ctrl.setEventIds(event);
try {
event.target.releasePointerCapture(event.pointerId);
} catch (_unused) {}
if (state._pointerEvents.has(event.pointerId)) {
state._pointerEvents.delete(event.pointerId);
}
if (!state._active) return;
if (state._pointerEvents.size < 2) {
state._active = false;
this.compute(event);
this.emit();
}
}
gestureStart(event) {
if (event.cancelable) event.preventDefault();
const state = this.state;
if (state._active) return;
this.start(event);
this.computeValues([event.scale, event.rotation]);
state.origin = [event.clientX, event.clientY];
this.compute(event);
this.emit();
}
gestureMove(event) {
if (event.cancelable) event.preventDefault();
if (!this.state._active) return;
const state = this.state;
this.computeValues([event.scale, event.rotation]);
state.origin = [event.clientX, event.clientY];
const _previousMovement = state._movement;
state._movement = [event.scale - 1, event.rotation];
state._delta = V.sub(state._movement, _previousMovement);
this.compute(event);
this.emit();
}
gestureEnd(event) {
if (!this.state._active) return;
this.state._active = false;
this.compute(event);
this.emit();
}
wheel(event) {
const modifierKey = this.config.modifierKey;
if (modifierKey && (Array.isArray(modifierKey) ? !modifierKey.find(k => event[k]) : !event[modifierKey])) return;
if (!this.state._active) this.wheelStart(event);else this.wheelChange(event);
this.timeoutStore.add('wheelEnd', this.wheelEnd.bind(this));
}
wheelStart(event) {
this.start(event);
this.wheelChange(event);
}
wheelChange(event) {
const isR3f = ('uv' in event);
if (!isR3f) {
if (event.cancelable) {
event.preventDefault();
}
if (false) {}
}
const state = this.state;
state._delta = [-wheelValues(event)[1] / PINCH_WHEEL_RATIO * state.offset[0], 0];
V.addTo(state._movement, state._delta);
clampStateInternalMovementToBounds(state);
this.state.origin = [event.clientX, event.clientY];
this.compute(event);
this.emit();
}
wheelEnd() {
if (!this.state._active) return;
this.state._active = false;
this.compute();
this.emit();
}
bind(bindFunction) {
const device = this.config.device;
if (!!device) {
bindFunction(device, 'start', this[device + 'Start'].bind(this));
bindFunction(device, 'change', this[device + 'Move'].bind(this));
bindFunction(device, 'end', this[device + 'End'].bind(this));
bindFunction(device, 'cancel', this[device + 'End'].bind(this));
bindFunction('lostPointerCapture', '', this[device + 'End'].bind(this));
}
if (this.config.pinchOnWheel) {
bindFunction('wheel', '', this.wheel.bind(this), {
passive: false
});
}
}
}
const pinchConfigResolver = _objectSpread2(_objectSpread2({}, commonConfigResolver), {}, {
device(_v, _k, {
shared,
pointer: {
touch = false
} = {}
}) {
const sharedConfig = shared;
if (sharedConfig.target && !SUPPORT.touch && SUPPORT.gesture) return 'gesture';
if (SUPPORT.touch && touch) return 'touch';
if (SUPPORT.touchscreen) {
if (SUPPORT.pointer) return 'pointer';
if (SUPPORT.touch) return 'touch';
}
},
bounds(_v, _k, {
scaleBounds = {},
angleBounds = {}
}) {
const _scaleBounds = state => {
const D = assignDefault(call(scaleBounds, state), {
min: -Infinity,
max: Infinity
});
return [D.min, D.max];
};
const _angleBounds = state => {
const A = assignDefault(call(angleBounds, state), {
min: -Infinity,
max: Infinity
});
return [A.min, A.max];
};
if (typeof scaleBounds !== 'function' && typeof angleBounds !== 'function') return [_scaleBounds(), _angleBounds()];
return state => [_scaleBounds(state), _angleBounds(state)];
},
threshold(value, _k, config) {
this.lockDirection = config.axis === 'lock';
const threshold = V.toVector(value, this.lockDirection ? [0.1, 3] : 0);
return threshold;
},
modifierKey(value) {
if (value === undefined) return 'ctrlKey';
return value;
},
pinchOnWheel(value = true) {
return value;
}
});
class MoveEngine extends CoordinatesEngine {
constructor(...args) {
super(...args);
_defineProperty(this, "ingKey", 'moving');
}
move(event) {
if (this.config.mouseOnly && event.pointerType !== 'mouse') return;
if (!this.state._active) this.moveStart(event);else this.moveChange(event);
this.timeoutStore.add('moveEnd', this.moveEnd.bind(this));
}
moveStart(event) {
this.start(event);
this.computeValues(pointerValues(event));
this.compute(event);
this.computeInitial();
this.emit();
}
moveChange(event) {
if (!this.state._active) return;
const values = pointerValues(event);
const state = this.state;
state._delta = V.sub(values, state._values);
V.addTo(state._movement, state._delta);
this.computeValues(values);
this.compute(event);
this.emit();
}
moveEnd(event) {
if (!this.state._active) return;
this.state._active = false;
this.compute(event);
this.emit();
}
bind(bindFunction) {
bindFunction('pointer', 'change', this.move.bind(this));
bindFunction('pointer', 'leave', this.moveEnd.bind(this));
}
}
const moveConfigResolver = _objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
mouseOnly: (value = true) => value
});
class ScrollEngine extends CoordinatesEngine {
constructor(...args) {
super(...args);
_defineProperty(this, "ingKey", 'scrolling');
}
scroll(event) {
if (!this.state._active) this.start(event);
this.scrollChange(event);
this.timeoutStore.add('scrollEnd', this.scrollEnd.bind(this));
}
scrollChange(event) {
if (event.cancelable) event.preventDefault();
const state = this.state;
const values = scrollValues(event);
state._delta = V.sub(values, state._values);
V.addTo(state._movement, state._delta);
this.computeValues(values);
this.compute(event);
this.emit();
}
scrollEnd() {
if (!this.state._active) return;
this.state._active = false;
this.compute();
this.emit();
}
bind(bindFunction) {
bindFunction('scroll', '', this.scroll.bind(this));
}
}
const scrollConfigResolver = coordinatesConfigResolver;
class WheelEngine extends CoordinatesEngine {
constructor(...args) {
super(...args);
_defineProperty(this, "ingKey", 'wheeling');
}
wheel(event) {
if (!this.state._active) this.start(event);
this.wheelChange(event);
this.timeoutStore.add('wheelEnd', this.wheelEnd.bind(this));
}
wheelChange(event) {
const state = this.state;
state._delta = wheelValues(event);
V.addTo(state._movement, state._delta);
clampStateInternalMovementToBounds(state);
this.compute(event);
this.emit();
}
wheelEnd() {
if (!this.state._active) return;
this.state._active = false;
this.compute();
this.emit();
}
bind(bindFunction) {
bindFunction('wheel', '', this.wheel.bind(this));
}
}
const wheelConfigResolver = coordinatesConfigResolver;
class HoverEngine extends CoordinatesEngine {
constructor(...args) {
super(...args);
_defineProperty(this, "ingKey", 'hovering');
}
enter(event) {
if (this.config.mouseOnly && event.pointerType !== 'mouse') return;
this.start(event);
this.computeValues(pointerValues(event));
this.compute(event);
this.emit();
}
leave(event) {
if (this.config.mouseOnly && event.pointerType !== 'mouse') return;
const state = this.state;
if (!state._active) return;
state._active = false;
const values = pointerValues(event);
state._movement = state._delta = V.sub(values, state._values);
this.computeValues(values);
this.compute(event);
state.delta = state.movement;
this.emit();
}
bind(bindFunction) {
bindFunction('pointer', 'enter', this.enter.bind(this));
bindFunction('pointer', 'leave', this.leave.bind(this));
}
}
const hoverConfigResolver = _objectSpread2(_objectSpread2({}, coordinatesConfigResolver), {}, {
mouseOnly: (value = true) => value
});
const actions_fe213e88_esm_EngineMap = new Map();
const ConfigResolverMap = new Map();
function actions_fe213e88_esm_registerAction(action) {
actions_fe213e88_esm_EngineMap.set(action.key, action.engine);
ConfigResolverMap.set(action.key, action.resolver);
}
const actions_fe213e88_esm_dragAction = {
key: 'drag',
engine: DragEngine,
resolver: dragConfigResolver
};
const actions_fe213e88_esm_hoverAction = {
key: 'hover',
engine: HoverEngine,
resolver: hoverConfigResolver
};
const actions_fe213e88_esm_moveAction = {
key: 'move',
engine: MoveEngine,
resolver: moveConfigResolver
};
const actions_fe213e88_esm_pinchAction = {
key: 'pinch',
engine: PinchEngine,
resolver: pinchConfigResolver
};
const actions_fe213e88_esm_scrollAction = {
key: 'scroll',
engine: ScrollEngine,
resolver: scrollConfigResolver
};
const actions_fe213e88_esm_wheelAction = {
key: 'wheel',
engine: WheelEngine,
resolver: wheelConfigResolver
};
;// ./node_modules/@use-gesture/core/dist/use-gesture-core.esm.js
function _objectWithoutPropertiesLoose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
function _objectWithoutProperties(source, excluded) {
if (source == null) return {};
var target = _objectWithoutPropertiesLoose(source, excluded);
var key, i;
if (Object.getOwnPropertySymbols) {
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
for (i = 0; i < sourceSymbolKeys.length; i++) {
key = sourceSymbolKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
}
return target;
}
const sharedConfigResolver = {
target(value) {
if (value) {
return () => 'current' in value ? value.current : value;
}
return undefined;
},
enabled(value = true) {
return value;
},
window(value = SUPPORT.isBrowser ? window : undefined) {
return value;
},
eventOptions({
passive = true,
capture = false
} = {}) {
return {
passive,
capture
};
},
transform(value) {
return value;
}
};
const _excluded = ["target", "eventOptions", "window", "enabled", "transform"];
function resolveWith(config = {}, resolvers) {
const result = {};
for (const [key, resolver] of Object.entries(resolvers)) {
switch (typeof resolver) {
case 'function':
if (false) {} else {
result[key] = resolver.call(result, config[key], key, config);
}
break;
case 'object':
result[key] = resolveWith(config[key], resolver);
break;
case 'boolean':
if (resolver) result[key] = config[key];
break;
}
}
return result;
}
function use_gesture_core_esm_parse(newConfig, gestureKey, _config = {}) {
const _ref = newConfig,
{
target,
eventOptions,
window,
enabled,
transform
} = _ref,
rest = _objectWithoutProperties(_ref, _excluded);
_config.shared = resolveWith({
target,
eventOptions,
window,
enabled,
transform
}, sharedConfigResolver);
if (gestureKey) {
const resolver = ConfigResolverMap.get(gestureKey);
_config[gestureKey] = resolveWith(_objectSpread2({
shared: _config.shared
}, rest), resolver);
} else {
for (const key in rest) {
const resolver = ConfigResolverMap.get(key);
if (resolver) {
_config[key] = resolveWith(_objectSpread2({
shared: _config.shared
}, rest[key]), resolver);
} else if (false) {}
}
}
return _config;
}
class EventStore {
constructor(ctrl, gestureKey) {
_defineProperty(this, "_listeners", new Set());
this._ctrl = ctrl;
this._gestureKey = gestureKey;
}
add(element, device, action, handler, options) {
const listeners = this._listeners;
const type = toDomEventType(device, action);
const _options = this._gestureKey ? this._ctrl.config[this._gestureKey].eventOptions : {};
const eventOptions = _objectSpread2(_objectSpread2({}, _options), options);
element.addEventListener(type, handler, eventOptions);
const remove = () => {
element.removeEventListener(type, handler, eventOptions);
listeners.delete(remove);
};
listeners.add(remove);
return remove;
}
clean() {
this._listeners.forEach(remove => remove());
this._listeners.clear();
}
}
class TimeoutStore {
constructor() {
_defineProperty(this, "_timeouts", new Map());
}
add(key, callback, ms = 140, ...args) {
this.remove(key);
this._timeouts.set(key, window.setTimeout(callback, ms, ...args));
}
remove(key) {
const timeout = this._timeouts.get(key);
if (timeout) window.clearTimeout(timeout);
}
clean() {
this._timeouts.forEach(timeout => void window.clearTimeout(timeout));
this._timeouts.clear();
}
}
class Controller {
constructor(handlers) {
_defineProperty(this, "gestures", new Set());
_defineProperty(this, "_targetEventStore", new EventStore(this));
_defineProperty(this, "gestureEventStores", {});
_defineProperty(this, "gestureTimeoutStores", {});
_defineProperty(this, "handlers", {});
_defineProperty(this, "config", {});
_defineProperty(this, "pointerIds", new Set());
_defineProperty(this, "touchIds", new Set());
_defineProperty(this, "state", {
shared: {
shiftKey: false,
metaKey: false,
ctrlKey: false,
altKey: false
}
});
resolveGestures(this, handlers);
}
setEventIds(event) {
if (isTouch(event)) {
this.touchIds = new Set(touchIds(event));
return this.touchIds;
} else if ('pointerId' in event) {
if (event.type === 'pointerup' || event.type === 'pointercancel') this.pointerIds.delete(event.pointerId);else if (event.type === 'pointerdown') this.pointerIds.add(event.pointerId);
return this.pointerIds;
}
}
applyHandlers(handlers, nativeHandlers) {
this.handlers = handlers;
this.nativeHandlers = nativeHandlers;
}
applyConfig(config, gestureKey) {
this.config = use_gesture_core_esm_parse(config, gestureKey, this.config);
}
clean() {
this._targetEventStore.clean();
for (const key of this.gestures) {
this.gestureEventStores[key].clean();
this.gestureTimeoutStores[key].clean();
}
}
effect() {
if (this.config.shared.target) this.bind();
return () => this._targetEventStore.clean();
}
bind(...args) {
const sharedConfig = this.config.shared;
const props = {};
let target;
if (sharedConfig.target) {
target = sharedConfig.target();
if (!target) return;
}
if (sharedConfig.enabled) {
for (const gestureKey of this.gestures) {
const gestureConfig = this.config[gestureKey];
const bindFunction = bindToProps(props, gestureConfig.eventOptions, !!target);
if (gestureConfig.enabled) {
const Engine = actions_fe213e88_esm_EngineMap.get(gestureKey);
new Engine(this, args, gestureKey).bind(bindFunction);
}
}
const nativeBindFunction = bindToProps(props, sharedConfig.eventOptions, !!target);
for (const eventKey in this.nativeHandlers) {
nativeBindFunction(eventKey, '', event => this.nativeHandlers[eventKey](_objectSpread2(_objectSpread2({}, this.state.shared), {}, {
event,
args
})), undefined, true);
}
}
for (const handlerProp in props) {
props[handlerProp] = actions_fe213e88_esm_chain(...props[handlerProp]);
}
if (!target) return props;
for (const handlerProp in props) {
const {
device,
capture,
passive
} = parseProp(handlerProp);
this._targetEventStore.add(target, device, '', props[handlerProp], {
capture,
passive
});
}
}
}
function use_gesture_core_esm_setupGesture(ctrl, gestureKey) {
ctrl.gestures.add(gestureKey);
ctrl.gestureEventStores[gestureKey] = new EventStore(ctrl, gestureKey);
ctrl.gestureTimeoutStores[gestureKey] = new TimeoutStore();
}
function resolveGestures(ctrl, internalHandlers) {
if (internalHandlers.drag) use_gesture_core_esm_setupGesture(ctrl, 'drag');
if (internalHandlers.wheel) use_gesture_core_esm_setupGesture(ctrl, 'wheel');
if (internalHandlers.scroll) use_gesture_core_esm_setupGesture(ctrl, 'scroll');
if (internalHandlers.move) use_gesture_core_esm_setupGesture(ctrl, 'move');
if (internalHandlers.pinch) use_gesture_core_esm_setupGesture(ctrl, 'pinch');
if (internalHandlers.hover) use_gesture_core_esm_setupGesture(ctrl, 'hover');
}
const bindToProps = (props, eventOptions, withPassiveOption) => (device, action, handler, options = {}, isNative = false) => {
var _options$capture, _options$passive;
const capture = (_options$capture = options.capture) !== null && _options$capture !== void 0 ? _options$capture : eventOptions.capture;
const passive = (_options$passive = options.passive) !== null && _options$passive !== void 0 ? _options$passive : eventOptions.passive;
let handlerProp = isNative ? device : toHandlerProp(device, action, capture);
if (withPassiveOption && passive) handlerProp += 'Passive';
props[handlerProp] = props[handlerProp] || [];
props[handlerProp].push(handler);
};
const RE_NOT_NATIVE = /^on(Drag|Wheel|Scroll|Move|Pinch|Hover)/;
function sortHandlers(_handlers) {
const native = {};
const handlers = {};
const actions = new Set();
for (let key in _handlers) {
if (RE_NOT_NATIVE.test(key)) {
actions.add(RegExp.lastMatch);
handlers[key] = _handlers[key];
} else {
native[key] = _handlers[key];
}
}
return [handlers, native, actions];
}
function registerGesture(actions, handlers, handlerKey, key, internalHandlers, config) {
if (!actions.has(handlerKey)) return;
if (!EngineMap.has(key)) {
if (false) {}
return;
}
const startKey = handlerKey + 'Start';
const endKey = handlerKey + 'End';
const fn = state => {
let memo = undefined;
if (state.first && startKey in handlers) handlers[startKey](state);
if (handlerKey in handlers) memo = handlers[handlerKey](state);
if (state.last && endKey in handlers) handlers[endKey](state);
return memo;
};
internalHandlers[key] = fn;
config[key] = config[key] || {};
}
function use_gesture_core_esm_parseMergedHandlers(mergedHandlers, mergedConfig) {
const [handlers, nativeHandlers, actions] = sortHandlers(mergedHandlers);
const internalHandlers = {};
registerGesture(actions, handlers, 'onDrag', 'drag', internalHandlers, mergedConfig);
registerGesture(actions, handlers, 'onWheel', 'wheel', internalHandlers, mergedConfig);
registerGesture(actions, handlers, 'onScroll', 'scroll', internalHandlers, mergedConfig);
registerGesture(actions, handlers, 'onPinch', 'pinch', internalHandlers, mergedConfig);
registerGesture(actions, handlers, 'onMove', 'move', internalHandlers, mergedConfig);
registerGesture(actions, handlers, 'onHover', 'hover', internalHandlers, mergedConfig);
return {
handlers: internalHandlers,
config: mergedConfig,
nativeHandlers
};
}
;// ./node_modules/@use-gesture/react/dist/use-gesture-react.esm.js
function useRecognizers(handlers, config = {}, gestureKey, nativeHandlers) {
const ctrl = external_React_default().useMemo(() => new Controller(handlers), []);
ctrl.applyHandlers(handlers, nativeHandlers);
ctrl.applyConfig(config, gestureKey);
external_React_default().useEffect(ctrl.effect.bind(ctrl));
external_React_default().useEffect(() => {
return ctrl.clean.bind(ctrl);
}, []);
if (config.target === undefined) {
return ctrl.bind.bind(ctrl);
}
return undefined;
}
function useDrag(handler, config) {
actions_fe213e88_esm_registerAction(actions_fe213e88_esm_dragAction);
return useRecognizers({
drag: handler
}, config || {}, 'drag');
}
function usePinch(handler, config) {
registerAction(pinchAction);
return useRecognizers({
pinch: handler
}, config || {}, 'pinch');
}
function useWheel(handler, config) {
registerAction(wheelAction);
return useRecognizers({
wheel: handler
}, config || {}, 'wheel');
}
function useScroll(handler, config) {
registerAction(scrollAction);
return useRecognizers({
scroll: handler
}, config || {}, 'scroll');
}
function useMove(handler, config) {
registerAction(moveAction);
return useRecognizers({
move: handler
}, config || {}, 'move');
}
function useHover(handler, config) {
registerAction(hoverAction);
return useRecognizers({
hover: handler
}, config || {}, 'hover');
}
function createUseGesture(actions) {
actions.forEach(registerAction);
return function useGesture(_handlers, _config) {
const {
handlers,
nativeHandlers,
config
} = parseMergedHandlers(_handlers, _config || {});
return useRecognizers(handlers, config, undefined, nativeHandlers);
};
}
function useGesture(handlers, config) {
const hook = createUseGesture([dragAction, pinchAction, scrollAction, wheelAction, moveAction, hoverAction]);
return hook(handlers, config || {});
}
;// ./node_modules/@wordpress/components/build-module/input-control/utils.js
function getDragCursor(dragDirection) {
let dragCursor = "ns-resize";
switch (dragDirection) {
case "n":
case "s":
dragCursor = "ns-resize";
break;
case "e":
case "w":
dragCursor = "ew-resize";
break;
}
return dragCursor;
}
function useDragCursor(isDragging, dragDirection) {
const dragCursor = getDragCursor(dragDirection);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (isDragging) {
document.documentElement.style.cursor = dragCursor;
} else {
document.documentElement.style.cursor = null;
}
}, [isDragging, dragCursor]);
return dragCursor;
}
function useDraft(props) {
const previousValueRef = (0,external_wp_element_namespaceObject.useRef)(props.value);
const [draft, setDraft] = (0,external_wp_element_namespaceObject.useState)({});
const value = draft.value !== void 0 ? draft.value : props.value;
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
const {
current: previousValue
} = previousValueRef;
previousValueRef.current = props.value;
if (draft.value !== void 0 && !draft.isStale) {
setDraft({
...draft,
isStale: true
});
} else if (draft.isStale && props.value !== previousValue) {
setDraft({});
}
}, [props.value, draft]);
const onChange = (nextValue, extra) => {
setDraft((current) => Object.assign(current, {
value: nextValue,
isStale: false
}));
props.onChange(nextValue, extra);
};
const onBlur = (event) => {
setDraft({});
props.onBlur?.(event);
};
return {
value,
onBlur,
onChange
};
}
;// ./node_modules/@wordpress/components/build-module/input-control/reducer/state.js
const initialStateReducer = (state) => state;
const initialInputControlState = {
error: null,
initialValue: "",
isDirty: false,
isDragEnabled: false,
isDragging: false,
isPressEnterToChange: false,
value: ""
};
;// ./node_modules/@wordpress/components/build-module/input-control/reducer/actions.js
const CHANGE = "CHANGE";
const COMMIT = "COMMIT";
const CONTROL = "CONTROL";
const DRAG_END = "DRAG_END";
const DRAG_START = "DRAG_START";
const DRAG = "DRAG";
const INVALIDATE = "INVALIDATE";
const PRESS_DOWN = "PRESS_DOWN";
const PRESS_ENTER = "PRESS_ENTER";
const PRESS_UP = "PRESS_UP";
const RESET = "RESET";
;// ./node_modules/@wordpress/components/build-module/input-control/reducer/reducer.js
function mergeInitialState(initialState = initialInputControlState) {
const {
value
} = initialState;
return {
...initialInputControlState,
...initialState,
initialValue: value
};
}
function inputControlStateReducer(composedStateReducers) {
return (state, action) => {
const nextState = {
...state
};
switch (action.type) {
/*
* Controlled updates
*/
case CONTROL:
nextState.value = action.payload.value;
nextState.isDirty = false;
nextState._event = void 0;
return nextState;
/**
* Keyboard events
*/
case PRESS_UP:
nextState.isDirty = false;
break;
case PRESS_DOWN:
nextState.isDirty = false;
break;
/**
* Drag events
*/
case DRAG_START:
nextState.isDragging = true;
break;
case DRAG_END:
nextState.isDragging = false;
break;
/**
* Input events
*/
case CHANGE:
nextState.error = null;
nextState.value = action.payload.value;
if (state.isPressEnterToChange) {
nextState.isDirty = true;
}
break;
case COMMIT:
nextState.value = action.payload.value;
nextState.isDirty = false;
break;
case RESET:
nextState.error = null;
nextState.isDirty = false;
nextState.value = action.payload.value || state.initialValue;
break;
/**
* Validation
*/
case INVALIDATE:
nextState.error = action.payload.error;
break;
}
nextState._event = action.payload.event;
return composedStateReducers(nextState, action);
};
}
function useInputControlStateReducer(stateReducer = initialStateReducer, initialState = initialInputControlState, onChangeHandler) {
const [state, dispatch] = (0,external_wp_element_namespaceObject.useReducer)(inputControlStateReducer(stateReducer), mergeInitialState(initialState));
const createChangeEvent = (type) => (nextValue, event) => {
dispatch({
type,
payload: {
value: nextValue,
event
}
});
};
const createKeyEvent = (type) => (event) => {
dispatch({
type,
payload: {
event
}
});
};
const createDragEvent = (type) => (payload) => {
dispatch({
type,
payload
});
};
const change = createChangeEvent(CHANGE);
const invalidate = (error, event) => dispatch({
type: INVALIDATE,
payload: {
error,
event
}
});
const reset = createChangeEvent(RESET);
const commit = createChangeEvent(COMMIT);
const dragStart = createDragEvent(DRAG_START);
const drag = createDragEvent(DRAG);
const dragEnd = createDragEvent(DRAG_END);
const pressUp = createKeyEvent(PRESS_UP);
const pressDown = createKeyEvent(PRESS_DOWN);
const pressEnter = createKeyEvent(PRESS_ENTER);
const currentStateRef = (0,external_wp_element_namespaceObject.useRef)(state);
const refPropsRef = (0,external_wp_element_namespaceObject.useRef)({
value: initialState.value,
onChangeHandler
});
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
currentStateRef.current = state;
refPropsRef.current = {
value: initialState.value,
onChangeHandler
};
});
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (currentStateRef.current._event !== void 0 && state.value !== refPropsRef.current.value && !state.isDirty) {
var _state$value;
refPropsRef.current.onChangeHandler((_state$value = state.value) !== null && _state$value !== void 0 ? _state$value : "", {
event: currentStateRef.current._event
});
}
}, [state.value, state.isDirty]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (initialState.value !== currentStateRef.current.value && !currentStateRef.current.isDirty) {
var _initialState$value;
dispatch({
type: CONTROL,
payload: {
value: (_initialState$value = initialState.value) !== null && _initialState$value !== void 0 ? _initialState$value : ""
}
});
}
}, [initialState.value]);
return {
change,
commit,
dispatch,
drag,
dragEnd,
dragStart,
invalidate,
pressDown,
pressEnter,
pressUp,
reset,
state
};
}
;// ./node_modules/@wordpress/components/build-module/utils/with-ignore-ime-events.js
function withIgnoreIMEEvents(handler) {
return (event) => {
const {
isComposing
} = "nativeEvent" in event ? event.nativeEvent : event;
if (isComposing || // Workaround for Mac Safari where the final Enter/Backspace of an IME composition
// is `isComposing=false`, even though it's technically still part of the composition.
// These can only be detected by keyCode.
event.keyCode === 229) {
return;
}
handler(event);
};
}
;// ./node_modules/@wordpress/components/build-module/input-control/input-field.js
const input_field_noop = () => {
};
function InputField({
disabled = false,
dragDirection = "n",
dragThreshold = 10,
id,
isDragEnabled = false,
isPressEnterToChange = false,
onBlur = input_field_noop,
onChange = input_field_noop,
onDrag = input_field_noop,
onDragEnd = input_field_noop,
onDragStart = input_field_noop,
onKeyDown = input_field_noop,
onValidate = input_field_noop,
size = "default",
stateReducer = (state) => state,
value: valueProp,
type,
...props
}, ref) {
const {
// State.
state,
// Actions.
change,
commit,
drag,
dragEnd,
dragStart,
invalidate,
pressDown,
pressEnter,
pressUp,
reset
} = useInputControlStateReducer(stateReducer, {
isDragEnabled,
value: valueProp,
isPressEnterToChange
}, onChange);
const {
value,
isDragging,
isDirty
} = state;
const wasDirtyOnBlur = (0,external_wp_element_namespaceObject.useRef)(false);
const dragCursor = useDragCursor(isDragging, dragDirection);
const handleOnBlur = (event) => {
onBlur(event);
if (isDirty || !event.target.validity.valid) {
wasDirtyOnBlur.current = true;
handleOnCommit(event);
}
};
const handleOnChange = (event) => {
const nextValue = event.target.value;
change(nextValue, event);
};
const handleOnCommit = (event) => {
const nextValue = event.currentTarget.value;
try {
onValidate(nextValue);
commit(nextValue, event);
} catch (err) {
invalidate(err, event);
}
};
const handleOnKeyDown = (event) => {
const {
key
} = event;
onKeyDown(event);
switch (key) {
case "ArrowUp":
pressUp(event);
break;
case "ArrowDown":
pressDown(event);
break;
case "Enter":
pressEnter(event);
if (isPressEnterToChange) {
event.preventDefault();
handleOnCommit(event);
}
break;
case "Escape":
if (isPressEnterToChange && isDirty) {
event.preventDefault();
reset(valueProp, event);
}
break;
}
};
const dragGestureProps = useDrag((dragProps2) => {
const {
distance,
dragging,
event,
target
} = dragProps2;
dragProps2.event = {
...dragProps2.event,
target
};
if (!distance) {
return;
}
event.stopPropagation();
if (!dragging) {
onDragEnd(dragProps2);
dragEnd(dragProps2);
return;
}
onDrag(dragProps2);
drag(dragProps2);
if (!isDragging) {
onDragStart(dragProps2);
dragStart(dragProps2);
}
}, {
axis: dragDirection === "e" || dragDirection === "w" ? "x" : "y",
threshold: dragThreshold,
enabled: isDragEnabled,
pointer: {
capture: false
}
});
const dragProps = isDragEnabled ? dragGestureProps() : {};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Input, {
...props,
...dragProps,
className: "components-input-control__input",
disabled,
dragCursor,
isDragging,
id,
onBlur: handleOnBlur,
onChange: handleOnChange,
onKeyDown: withIgnoreIMEEvents(handleOnKeyDown),
ref,
inputSize: size,
value: value !== null && value !== void 0 ? value : "",
type
});
}
const ForwardedComponent = (0,external_wp_element_namespaceObject.forwardRef)(InputField);
var input_field_default = ForwardedComponent;
;// ./node_modules/@wordpress/components/build-module/utils/font-values.js
var font_values_default = {
"default.fontFamily": "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen-Sans, Ubuntu, Cantarell, 'Helvetica Neue', sans-serif",
"default.fontSize": "13px",
"helpText.fontSize": "12px",
mobileTextMinFontSize: "16px"
};
;// ./node_modules/@wordpress/components/build-module/utils/font.js
function font(value) {
var _FONT$value;
return (_FONT$value = font_values_default[value]) !== null && _FONT$value !== void 0 ? _FONT$value : "";
}
;// ./node_modules/@wordpress/components/build-module/utils/box-sizing.js
function box_sizing_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const boxSizingReset = true ? {
name: "kv6lnz",
styles: "box-sizing:border-box;*,*::before,*::after{box-sizing:inherit;}"
} : 0;
;// ./node_modules/@wordpress/components/build-module/base-control/styles/base-control-styles.js
function base_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const Wrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "ej5x27r4"
} : 0)("font-family:", font("default.fontFamily"), ";font-size:", font("default.fontSize"), ";", boxSizingReset, ";" + ( true ? "" : 0));
const deprecatedMarginField = ({
__nextHasNoMarginBottom = false
}) => {
return !__nextHasNoMarginBottom && /* @__PURE__ */ emotion_react_browser_esm_css("margin-bottom:", space(2), ";" + ( true ? "" : 0), true ? "" : 0);
};
const StyledField = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "ej5x27r3"
} : 0)(deprecatedMarginField, " .components-panel__row &{margin-bottom:inherit;}" + ( true ? "" : 0));
const labelStyles = /* @__PURE__ */ emotion_react_browser_esm_css(baseLabelTypography, ";display:block;margin-bottom:", space(2), ";padding:0;" + ( true ? "" : 0), true ? "" : 0);
const StyledLabel = /* @__PURE__ */ emotion_styled_base_browser_esm("label", true ? {
target: "ej5x27r2"
} : 0)(labelStyles, ";" + ( true ? "" : 0));
var base_control_styles_ref = true ? {
name: "11yad0w",
styles: "margin-bottom:revert"
} : 0;
const deprecatedMarginHelp = ({
__nextHasNoMarginBottom = false
}) => {
return !__nextHasNoMarginBottom && base_control_styles_ref;
};
const StyledHelp = /* @__PURE__ */ emotion_styled_base_browser_esm("p", true ? {
target: "ej5x27r1"
} : 0)("margin-top:", space(2), ";margin-bottom:0;font-size:", font("helpText.fontSize"), ";font-style:normal;color:", COLORS.gray[700], ";", deprecatedMarginHelp, ";" + ( true ? "" : 0));
const StyledVisualLabel = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "ej5x27r0"
} : 0)(labelStyles, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/base-control/index.js
const UnconnectedBaseControl = (props) => {
const {
__nextHasNoMarginBottom = false,
__associatedWPComponentName = "BaseControl",
id,
label,
hideLabelFromVision = false,
help,
className,
children
} = useContextSystem(props, "BaseControl");
if (!__nextHasNoMarginBottom) {
external_wp_deprecated_default()(`Bottom margin styles for wp.components.${__associatedWPComponentName}`, {
since: "6.7",
version: "7.0",
hint: "Set the `__nextHasNoMarginBottom` prop to true to start opting into the new styles, which will become the default in a future version."
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
className,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(StyledField, {
className: "components-base-control__field",
__nextHasNoMarginBottom,
children: [label && id && (hideLabelFromVision ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "label",
htmlFor: id,
children: label
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledLabel, {
className: "components-base-control__label",
htmlFor: id,
children: label
})), label && !id && (hideLabelFromVision ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "label",
children: label
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(VisualLabel, {
children: label
})), children]
}), !!help && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledHelp, {
id: id ? id + "__help" : void 0,
className: "components-base-control__help",
__nextHasNoMarginBottom,
children: help
})]
});
};
const UnforwardedVisualLabel = (props, ref) => {
const {
className,
children,
...restProps
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledVisualLabel, {
ref,
...restProps,
className: dist_clsx("components-base-control__label", className),
children
});
};
const VisualLabel = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedVisualLabel);
const BaseControl = Object.assign(contextConnectWithoutRef(UnconnectedBaseControl, "BaseControl"), {
/**
* `BaseControl.VisualLabel` is used to render a purely visual label inside a `BaseControl` component.
*
* It should only be used in cases where the children being rendered inside `BaseControl` are already accessibly labeled,
* e.g., a button, but we want an additional visual label for that section equivalent to the labels `BaseControl` would
* otherwise use if the `label` prop was passed.
*
* ```jsx
* import { BaseControl } from '@wordpress/components';
*
* const MyBaseControl = () => (
* <BaseControl
* __nextHasNoMarginBottom
* help="This button is already accessibly labeled."
* >
* <BaseControl.VisualLabel>Author</BaseControl.VisualLabel>
* <Button>Select an author</Button>
* </BaseControl>
* );
* ```
*/
VisualLabel
});
var base_control_default = BaseControl;
;// ./node_modules/@wordpress/components/build-module/utils/deprecated-36px-size.js
function maybeWarnDeprecated36pxSize({
componentName,
__next40pxDefaultSize,
size,
__shouldNotWarnDeprecated36pxSize
}) {
if (__shouldNotWarnDeprecated36pxSize || __next40pxDefaultSize || size !== void 0 && size !== "default") {
return;
}
external_wp_deprecated_default()(`36px default size for wp.components.${componentName}`, {
since: "6.8",
version: "7.1",
hint: "Set the `__next40pxDefaultSize` prop to true to start opting into the new default size, which will become the default in a future version."
});
}
;// ./node_modules/@wordpress/components/build-module/input-control/index.js
const input_control_noop = () => {
};
function input_control_useUniqueId(idProp) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(InputControl);
const id = `inspector-input-control-${instanceId}`;
return idProp || id;
}
function UnforwardedInputControl(props, ref) {
const {
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize,
__unstableStateReducer: stateReducer = (state) => state,
__unstableInputWidth,
className,
disabled = false,
help,
hideLabelFromVision = false,
id: idProp,
isPressEnterToChange = false,
label,
labelPosition = "top",
onChange = input_control_noop,
onValidate = input_control_noop,
onKeyDown = input_control_noop,
prefix,
size = "default",
style,
suffix,
value,
...restProps
} = useDeprecated36pxDefaultSizeProp(props);
const id = input_control_useUniqueId(idProp);
const classes = dist_clsx("components-input-control", className);
const draftHookProps = useDraft({
value,
onBlur: restProps.onBlur,
onChange
});
const helpProp = !!help ? {
"aria-describedby": `${id}__help`
} : {};
maybeWarnDeprecated36pxSize({
componentName: "InputControl",
__next40pxDefaultSize,
size,
__shouldNotWarnDeprecated36pxSize
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
className: classes,
help,
id,
__nextHasNoMarginBottom: true,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(input_base_default, {
__next40pxDefaultSize,
__unstableInputWidth,
disabled,
gap: 3,
hideLabelFromVision,
id,
justify: "left",
label,
labelPosition,
prefix,
size,
style,
suffix,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(input_field_default, {
...restProps,
...helpProp,
__next40pxDefaultSize,
className: "components-input-control__input",
disabled,
id,
isPressEnterToChange,
onKeyDown,
onValidate,
paddingInlineStart: prefix ? space(1) : void 0,
paddingInlineEnd: suffix ? space(1) : void 0,
ref,
size,
stateReducer,
...draftHookProps
})
})
});
}
const InputControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedInputControl);
var input_control_default = InputControl;
;// ./node_modules/@wordpress/components/build-module/dashicon/index.js
function Dashicon({
icon,
className,
size = 20,
style = {},
...extraProps
}) {
const iconClass = ["dashicon", "dashicons", "dashicons-" + icon, className].filter(Boolean).join(" ");
const sizeStyles = (
// using `!=` to catch both 20 and "20"
// eslint-disable-next-line eqeqeq
20 != size ? {
fontSize: `${size}px`,
width: `${size}px`,
height: `${size}px`
} : {}
);
const styles = {
...sizeStyles,
...style
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: iconClass,
style: styles,
...extraProps
});
}
var dashicon_default = Dashicon;
;// ./node_modules/@wordpress/components/build-module/icon/index.js
function Icon({
icon = null,
size = "string" === typeof icon ? 20 : 24,
...additionalProps
}) {
if ("string" === typeof icon) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dashicon_default, {
icon,
size,
...additionalProps
});
}
if ((0,external_wp_element_namespaceObject.isValidElement)(icon) && dashicon_default === icon.type) {
return (0,external_wp_element_namespaceObject.cloneElement)(icon, {
...additionalProps
});
}
if ("function" === typeof icon) {
return (0,external_wp_element_namespaceObject.createElement)(icon, {
size,
...additionalProps
});
}
if (icon && (icon.type === "svg" || icon.type === external_wp_primitives_namespaceObject.SVG)) {
const appliedProps = {
...icon.props,
width: size,
height: size,
...additionalProps
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
...appliedProps
});
}
if ((0,external_wp_element_namespaceObject.isValidElement)(icon)) {
return (0,external_wp_element_namespaceObject.cloneElement)(icon, {
// @ts-ignore Just forwarding the size prop along
size,
width: size,
height: size,
...additionalProps
});
}
return icon;
}
var icon_icon_default = Icon;
;// ./node_modules/@wordpress/components/build-module/button/index.js
const disabledEventsOnDisabledButton = ["onMouseDown", "onClick"];
function button_useDeprecatedProps({
__experimentalIsFocusable,
isDefault,
isPrimary,
isSecondary,
isTertiary,
isLink,
isPressed,
isSmall,
size,
variant,
describedBy,
...otherProps
}) {
let computedSize = size;
let computedVariant = variant;
const newProps = {
accessibleWhenDisabled: __experimentalIsFocusable,
// @todo Mark `isPressed` as deprecated
"aria-pressed": isPressed,
description: describedBy
};
if (isSmall) {
var _computedSize;
(_computedSize = computedSize) !== null && _computedSize !== void 0 ? _computedSize : computedSize = "small";
}
if (isPrimary) {
var _computedVariant;
(_computedVariant = computedVariant) !== null && _computedVariant !== void 0 ? _computedVariant : computedVariant = "primary";
}
if (isTertiary) {
var _computedVariant2;
(_computedVariant2 = computedVariant) !== null && _computedVariant2 !== void 0 ? _computedVariant2 : computedVariant = "tertiary";
}
if (isSecondary) {
var _computedVariant3;
(_computedVariant3 = computedVariant) !== null && _computedVariant3 !== void 0 ? _computedVariant3 : computedVariant = "secondary";
}
if (isDefault) {
var _computedVariant4;
external_wp_deprecated_default()("wp.components.Button `isDefault` prop", {
since: "5.4",
alternative: 'variant="secondary"'
});
(_computedVariant4 = computedVariant) !== null && _computedVariant4 !== void 0 ? _computedVariant4 : computedVariant = "secondary";
}
if (isLink) {
var _computedVariant5;
(_computedVariant5 = computedVariant) !== null && _computedVariant5 !== void 0 ? _computedVariant5 : computedVariant = "link";
}
return {
...newProps,
...otherProps,
size: computedSize,
variant: computedVariant
};
}
function UnforwardedButton(props, ref) {
const {
__next40pxDefaultSize,
accessibleWhenDisabled,
isBusy,
isDestructive,
className,
disabled,
icon,
iconPosition = "left",
iconSize,
showTooltip,
tooltipPosition,
shortcut,
label,
children,
size = "default",
text,
variant,
description,
...buttonOrAnchorProps
} = button_useDeprecatedProps(props);
const {
href,
target,
"aria-checked": ariaChecked,
"aria-pressed": ariaPressed,
"aria-selected": ariaSelected,
...additionalProps
} = "href" in buttonOrAnchorProps ? buttonOrAnchorProps : {
href: void 0,
target: void 0,
...buttonOrAnchorProps
};
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(Button, "components-button__description");
const hasChildren = "string" === typeof children && !!children || Array.isArray(children) && children?.[0] && children[0] !== null && // Tooltip should not considered as a child
children?.[0]?.props?.className !== "components-tooltip";
const truthyAriaPressedValues = [true, "true", "mixed"];
const classes = dist_clsx("components-button", className, {
"is-next-40px-default-size": __next40pxDefaultSize,
"is-secondary": variant === "secondary",
"is-primary": variant === "primary",
"is-small": size === "small",
"is-compact": size === "compact",
"is-tertiary": variant === "tertiary",
"is-pressed": truthyAriaPressedValues.includes(ariaPressed),
"is-pressed-mixed": ariaPressed === "mixed",
"is-busy": isBusy,
"is-link": variant === "link",
"is-destructive": isDestructive,
"has-text": !!icon && (hasChildren || text),
"has-icon": !!icon,
"has-icon-right": iconPosition === "right"
});
const trulyDisabled = disabled && !accessibleWhenDisabled;
const Tag = href !== void 0 && !disabled ? "a" : "button";
const buttonProps = Tag === "button" ? {
type: "button",
disabled: trulyDisabled,
"aria-checked": ariaChecked,
"aria-pressed": ariaPressed,
"aria-selected": ariaSelected
} : {};
const anchorProps = Tag === "a" ? {
href,
target
} : {};
const disableEventProps = {};
if (disabled && accessibleWhenDisabled) {
buttonProps["aria-disabled"] = true;
anchorProps["aria-disabled"] = true;
for (const disabledEvent of disabledEventsOnDisabledButton) {
disableEventProps[disabledEvent] = (event) => {
if (event) {
event.stopPropagation();
event.preventDefault();
}
};
}
}
const shouldShowTooltip = !trulyDisabled && // An explicit tooltip is passed or...
(showTooltip && !!label || // There's a shortcut or...
!!shortcut || // There's a label and...
!!label && // The children are empty and...
!children?.length && // The tooltip is not explicitly disabled.
false !== showTooltip);
const descriptionId = description ? instanceId : void 0;
const describedById = additionalProps["aria-describedby"] || descriptionId;
const commonProps = {
className: classes,
"aria-label": additionalProps["aria-label"] || label,
"aria-describedby": describedById,
ref
};
const elementChildren = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [icon && iconPosition === "left" && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon,
size: iconSize
}), text && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: text
}), children, icon && iconPosition === "right" && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon,
size: iconSize
})]
});
const element = Tag === "a" ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("a", {
...anchorProps,
...additionalProps,
...disableEventProps,
...commonProps,
children: elementChildren
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("button", {
...buttonProps,
...additionalProps,
...disableEventProps,
...commonProps,
children: elementChildren
});
const tooltipProps = shouldShowTooltip ? {
text: children?.length && description ? description : label,
shortcut,
placement: tooltipPosition && // Convert legacy `position` values to be used with the new `placement` prop
positionToPlacement(tooltipPosition)
} : {};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tooltip_default, {
...tooltipProps,
children: element
}), description && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
id: descriptionId,
children: description
})
})]
});
}
const Button = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedButton);
var button_default = Button;
;// ./node_modules/@wordpress/components/build-module/number-control/styles/number-control-styles.js
function number_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
var number_control_styles_ref = true ? {
name: "euqsgg",
styles: "input[type='number']::-webkit-outer-spin-button,input[type='number']::-webkit-inner-spin-button{-webkit-appearance:none!important;margin:0!important;}input[type='number']{-moz-appearance:textfield;}"
} : 0;
const htmlArrowStyles = ({
hideHTMLArrows
}) => {
if (!hideHTMLArrows) {
return ``;
}
return number_control_styles_ref;
};
const number_control_styles_Input = /* @__PURE__ */ emotion_styled_base_browser_esm(input_control_default, true ? {
target: "ep09it41"
} : 0)(htmlArrowStyles, ";" + ( true ? "" : 0));
const SpinButton = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "ep09it40"
} : 0)("&&&&&{color:", COLORS.theme.accent, ";}" + ( true ? "" : 0));
const smallSpinButtons = /* @__PURE__ */ emotion_react_browser_esm_css("width:", space(5), ";min-width:", space(5), ";height:", space(5), ";" + ( true ? "" : 0), true ? "" : 0);
const styles = {
smallSpinButtons
};
;// ./node_modules/@wordpress/components/build-module/utils/math.js
function getNumber(value) {
const number = Number(value);
return isNaN(number) ? 0 : number;
}
function add(...args) {
return args.reduce(
/** @type {(sum:number, arg: number|string) => number} */
(sum, arg) => sum + getNumber(arg),
0
);
}
function subtract(...args) {
return args.reduce(
/** @type {(diff:number, arg: number|string, index:number) => number} */
(diff, arg, index) => {
const value = getNumber(arg);
return index === 0 ? value : diff - value;
},
0
);
}
function getPrecision(value) {
const split = (value + "").split(".");
return split[1] !== void 0 ? split[1].length : 0;
}
function math_clamp(value, min, max) {
const baseValue = getNumber(value);
return Math.max(min, Math.min(baseValue, max));
}
function ensureValidStep(value, min, step) {
const baseValue = getNumber(value);
const minValue = getNumber(min);
const stepValue = getNumber(step);
const precision = Math.max(getPrecision(step), getPrecision(min));
const tare = minValue % stepValue ? minValue : 0;
const rounded = Math.round((baseValue - tare) / stepValue) * stepValue;
const fromMin = rounded + tare;
return precision ? getNumber(fromMin.toFixed(precision)) : fromMin;
}
;// ./node_modules/@wordpress/components/build-module/h-stack/utils.js
const H_ALIGNMENTS = {
bottom: {
align: "flex-end",
justify: "center"
},
bottomLeft: {
align: "flex-end",
justify: "flex-start"
},
bottomRight: {
align: "flex-end",
justify: "flex-end"
},
center: {
align: "center",
justify: "center"
},
edge: {
align: "center",
justify: "space-between"
},
left: {
align: "center",
justify: "flex-start"
},
right: {
align: "center",
justify: "flex-end"
},
stretch: {
align: "stretch"
},
top: {
align: "flex-start",
justify: "center"
},
topLeft: {
align: "flex-start",
justify: "flex-start"
},
topRight: {
align: "flex-start",
justify: "flex-end"
}
};
const V_ALIGNMENTS = {
bottom: {
justify: "flex-end",
align: "center"
},
bottomLeft: {
justify: "flex-end",
align: "flex-start"
},
bottomRight: {
justify: "flex-end",
align: "flex-end"
},
center: {
justify: "center",
align: "center"
},
edge: {
justify: "space-between",
align: "center"
},
left: {
justify: "center",
align: "flex-start"
},
right: {
justify: "center",
align: "flex-end"
},
stretch: {
align: "stretch"
},
top: {
justify: "flex-start",
align: "center"
},
topLeft: {
justify: "flex-start",
align: "flex-start"
},
topRight: {
justify: "flex-start",
align: "flex-end"
}
};
function getAlignmentProps(alignment, direction = "row") {
if (!isValueDefined(alignment)) {
return {};
}
const isVertical = direction === "column";
const props = isVertical ? V_ALIGNMENTS : H_ALIGNMENTS;
const alignmentProps = alignment in props ? props[alignment] : {
align: alignment
};
return alignmentProps;
}
;// ./node_modules/@wordpress/components/build-module/utils/get-valid-children.js
function getValidChildren(children) {
if (typeof children === "string") {
return [children];
}
return external_wp_element_namespaceObject.Children.toArray(children).filter((child) => (0,external_wp_element_namespaceObject.isValidElement)(child));
}
;// ./node_modules/@wordpress/components/build-module/h-stack/hook.js
function useHStack(props) {
const {
alignment = "edge",
children,
direction,
spacing = 2,
...otherProps
} = useContextSystem(props, "HStack");
const align = getAlignmentProps(alignment, direction);
const validChildren = getValidChildren(children);
const clonedChildren = validChildren.map((child, index) => {
const _isSpacer = hasConnectNamespace(child, ["Spacer"]);
if (_isSpacer) {
const childElement = child;
const _key = childElement.key || `hstack-${index}`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_item_component_component_default, {
isBlock: true,
...childElement.props
}, _key);
}
return child;
});
const propsForFlex = {
children: clonedChildren,
direction,
justify: "center",
...align,
...otherProps,
gap: spacing
};
const {
isColumn,
...flexProps
} = useFlex(propsForFlex);
return flexProps;
}
;// ./node_modules/@wordpress/components/build-module/h-stack/component.js
function UnconnectedHStack(props, forwardedRef) {
const hStackProps = useHStack(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...hStackProps,
ref: forwardedRef
});
}
const HStack = contextConnect(UnconnectedHStack, "HStack");
var h_stack_component_component_default = HStack;
;// ./node_modules/@wordpress/components/build-module/number-control/index.js
const number_control_noop = () => {
};
function UnforwardedNumberControl(props, forwardedRef) {
const {
__unstableStateReducer: stateReducerProp,
className,
dragDirection = "n",
hideHTMLArrows = false,
spinControls = hideHTMLArrows ? "none" : "native",
isDragEnabled = true,
isShiftStepEnabled = true,
label,
max = Infinity,
min = -Infinity,
required = false,
shiftStep = 10,
step = 1,
spinFactor = 1,
type: typeProp = "number",
value: valueProp,
size = "default",
suffix,
onChange = number_control_noop,
__shouldNotWarnDeprecated36pxSize,
...restProps
} = useDeprecated36pxDefaultSizeProp(props);
maybeWarnDeprecated36pxSize({
componentName: "NumberControl",
size,
__next40pxDefaultSize: restProps.__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize
});
if (hideHTMLArrows) {
external_wp_deprecated_default()("wp.components.NumberControl hideHTMLArrows prop ", {
alternative: 'spinControls="none"',
since: "6.2",
version: "6.3"
});
}
const inputRef = (0,external_wp_element_namespaceObject.useRef)();
const mergedRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([inputRef, forwardedRef]);
const isStepAny = step === "any";
const baseStep = isStepAny ? 1 : ensureNumber(step);
const baseSpin = ensureNumber(spinFactor) * baseStep;
const constrainValue = (value, stepOverride) => {
if (!isStepAny) {
value = ensureValidStep(value, min, stepOverride !== null && stepOverride !== void 0 ? stepOverride : baseStep);
}
return `${math_clamp(value, min, max)}`;
};
const baseValue = constrainValue(0);
const autoComplete = typeProp === "number" ? "off" : void 0;
const classes = dist_clsx("components-number-control", className);
const cx = useCx();
const spinButtonClasses = cx(size === "small" && styles.smallSpinButtons);
const spinValue = (value, direction, event) => {
event?.preventDefault();
const shift = event?.shiftKey && isShiftStepEnabled;
const delta = shift ? ensureNumber(shiftStep) * baseSpin : baseSpin;
let nextValue = isValueEmpty(value) ? baseValue : value;
if (direction === "up") {
nextValue = add(nextValue, delta);
} else if (direction === "down") {
nextValue = subtract(nextValue, delta);
}
return constrainValue(nextValue, shift ? delta : void 0);
};
const numberControlStateReducer = (state, action) => {
const nextState = {
...state
};
const {
type,
payload
} = action;
const event = payload.event;
const currentValue = nextState.value;
if (type === PRESS_UP || type === PRESS_DOWN) {
nextState.value = spinValue(currentValue, type === PRESS_UP ? "up" : "down", event);
}
if (type === DRAG && isDragEnabled) {
const [x, y] = payload.delta;
const enableShift = payload.shiftKey && isShiftStepEnabled;
const modifier = enableShift ? ensureNumber(shiftStep) * baseSpin : baseSpin;
let directionModifier;
let delta;
switch (dragDirection) {
case "n":
delta = y;
directionModifier = -1;
break;
case "e":
delta = x;
directionModifier = (0,external_wp_i18n_namespaceObject.isRTL)() ? -1 : 1;
break;
case "s":
delta = y;
directionModifier = 1;
break;
case "w":
delta = x;
directionModifier = (0,external_wp_i18n_namespaceObject.isRTL)() ? 1 : -1;
break;
}
if (delta !== 0) {
delta = Math.ceil(Math.abs(delta)) * Math.sign(delta);
const distance = delta * modifier * directionModifier;
nextState.value = constrainValue(
// @ts-expect-error TODO: Investigate if it's ok for currentValue to be undefined
add(currentValue, distance),
enableShift ? modifier : void 0
);
}
}
if (type === PRESS_ENTER || type === COMMIT) {
const applyEmptyValue = required === false && currentValue === "";
nextState.value = applyEmptyValue ? currentValue : (
// @ts-expect-error TODO: Investigate if it's ok for currentValue to be undefined
constrainValue(currentValue)
);
}
return nextState;
};
const buildSpinButtonClickHandler = (direction) => (event) => onChange(String(spinValue(valueProp, direction, event)), {
// Set event.target to the <input> so that consumers can use
// e.g. event.target.validity.
event: {
...event,
target: inputRef.current
}
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(number_control_styles_Input, {
autoComplete,
inputMode: "numeric",
...restProps,
className: classes,
dragDirection,
hideHTMLArrows: spinControls !== "native",
isDragEnabled,
label,
max: max === Infinity ? void 0 : max,
min: min === -Infinity ? void 0 : min,
ref: mergedRef,
required,
step,
type: typeProp,
value: valueProp,
__unstableStateReducer: (state, action) => {
var _stateReducerProp;
const baseState = numberControlStateReducer(state, action);
return (_stateReducerProp = stateReducerProp?.(baseState, action)) !== null && _stateReducerProp !== void 0 ? _stateReducerProp : baseState;
},
size,
__shouldNotWarnDeprecated36pxSize: true,
suffix: spinControls === "custom" ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [suffix, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
marginBottom: 0,
marginRight: 2,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
spacing: 1,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SpinButton, {
className: spinButtonClasses,
icon: plus_default,
size: "small",
label: (0,external_wp_i18n_namespaceObject.__)("Increment"),
onClick: buildSpinButtonClickHandler("up")
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SpinButton, {
className: spinButtonClasses,
icon: reset_default,
size: "small",
label: (0,external_wp_i18n_namespaceObject.__)("Decrement"),
onClick: buildSpinButtonClickHandler("down")
})]
})
})]
}) : suffix,
onChange
});
}
const NumberControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedNumberControl);
var number_control_default = NumberControl;
;// ./node_modules/@wordpress/components/build-module/angle-picker-control/styles/angle-picker-control-styles.js
function angle_picker_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const CIRCLE_SIZE = 32;
const INNER_CIRCLE_SIZE = 6;
const CircleRoot = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eln3bjz3"
} : 0)("border-radius:", config_values_default.radiusRound, ";border:", config_values_default.borderWidth, " solid ", COLORS.ui.border, ";box-sizing:border-box;cursor:grab;height:", CIRCLE_SIZE, "px;overflow:hidden;width:", CIRCLE_SIZE, "px;:active{cursor:grabbing;}" + ( true ? "" : 0));
const CircleIndicatorWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eln3bjz2"
} : 0)( true ? {
name: "1r307gh",
styles: "box-sizing:border-box;position:relative;width:100%;height:100%;:focus-visible{outline:none;}"
} : 0);
const CircleIndicator = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eln3bjz1"
} : 0)("background:", COLORS.theme.accent, ";border-radius:", config_values_default.radiusRound, ";box-sizing:border-box;display:block;left:50%;top:4px;transform:translateX( -50% );position:absolute;width:", INNER_CIRCLE_SIZE, "px;height:", INNER_CIRCLE_SIZE, "px;" + ( true ? "" : 0));
const UnitText = /* @__PURE__ */ emotion_styled_base_browser_esm(text_component_component_default, true ? {
target: "eln3bjz0"
} : 0)("color:", COLORS.theme.accent, ";margin-right:", space(3), ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/angle-picker-control/angle-circle.js
function AngleCircle({
value,
onChange,
...props
}) {
const angleCircleRef = (0,external_wp_element_namespaceObject.useRef)(null);
const angleCircleCenterRef = (0,external_wp_element_namespaceObject.useRef)();
const previousCursorValueRef = (0,external_wp_element_namespaceObject.useRef)();
const setAngleCircleCenter = () => {
if (angleCircleRef.current === null) {
return;
}
const rect = angleCircleRef.current.getBoundingClientRect();
angleCircleCenterRef.current = {
x: rect.x + rect.width / 2,
y: rect.y + rect.height / 2
};
};
const changeAngleToPosition = (event) => {
if (event === void 0) {
return;
}
event.preventDefault();
event.target?.focus();
if (angleCircleCenterRef.current !== void 0 && onChange !== void 0) {
const {
x: centerX,
y: centerY
} = angleCircleCenterRef.current;
onChange(getAngle(centerX, centerY, event.clientX, event.clientY));
}
};
const {
startDrag,
isDragging
} = (0,external_wp_compose_namespaceObject.__experimentalUseDragging)({
onDragStart: (event) => {
setAngleCircleCenter();
changeAngleToPosition(event);
},
onDragMove: changeAngleToPosition,
onDragEnd: changeAngleToPosition
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (isDragging) {
if (previousCursorValueRef.current === void 0) {
previousCursorValueRef.current = document.body.style.cursor;
}
document.body.style.cursor = "grabbing";
} else {
document.body.style.cursor = previousCursorValueRef.current || "";
previousCursorValueRef.current = void 0;
}
}, [isDragging]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CircleRoot, {
ref: angleCircleRef,
onMouseDown: startDrag,
className: "components-angle-picker-control__angle-circle",
...props,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CircleIndicatorWrapper, {
style: value ? {
transform: `rotate(${value}deg)`
} : void 0,
className: "components-angle-picker-control__angle-circle-indicator-wrapper",
tabIndex: -1,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CircleIndicator, {
className: "components-angle-picker-control__angle-circle-indicator"
})
})
});
}
function getAngle(centerX, centerY, pointX, pointY) {
const y = pointY - centerY;
const x = pointX - centerX;
const angleInRadians = Math.atan2(y, x);
const angleInDeg = Math.round(angleInRadians * (180 / Math.PI)) + 90;
if (angleInDeg < 0) {
return 360 + angleInDeg;
}
return angleInDeg;
}
var angle_circle_default = AngleCircle;
;// ./node_modules/@wordpress/components/build-module/angle-picker-control/index.js
function UnforwardedAnglePickerControl(props, ref) {
const {
className,
label = (0,external_wp_i18n_namespaceObject.__)("Angle"),
onChange,
value,
...restProps
} = props;
const handleOnNumberChange = (unprocessedValue) => {
if (onChange === void 0) {
return;
}
const inputValue = unprocessedValue !== void 0 && unprocessedValue !== "" ? parseInt(unprocessedValue, 10) : 0;
onChange(inputValue);
};
const classes = dist_clsx("components-angle-picker-control", className);
const unitText = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(UnitText, {
children: "\xB0"
});
const [prefixedUnitText, suffixedUnitText] = (0,external_wp_i18n_namespaceObject.isRTL)() ? [unitText, null] : [null, unitText];
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(flex_component_component_default, {
...restProps,
ref,
className: classes,
gap: 2,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_block_component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(number_control_default, {
__next40pxDefaultSize: true,
label,
className: "components-angle-picker-control__input-field",
max: 360,
min: 0,
onChange: handleOnNumberChange,
step: "1",
value,
spinControls: "none",
prefix: prefixedUnitText,
suffix: suffixedUnitText
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
marginBottom: "1",
marginTop: "auto",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(angle_circle_default, {
"aria-hidden": "true",
value,
onChange
})
})]
});
}
const AnglePickerControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedAnglePickerControl);
var angle_picker_control_default = AnglePickerControl;
// EXTERNAL MODULE: ./node_modules/remove-accents/index.js
var remove_accents = __webpack_require__(9681);
var remove_accents_default = /*#__PURE__*/__webpack_require__.n(remove_accents);
;// external ["wp","richText"]
const external_wp_richText_namespaceObject = window["wp"]["richText"];
;// external ["wp","a11y"]
const external_wp_a11y_namespaceObject = window["wp"]["a11y"];
;// external ["wp","keycodes"]
const external_wp_keycodes_namespaceObject = window["wp"]["keycodes"];
;// ./node_modules/@wordpress/components/build-module/utils/strings.js
const ALL_UNICODE_DASH_CHARACTERS = new RegExp(/[\u007e\u00ad\u2053\u207b\u208b\u2212\p{Pd}]/gu);
const normalizeTextString = (value) => {
return remove_accents_default()(value).normalize("NFKC").toLocaleLowerCase().replace(ALL_UNICODE_DASH_CHARACTERS, "-");
};
function kebabCase(str) {
var _str$toString;
let input = (_str$toString = str?.toString?.()) !== null && _str$toString !== void 0 ? _str$toString : "";
input = input.replace(/['\u2019]/, "");
return paramCase(input, {
splitRegexp: [
/(?!(?:1ST|2ND|3RD|[4-9]TH)(?![a-z]))([a-z0-9])([A-Z])/g,
// fooBar => foo-bar, 3Bar => 3-bar
/(?!(?:1st|2nd|3rd|[4-9]th)(?![a-z]))([0-9])([a-z])/g,
// 3bar => 3-bar
/([A-Za-z])([0-9])/g,
// Foo3 => foo-3, foo3 => foo-3
/([A-Z])([A-Z][a-z])/g
// FOOBar => foo-bar
]
});
}
function escapeRegExp(string) {
return string.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
}
;// ./node_modules/@wordpress/components/build-module/autocomplete/get-default-use-items.js
function filterOptions(search, options = [], maxResults = 10) {
const filtered = [];
for (let i = 0; i < options.length; i++) {
const option = options[i];
let {
keywords = []
} = option;
if ("string" === typeof option.label) {
keywords = [...keywords, option.label];
}
const isMatch = keywords.some((keyword) => search.test(remove_accents_default()(keyword)));
if (!isMatch) {
continue;
}
filtered.push(option);
if (filtered.length === maxResults) {
break;
}
}
return filtered;
}
function getDefaultUseItems(autocompleter) {
return (filterValue) => {
const [items, setItems] = (0,external_wp_element_namespaceObject.useState)([]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
const {
options,
isDebounced
} = autocompleter;
const loadOptions = (0,external_wp_compose_namespaceObject.debounce)(() => {
const promise2 = Promise.resolve(typeof options === "function" ? options(filterValue) : options).then((optionsData) => {
if (promise2.canceled) {
return;
}
const keyedOptions = optionsData.map((optionData, optionIndex) => ({
key: `${autocompleter.name}-${optionIndex}`,
value: optionData,
label: autocompleter.getOptionLabel(optionData),
keywords: autocompleter.getOptionKeywords ? autocompleter.getOptionKeywords(optionData) : [],
isDisabled: autocompleter.isOptionDisabled ? autocompleter.isOptionDisabled(optionData) : false
}));
const search = new RegExp("(?:\\b|\\s|^)" + escapeRegExp(filterValue), "i");
setItems(filterOptions(search, keyedOptions));
});
return promise2;
}, isDebounced ? 250 : 0);
const promise = loadOptions();
return () => {
loadOptions.cancel();
if (promise) {
promise.canceled = true;
}
};
}, [filterValue]);
return [items];
};
}
;// ./node_modules/@floating-ui/react-dom/dist/floating-ui.react-dom.mjs
/**
* Provides data to position an inner element of the floating element so that it
* appears centered to the reference element.
* This wraps the core `arrow` middleware to allow React refs as the element.
* @see https://floating-ui.com/docs/arrow
*/
const floating_ui_react_dom_arrow = options => {
function isRef(value) {
return {}.hasOwnProperty.call(value, 'current');
}
return {
name: 'arrow',
options,
fn(state) {
const {
element,
padding
} = typeof options === 'function' ? options(state) : options;
if (element && isRef(element)) {
if (element.current != null) {
return floating_ui_dom_arrow({
element: element.current,
padding
}).fn(state);
}
return {};
}
if (element) {
return floating_ui_dom_arrow({
element,
padding
}).fn(state);
}
return {};
}
};
};
var index = typeof document !== 'undefined' ? external_React_.useLayoutEffect : external_React_.useEffect;
// Fork of `fast-deep-equal` that only does the comparisons we need and compares
// functions
function deepEqual(a, b) {
if (a === b) {
return true;
}
if (typeof a !== typeof b) {
return false;
}
if (typeof a === 'function' && a.toString() === b.toString()) {
return true;
}
let length;
let i;
let keys;
if (a && b && typeof a === 'object') {
if (Array.isArray(a)) {
length = a.length;
if (length !== b.length) return false;
for (i = length; i-- !== 0;) {
if (!deepEqual(a[i], b[i])) {
return false;
}
}
return true;
}
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length) {
return false;
}
for (i = length; i-- !== 0;) {
if (!{}.hasOwnProperty.call(b, keys[i])) {
return false;
}
}
for (i = length; i-- !== 0;) {
const key = keys[i];
if (key === '_owner' && a.$$typeof) {
continue;
}
if (!deepEqual(a[key], b[key])) {
return false;
}
}
return true;
}
// biome-ignore lint/suspicious/noSelfCompare: in source
return a !== a && b !== b;
}
function getDPR(element) {
if (typeof window === 'undefined') {
return 1;
}
const win = element.ownerDocument.defaultView || window;
return win.devicePixelRatio || 1;
}
function floating_ui_react_dom_roundByDPR(element, value) {
const dpr = getDPR(element);
return Math.round(value * dpr) / dpr;
}
function useLatestRef(value) {
const ref = external_React_.useRef(value);
index(() => {
ref.current = value;
});
return ref;
}
/**
* Provides data to position a floating element.
* @see https://floating-ui.com/docs/useFloating
*/
function useFloating(options) {
if (options === void 0) {
options = {};
}
const {
placement = 'bottom',
strategy = 'absolute',
middleware = [],
platform,
elements: {
reference: externalReference,
floating: externalFloating
} = {},
transform = true,
whileElementsMounted,
open
} = options;
const [data, setData] = external_React_.useState({
x: 0,
y: 0,
strategy,
placement,
middlewareData: {},
isPositioned: false
});
const [latestMiddleware, setLatestMiddleware] = external_React_.useState(middleware);
if (!deepEqual(latestMiddleware, middleware)) {
setLatestMiddleware(middleware);
}
const [_reference, _setReference] = external_React_.useState(null);
const [_floating, _setFloating] = external_React_.useState(null);
const setReference = external_React_.useCallback(node => {
if (node !== referenceRef.current) {
referenceRef.current = node;
_setReference(node);
}
}, []);
const setFloating = external_React_.useCallback(node => {
if (node !== floatingRef.current) {
floatingRef.current = node;
_setFloating(node);
}
}, []);
const referenceEl = externalReference || _reference;
const floatingEl = externalFloating || _floating;
const referenceRef = external_React_.useRef(null);
const floatingRef = external_React_.useRef(null);
const dataRef = external_React_.useRef(data);
const hasWhileElementsMounted = whileElementsMounted != null;
const whileElementsMountedRef = useLatestRef(whileElementsMounted);
const platformRef = useLatestRef(platform);
const update = external_React_.useCallback(() => {
if (!referenceRef.current || !floatingRef.current) {
return;
}
const config = {
placement,
strategy,
middleware: latestMiddleware
};
if (platformRef.current) {
config.platform = platformRef.current;
}
floating_ui_dom_computePosition(referenceRef.current, floatingRef.current, config).then(data => {
const fullData = {
...data,
isPositioned: true
};
if (isMountedRef.current && !deepEqual(dataRef.current, fullData)) {
dataRef.current = fullData;
external_ReactDOM_namespaceObject.flushSync(() => {
setData(fullData);
});
}
});
}, [latestMiddleware, placement, strategy, platformRef]);
index(() => {
if (open === false && dataRef.current.isPositioned) {
dataRef.current.isPositioned = false;
setData(data => ({
...data,
isPositioned: false
}));
}
}, [open]);
const isMountedRef = external_React_.useRef(false);
index(() => {
isMountedRef.current = true;
return () => {
isMountedRef.current = false;
};
}, []);
// biome-ignore lint/correctness/useExhaustiveDependencies: `hasWhileElementsMounted` is intentionally included.
index(() => {
if (referenceEl) referenceRef.current = referenceEl;
if (floatingEl) floatingRef.current = floatingEl;
if (referenceEl && floatingEl) {
if (whileElementsMountedRef.current) {
return whileElementsMountedRef.current(referenceEl, floatingEl, update);
}
update();
}
}, [referenceEl, floatingEl, update, whileElementsMountedRef, hasWhileElementsMounted]);
const refs = external_React_.useMemo(() => ({
reference: referenceRef,
floating: floatingRef,
setReference,
setFloating
}), [setReference, setFloating]);
const elements = external_React_.useMemo(() => ({
reference: referenceEl,
floating: floatingEl
}), [referenceEl, floatingEl]);
const floatingStyles = external_React_.useMemo(() => {
const initialStyles = {
position: strategy,
left: 0,
top: 0
};
if (!elements.floating) {
return initialStyles;
}
const x = floating_ui_react_dom_roundByDPR(elements.floating, data.x);
const y = floating_ui_react_dom_roundByDPR(elements.floating, data.y);
if (transform) {
return {
...initialStyles,
transform: "translate(" + x + "px, " + y + "px)",
...(getDPR(elements.floating) >= 1.5 && {
willChange: 'transform'
})
};
}
return {
position: strategy,
left: x,
top: y
};
}, [strategy, transform, elements.floating, data.x, data.y]);
return external_React_.useMemo(() => ({
...data,
update,
refs,
elements,
floatingStyles
}), [data, update, refs, elements, floatingStyles]);
}
;// ./node_modules/@wordpress/icons/build-module/library/close.js
var close_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "m13.06 12 6.47-6.47-1.06-1.06L12 10.94 5.53 4.47 4.47 5.53 10.94 12l-6.47 6.47 1.06 1.06L12 13.06l6.47 6.47 1.06-1.06L13.06 12Z" }) });
;// ./node_modules/@wordpress/components/build-module/scroll-lock/index.js
let previousScrollTop = 0;
function setLocked(locked) {
const scrollingElement = document.scrollingElement || document.body;
if (locked) {
previousScrollTop = scrollingElement.scrollTop;
}
const methodName = locked ? "add" : "remove";
scrollingElement.classList[methodName]("lockscroll");
document.documentElement.classList[methodName]("lockscroll");
if (!locked) {
scrollingElement.scrollTop = previousScrollTop;
}
}
let lockCounter = 0;
function ScrollLock() {
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (lockCounter === 0) {
setLocked(true);
}
++lockCounter;
return () => {
if (lockCounter === 1) {
setLocked(false);
}
--lockCounter;
};
}, []);
return null;
}
var scroll_lock_default = ScrollLock;
;// ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/slot-fill-context.js
const initialContextValue = {
slots: (0,external_wp_compose_namespaceObject.observableMap)(),
fills: (0,external_wp_compose_namespaceObject.observableMap)(),
registerSlot: () => {
true ? external_wp_warning_default()("Components must be wrapped within `SlotFillProvider`. See https://developer.wordpress.org/block-editor/components/slot-fill/") : 0;
},
updateSlot: () => {
},
unregisterSlot: () => {
},
registerFill: () => {
},
unregisterFill: () => {
},
// This helps the provider know if it's using the default context value or not.
isDefault: true
};
const SlotFillContext = (0,external_wp_element_namespaceObject.createContext)(initialContextValue);
SlotFillContext.displayName = "SlotFillContext";
var slot_fill_context_default = SlotFillContext;
;// ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/use-slot.js
function useSlot(name) {
const registry = (0,external_wp_element_namespaceObject.useContext)(slot_fill_context_default);
const slot = (0,external_wp_compose_namespaceObject.useObservableValue)(registry.slots, name);
return {
...slot
};
}
;// ./node_modules/@wordpress/components/build-module/slot-fill/context.js
const initialValue = {
slots: (0,external_wp_compose_namespaceObject.observableMap)(),
fills: (0,external_wp_compose_namespaceObject.observableMap)(),
registerSlot: () => {
},
unregisterSlot: () => {
},
registerFill: () => {
},
unregisterFill: () => {
},
updateFill: () => {
}
};
const context_SlotFillContext = (0,external_wp_element_namespaceObject.createContext)(initialValue);
context_SlotFillContext.displayName = "SlotFillContext";
var context_default = context_SlotFillContext;
;// ./node_modules/@wordpress/components/build-module/slot-fill/fill.js
function Fill({
name,
children
}) {
const registry = (0,external_wp_element_namespaceObject.useContext)(context_default);
const instanceRef = (0,external_wp_element_namespaceObject.useRef)({});
const childrenRef = (0,external_wp_element_namespaceObject.useRef)(children);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
childrenRef.current = children;
}, [children]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
const instance = instanceRef.current;
registry.registerFill(name, instance, childrenRef.current);
return () => registry.unregisterFill(name, instance);
}, [registry, name]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
registry.updateFill(name, instanceRef.current, childrenRef.current);
});
return null;
}
;// ./node_modules/@wordpress/components/build-module/slot-fill/slot.js
function isFunction(maybeFunc) {
return typeof maybeFunc === "function";
}
function addKeysToChildren(children) {
return external_wp_element_namespaceObject.Children.map(children, (child, childIndex) => {
if (!child || typeof child === "string") {
return child;
}
let childKey = childIndex;
if (typeof child === "object" && "key" in child && child?.key) {
childKey = child.key;
}
return (0,external_wp_element_namespaceObject.cloneElement)(child, {
key: childKey
});
});
}
function Slot(props) {
var _useObservableValue;
const registry = (0,external_wp_element_namespaceObject.useContext)(context_default);
const instanceRef = (0,external_wp_element_namespaceObject.useRef)({});
const {
name,
children,
fillProps = {}
} = props;
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
const instance = instanceRef.current;
registry.registerSlot(name, instance);
return () => registry.unregisterSlot(name, instance);
}, [registry, name]);
let fills = (_useObservableValue = (0,external_wp_compose_namespaceObject.useObservableValue)(registry.fills, name)) !== null && _useObservableValue !== void 0 ? _useObservableValue : [];
const currentSlot = (0,external_wp_compose_namespaceObject.useObservableValue)(registry.slots, name);
if (currentSlot !== instanceRef.current) {
fills = [];
}
const renderedFills = fills.map((fill) => {
const fillChildren = isFunction(fill.children) ? fill.children(fillProps) : fill.children;
return addKeysToChildren(fillChildren);
}).filter(
// In some cases fills are rendered only when some conditions apply.
// This ensures that we only use non-empty fills when rendering, i.e.,
// it allows us to render wrappers only when the fills are actually present.
(element) => !(0,external_wp_element_namespaceObject.isEmptyElement)(element)
);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: isFunction(children) ? children(renderedFills) : renderedFills
});
}
var slot_default = Slot;
;// ./node_modules/@wordpress/components/node_modules/uuid/dist/esm-browser/native.js
const randomUUID = typeof crypto !== 'undefined' && crypto.randomUUID && crypto.randomUUID.bind(crypto);
/* harmony default export */ const esm_browser_native = ({
randomUUID
});
;// ./node_modules/@wordpress/components/node_modules/uuid/dist/esm-browser/rng.js
// Unique ID creation requires a high quality random # generator. In the browser we therefore
// require the crypto API and do not support built-in fallback to lower quality random number
// generators (like Math.random()).
let getRandomValues;
const rnds8 = new Uint8Array(16);
function rng() {
// lazy load so that environments that need to polyfill have a chance to do so
if (!getRandomValues) {
// getRandomValues needs to be invoked in a context where "this" is a Crypto implementation.
getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
if (!getRandomValues) {
throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
}
}
return getRandomValues(rnds8);
}
;// ./node_modules/@wordpress/components/node_modules/uuid/dist/esm-browser/stringify.js
/**
* Convert array of 16 byte values to UUID string format of the form:
* XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
*/
const byteToHex = [];
for (let i = 0; i < 256; ++i) {
byteToHex.push((i + 0x100).toString(16).slice(1));
}
function unsafeStringify(arr, offset = 0) {
// Note: Be careful editing this code! It's been tuned for performance
// and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
}
function stringify_stringify(arr, offset = 0) {
const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID. If this throws, it's likely due to one
// of the following:
// - One or more input array values don't map to a hex octet (leading to
// "undefined" in the uuid)
// - Invalid input values for the RFC `version` or `variant` fields
if (!validate(uuid)) {
throw TypeError('Stringified UUID is invalid');
}
return uuid;
}
/* harmony default export */ const esm_browser_stringify = ((/* unused pure expression or super */ null && (stringify_stringify)));
;// ./node_modules/@wordpress/components/node_modules/uuid/dist/esm-browser/v4.js
function v4(options, buf, offset) {
if (esm_browser_native.randomUUID && !buf && !options) {
return esm_browser_native.randomUUID();
}
options = options || {};
const rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
rnds[6] = rnds[6] & 0x0f | 0x40;
rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
if (buf) {
offset = offset || 0;
for (let i = 0; i < 16; ++i) {
buf[offset + i] = rnds[i];
}
return buf;
}
return unsafeStringify(rnds);
}
/* harmony default export */ const esm_browser_v4 = (v4);
;// ./node_modules/@wordpress/components/build-module/style-provider/index.js
const uuidCache = /* @__PURE__ */ new Set();
const containerCacheMap = /* @__PURE__ */ new WeakMap();
const memoizedCreateCacheWithContainer = (container) => {
if (containerCacheMap.has(container)) {
return containerCacheMap.get(container);
}
let key = esm_browser_v4().replace(/[0-9]/g, "");
while (uuidCache.has(key)) {
key = esm_browser_v4().replace(/[0-9]/g, "");
}
uuidCache.add(key);
const cache = emotion_cache_browser_esm({
container,
key
});
containerCacheMap.set(container, cache);
return cache;
};
function StyleProvider(props) {
const {
children,
document
} = props;
if (!document) {
return null;
}
const cache = memoizedCreateCacheWithContainer(document.head);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CacheProvider, {
value: cache,
children
});
}
var style_provider_default = StyleProvider;
;// ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/fill.js
function fill_Fill({
name,
children
}) {
var _slot$fillProps;
const registry = (0,external_wp_element_namespaceObject.useContext)(slot_fill_context_default);
const slot = (0,external_wp_compose_namespaceObject.useObservableValue)(registry.slots, name);
const instanceRef = (0,external_wp_element_namespaceObject.useRef)({});
(0,external_wp_element_namespaceObject.useEffect)(() => {
const instance = instanceRef.current;
registry.registerFill(name, instance);
return () => registry.unregisterFill(name, instance);
}, [registry, name]);
if (!slot || !slot.ref.current) {
return null;
}
const wrappedChildren = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(style_provider_default, {
document: slot.ref.current.ownerDocument,
children: typeof children === "function" ? children((_slot$fillProps = slot.fillProps) !== null && _slot$fillProps !== void 0 ? _slot$fillProps : {}) : children
});
return (0,external_wp_element_namespaceObject.createPortal)(wrappedChildren, slot.ref.current);
}
;// ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/slot.js
function slot_Slot(props, forwardedRef) {
const {
name,
fillProps = {},
as,
// `children` is not allowed. However, if it is passed,
// it will be displayed as is, so remove `children`.
children,
...restProps
} = props;
const registry = (0,external_wp_element_namespaceObject.useContext)(slot_fill_context_default);
const ref = (0,external_wp_element_namespaceObject.useRef)(null);
const fillPropsRef = (0,external_wp_element_namespaceObject.useRef)(fillProps);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
fillPropsRef.current = fillProps;
}, [fillProps]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
registry.registerSlot(name, ref, fillPropsRef.current);
return () => registry.unregisterSlot(name, ref);
}, [registry, name]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
registry.updateSlot(name, ref, fillPropsRef.current);
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
as,
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, ref]),
...restProps
});
}
var slot_slot_default = (0,external_wp_element_namespaceObject.forwardRef)(slot_Slot);
;// external ["wp","isShallowEqual"]
const external_wp_isShallowEqual_namespaceObject = window["wp"]["isShallowEqual"];
var external_wp_isShallowEqual_default = /*#__PURE__*/__webpack_require__.n(external_wp_isShallowEqual_namespaceObject);
;// ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/slot-fill-provider.js
function createSlotRegistry() {
const slots = (0,external_wp_compose_namespaceObject.observableMap)();
const fills = (0,external_wp_compose_namespaceObject.observableMap)();
const registerSlot = (name, ref, fillProps) => {
slots.set(name, {
ref,
fillProps
});
};
const unregisterSlot = (name, ref) => {
const slot = slots.get(name);
if (!slot) {
return;
}
if (slot.ref !== ref) {
return;
}
slots.delete(name);
};
const updateSlot = (name, ref, fillProps) => {
const slot = slots.get(name);
if (!slot) {
return;
}
if (slot.ref !== ref) {
return;
}
if (external_wp_isShallowEqual_default()(slot.fillProps, fillProps)) {
return;
}
slots.set(name, {
ref,
fillProps
});
};
const registerFill = (name, ref) => {
fills.set(name, [...fills.get(name) || [], ref]);
};
const unregisterFill = (name, ref) => {
const fillsForName = fills.get(name);
if (!fillsForName) {
return;
}
fills.set(name, fillsForName.filter((fillRef) => fillRef !== ref));
};
return {
slots,
fills,
registerSlot,
updateSlot,
unregisterSlot,
registerFill,
unregisterFill
};
}
function SlotFillProvider({
children
}) {
const [registry] = (0,external_wp_element_namespaceObject.useState)(createSlotRegistry);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(slot_fill_context_default.Provider, {
value: registry,
children
});
}
;// ./node_modules/@wordpress/components/build-module/slot-fill/provider.js
function provider_createSlotRegistry() {
const slots = (0,external_wp_compose_namespaceObject.observableMap)();
const fills = (0,external_wp_compose_namespaceObject.observableMap)();
function registerSlot(name, instance) {
slots.set(name, instance);
}
function unregisterSlot(name, instance) {
if (slots.get(name) !== instance) {
return;
}
slots.delete(name);
}
function registerFill(name, instance, children) {
fills.set(name, [...fills.get(name) || [], {
instance,
children
}]);
}
function unregisterFill(name, instance) {
const fillsForName = fills.get(name);
if (!fillsForName) {
return;
}
fills.set(name, fillsForName.filter((fill) => fill.instance !== instance));
}
function updateFill(name, instance, children) {
const fillsForName = fills.get(name);
if (!fillsForName) {
return;
}
const fillForInstance = fillsForName.find((f) => f.instance === instance);
if (!fillForInstance) {
return;
}
if (fillForInstance.children === children) {
return;
}
fills.set(name, fillsForName.map((f) => {
if (f.instance === instance) {
return {
instance,
children
};
}
return f;
}));
}
return {
slots,
fills,
registerSlot,
unregisterSlot,
registerFill,
unregisterFill,
updateFill
};
}
function provider_SlotFillProvider({
children
}) {
const [contextValue] = (0,external_wp_element_namespaceObject.useState)(provider_createSlotRegistry);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(context_default.Provider, {
value: contextValue,
children
});
}
var provider_default = provider_SlotFillProvider;
;// ./node_modules/@wordpress/components/build-module/slot-fill/index.js
function slot_fill_Fill(props) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Fill, {
...props
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(fill_Fill, {
...props
})]
});
}
function UnforwardedSlot(props, ref) {
const {
bubblesVirtually,
...restProps
} = props;
if (bubblesVirtually) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(slot_slot_default, {
...restProps,
ref
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(slot_default, {
...restProps
});
}
const slot_fill_Slot = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedSlot);
function Provider({
children,
passthrough = false
}) {
const parent = (0,external_wp_element_namespaceObject.useContext)(slot_fill_context_default);
if (!parent.isDefault && passthrough) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(provider_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SlotFillProvider, {
children
})
});
}
Provider.displayName = "SlotFillProvider";
function createSlotFill(key) {
const baseName = typeof key === "symbol" ? key.description : key;
const FillComponent = (props) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(slot_fill_Fill, {
name: key,
...props
});
FillComponent.displayName = `${baseName}Fill`;
const SlotComponent = (props) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(slot_fill_Slot, {
name: key,
...props
});
SlotComponent.displayName = `${baseName}Slot`;
SlotComponent.__unstableName = key;
return {
name: key,
Fill: FillComponent,
Slot: SlotComponent
};
}
;// ./node_modules/@wordpress/components/build-module/popover/overlay-middlewares.js
function overlayMiddlewares() {
return [{
name: "overlay",
fn({
rects
}) {
return rects.reference;
}
}, floating_ui_dom_size({
apply({
rects,
elements
}) {
var _elements$floating;
const {
firstElementChild
} = (_elements$floating = elements.floating) !== null && _elements$floating !== void 0 ? _elements$floating : {};
if (!(firstElementChild instanceof HTMLElement)) {
return;
}
Object.assign(firstElementChild.style, {
width: `${rects.reference.width}px`,
height: `${rects.reference.height}px`
});
}
})];
}
;// ./node_modules/@wordpress/components/build-module/popover/index.js
const SLOT_NAME = "Popover";
const OVERFLOW_PADDING = 8;
const ArrowTriangle = () => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 100 100",
className: "components-popover__triangle",
role: "presentation",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
className: "components-popover__triangle-bg",
d: "M 0 0 L 50 50 L 100 0"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
className: "components-popover__triangle-border",
d: "M 0 0 L 50 50 L 100 0",
vectorEffect: "non-scaling-stroke"
})]
});
const slotNameContext = (0,external_wp_element_namespaceObject.createContext)(void 0);
slotNameContext.displayName = "__unstableSlotNameContext";
const fallbackContainerClassname = "components-popover__fallback-container";
const getPopoverFallbackContainer = () => {
let container = document.body.querySelector("." + fallbackContainerClassname);
if (!container) {
container = document.createElement("div");
container.className = fallbackContainerClassname;
document.body.append(container);
}
return container;
};
const UnforwardedPopover = (props, forwardedRef) => {
const {
animate = true,
headerTitle,
constrainTabbing,
onClose,
children,
className,
noArrow = true,
position,
placement: placementProp = "bottom-start",
offset: offsetProp = 0,
focusOnMount = "firstElement",
anchor,
expandOnMobile,
onFocusOutside,
__unstableSlotName = SLOT_NAME,
flip = true,
resize = true,
shift = false,
inline = false,
variant,
style: contentStyle,
// Deprecated props
__unstableForcePosition,
anchorRef,
anchorRect,
getAnchorRect,
isAlternate,
// Rest
...contentProps
} = useContextSystem(props, "Popover");
let computedFlipProp = flip;
let computedResizeProp = resize;
if (__unstableForcePosition !== void 0) {
external_wp_deprecated_default()("`__unstableForcePosition` prop in wp.components.Popover", {
since: "6.1",
version: "6.3",
alternative: "`flip={ false }` and `resize={ false }`"
});
computedFlipProp = !__unstableForcePosition;
computedResizeProp = !__unstableForcePosition;
}
if (anchorRef !== void 0) {
external_wp_deprecated_default()("`anchorRef` prop in wp.components.Popover", {
since: "6.1",
alternative: "`anchor` prop"
});
}
if (anchorRect !== void 0) {
external_wp_deprecated_default()("`anchorRect` prop in wp.components.Popover", {
since: "6.1",
alternative: "`anchor` prop"
});
}
if (getAnchorRect !== void 0) {
external_wp_deprecated_default()("`getAnchorRect` prop in wp.components.Popover", {
since: "6.1",
alternative: "`anchor` prop"
});
}
const computedVariant = isAlternate ? "toolbar" : variant;
if (isAlternate !== void 0) {
external_wp_deprecated_default()("`isAlternate` prop in wp.components.Popover", {
since: "6.2",
alternative: "`variant` prop with the `'toolbar'` value"
});
}
const arrowRef = (0,external_wp_element_namespaceObject.useRef)(null);
const [fallbackReferenceElement, setFallbackReferenceElement] = (0,external_wp_element_namespaceObject.useState)(null);
const anchorRefFallback = (0,external_wp_element_namespaceObject.useCallback)((node) => {
setFallbackReferenceElement(node);
}, []);
const isMobileViewport = (0,external_wp_compose_namespaceObject.useViewportMatch)("medium", "<");
const isExpanded = expandOnMobile && isMobileViewport;
const hasArrow = !isExpanded && !noArrow;
const normalizedPlacementFromProps = position ? positionToPlacement(position) : placementProp;
const middleware = [...placementProp === "overlay" ? overlayMiddlewares() : [], offset(offsetProp), computedFlipProp && floating_ui_dom_flip(), computedResizeProp && floating_ui_dom_size({
padding: OVERFLOW_PADDING,
apply(sizeProps) {
var _refs$floating$curren;
const {
firstElementChild
} = (_refs$floating$curren = refs.floating.current) !== null && _refs$floating$curren !== void 0 ? _refs$floating$curren : {};
if (!(firstElementChild instanceof HTMLElement)) {
return;
}
Object.assign(firstElementChild.style, {
maxHeight: `${Math.max(0, sizeProps.availableHeight)}px`,
overflow: "auto"
});
}
}), shift && floating_ui_dom_shift({
crossAxis: true,
limiter: floating_ui_dom_limitShift(),
padding: 1
// Necessary to avoid flickering at the edge of the viewport.
}), floating_ui_react_dom_arrow({
element: arrowRef
})];
const slotName = (0,external_wp_element_namespaceObject.useContext)(slotNameContext) || __unstableSlotName;
const slot = useSlot(slotName);
let onDialogClose;
if (onClose || onFocusOutside) {
onDialogClose = (type, event) => {
if (type === "focus-outside" && onFocusOutside) {
onFocusOutside(event);
} else if (onClose) {
onClose();
}
};
}
const [dialogRef, dialogProps] = (0,external_wp_compose_namespaceObject.__experimentalUseDialog)({
constrainTabbing,
focusOnMount,
__unstableOnClose: onDialogClose,
// @ts-expect-error The __unstableOnClose property needs to be deprecated first (see https://github.com/WordPress/gutenberg/pull/27675)
onClose: onDialogClose
});
const {
// Positioning coordinates
x,
y,
// Object with "regular" refs to both "reference" and "floating"
refs,
// Type of CSS position property to use (absolute or fixed)
strategy,
update,
placement: computedPlacement,
middlewareData: {
arrow: arrowData
}
} = useFloating({
placement: normalizedPlacementFromProps === "overlay" ? void 0 : normalizedPlacementFromProps,
middleware,
whileElementsMounted: (referenceParam, floatingParam, updateParam) => autoUpdate(referenceParam, floatingParam, updateParam, {
layoutShift: false,
animationFrame: true
})
});
const arrowCallbackRef = (0,external_wp_element_namespaceObject.useCallback)((node) => {
arrowRef.current = node;
update();
}, [update]);
const anchorRefTop = anchorRef?.top;
const anchorRefBottom = anchorRef?.bottom;
const anchorRefStartContainer = anchorRef?.startContainer;
const anchorRefCurrent = anchorRef?.current;
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
const resultingReferenceElement = getReferenceElement({
anchor,
anchorRef,
anchorRect,
getAnchorRect,
fallbackReferenceElement
});
refs.setReference(resultingReferenceElement);
}, [anchor, anchorRef, anchorRefTop, anchorRefBottom, anchorRefStartContainer, anchorRefCurrent, anchorRect, getAnchorRect, fallbackReferenceElement, refs]);
const mergedFloatingRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([refs.setFloating, dialogRef, forwardedRef]);
const style = isExpanded ? void 0 : {
position: strategy,
top: 0,
left: 0,
// `x` and `y` are framer-motion specific props and are shorthands
// for `translateX` and `translateY`. Currently it is not possible
// to use `translateX` and `translateY` because those values would
// be overridden by the return value of the
// `placementToMotionAnimationProps` function.
x: computePopoverPosition(x),
y: computePopoverPosition(y)
};
const shouldReduceMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
const shouldAnimate = animate && !isExpanded && !shouldReduceMotion;
const [animationFinished, setAnimationFinished] = (0,external_wp_element_namespaceObject.useState)(false);
const {
style: motionInlineStyles,
...otherMotionProps
} = (0,external_wp_element_namespaceObject.useMemo)(() => placementToMotionAnimationProps(computedPlacement), [computedPlacement]);
const animationProps = shouldAnimate ? {
style: {
...contentStyle,
...motionInlineStyles,
...style
},
onAnimationComplete: () => setAnimationFinished(true),
...otherMotionProps
} : {
animate: false,
style: {
...contentStyle,
...style
}
};
const isPositioned = (!shouldAnimate || animationFinished) && x !== null && y !== null;
let content = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(motion.div, {
className: dist_clsx(className, {
"is-expanded": isExpanded,
"is-positioned": isPositioned,
// Use the 'alternate' classname for 'toolbar' variant for back compat.
[`is-${computedVariant === "toolbar" ? "alternate" : computedVariant}`]: computedVariant
}),
...animationProps,
...contentProps,
ref: mergedFloatingRef,
...dialogProps,
tabIndex: -1,
children: [isExpanded && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(scroll_lock_default, {}), isExpanded && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-popover__header",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-popover__header-title",
children: headerTitle
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
className: "components-popover__close",
size: "small",
icon: close_default,
onClick: onClose,
label: (0,external_wp_i18n_namespaceObject.__)("Close")
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-popover__content",
children
}), hasArrow && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref: arrowCallbackRef,
className: ["components-popover__arrow", `is-${computedPlacement.split("-")[0]}`].join(" "),
style: {
left: typeof arrowData?.x !== "undefined" && Number.isFinite(arrowData.x) ? `${arrowData.x}px` : "",
top: typeof arrowData?.y !== "undefined" && Number.isFinite(arrowData.y) ? `${arrowData.y}px` : ""
},
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ArrowTriangle, {})
})]
});
const shouldRenderWithinSlot = slot.ref && !inline;
const hasAnchor = anchorRef || anchorRect || anchor;
if (shouldRenderWithinSlot) {
content = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(slot_fill_Fill, {
name: slotName,
children: content
});
} else if (!inline) {
content = (0,external_wp_element_namespaceObject.createPortal)(/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyleProvider, {
document,
children: content
}), getPopoverFallbackContainer());
}
if (hasAnchor) {
return content;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
ref: anchorRefFallback
}), content]
});
};
const PopoverSlot = (0,external_wp_element_namespaceObject.forwardRef)(({
name = SLOT_NAME
}, ref) => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(slot_fill_Slot, {
bubblesVirtually: true,
name,
className: "popover-slot",
ref
});
});
const popover_Popover = Object.assign(contextConnect(UnforwardedPopover, "Popover"), {
/**
* Renders a slot that is used internally by Popover for rendering content.
*/
Slot: Object.assign(PopoverSlot, {
displayName: "Popover.Slot"
}),
/**
* Provides a context to manage popover slot names.
*
* This is marked as unstable and should not be used directly.
*/
__unstableSlotNameProvider: Object.assign(slotNameContext.Provider, {
displayName: "Popover.__unstableSlotNameProvider"
})
});
var popover_default = popover_Popover;
;// ./node_modules/@wordpress/components/build-module/autocomplete/autocompleter-ui.js
function ListBox({
items,
onSelect,
selectedIndex,
instanceId,
listBoxId,
className,
Component = "div"
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
id: listBoxId,
role: "listbox",
className: "components-autocomplete__results",
children: items.map((option, index) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
id: `components-autocomplete-item-${instanceId}-${option.key}`,
role: "option",
__next40pxDefaultSize: true,
"aria-selected": index === selectedIndex,
accessibleWhenDisabled: true,
disabled: option.isDisabled,
className: dist_clsx("components-autocomplete__result", className, {
// Unused, for backwards compatibility.
"is-selected": index === selectedIndex
}),
variant: index === selectedIndex ? "primary" : void 0,
onClick: () => onSelect(option),
children: option.label
}, option.key))
});
}
function getAutoCompleterUI(autocompleter) {
var _autocompleter$useIte;
const useItems = (_autocompleter$useIte = autocompleter.useItems) !== null && _autocompleter$useIte !== void 0 ? _autocompleter$useIte : getDefaultUseItems(autocompleter);
function AutocompleterUI({
filterValue,
instanceId,
listBoxId,
className,
selectedIndex,
onChangeOptions,
onSelect,
onReset,
reset,
contentRef
}) {
const [items] = useItems(filterValue);
const popoverAnchor = (0,external_wp_richText_namespaceObject.useAnchor)({
editableContentElement: contentRef.current
});
const [needsA11yCompat, setNeedsA11yCompat] = (0,external_wp_element_namespaceObject.useState)(false);
const popoverRef = (0,external_wp_element_namespaceObject.useRef)(null);
const popoverRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([popoverRef, (0,external_wp_compose_namespaceObject.useRefEffect)((node) => {
if (!contentRef.current) {
return;
}
setNeedsA11yCompat(node.ownerDocument !== contentRef.current.ownerDocument);
}, [contentRef])]);
useOnClickOutside(popoverRef, reset);
const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
function announce(options) {
if (!debouncedSpeak) {
return;
}
if (!!options.length) {
if (filterValue) {
debouncedSpeak((0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: %d: number of results. */
(0,external_wp_i18n_namespaceObject._n)("%d result found, use up and down arrow keys to navigate.", "%d results found, use up and down arrow keys to navigate.", options.length),
options.length
), "assertive");
} else {
debouncedSpeak((0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: %d: number of results. */
(0,external_wp_i18n_namespaceObject._n)("Initial %d result loaded. Type to filter all available results. Use up and down arrow keys to navigate.", "Initial %d results loaded. Type to filter all available results. Use up and down arrow keys to navigate.", options.length),
options.length
), "assertive");
}
} else {
debouncedSpeak((0,external_wp_i18n_namespaceObject.__)("No results."), "assertive");
}
}
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
onChangeOptions(items);
announce(items);
}, [items]);
if (items.length === 0) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(popover_default, {
focusOnMount: false,
onClose: onReset,
placement: "top-start",
className: "components-autocomplete__popover",
anchor: popoverAnchor,
ref: popoverRefs,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ListBox, {
items,
onSelect,
selectedIndex,
instanceId,
listBoxId,
className
})
}), contentRef.current && needsA11yCompat && (0,external_ReactDOM_namespaceObject.createPortal)(/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ListBox, {
items,
onSelect,
selectedIndex,
instanceId,
listBoxId,
className,
Component: component_component_default
}), contentRef.current.ownerDocument.body)]
});
}
return AutocompleterUI;
}
function useOnClickOutside(ref, handler) {
(0,external_wp_element_namespaceObject.useEffect)(() => {
const listener = (event) => {
if (!ref.current || ref.current.contains(event.target)) {
return;
}
handler(event);
};
document.addEventListener("mousedown", listener);
document.addEventListener("touchstart", listener);
return () => {
document.removeEventListener("mousedown", listener);
document.removeEventListener("touchstart", listener);
};
}, [handler, ref]);
}
;// ./node_modules/@wordpress/components/build-module/utils/get-node-text.js
const getNodeText = (node) => {
if (node === null) {
return "";
}
switch (typeof node) {
case "string":
case "number":
return node.toString();
case "object": {
if (node instanceof Array) {
return node.map(getNodeText).join("");
}
if ("props" in node) {
return getNodeText(node.props.children);
}
return "";
}
default:
return "";
}
};
var get_node_text_default = getNodeText;
;// ./node_modules/@wordpress/components/build-module/autocomplete/index.js
const EMPTY_FILTERED_OPTIONS = [];
const AUTOCOMPLETE_HOOK_REFERENCE = {};
function useAutocomplete({
record,
onChange,
onReplace,
completers,
contentRef
}) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(AUTOCOMPLETE_HOOK_REFERENCE);
const [selectedIndex, setSelectedIndex] = (0,external_wp_element_namespaceObject.useState)(0);
const [filteredOptions, setFilteredOptions] = (0,external_wp_element_namespaceObject.useState)(EMPTY_FILTERED_OPTIONS);
const [filterValue, setFilterValue] = (0,external_wp_element_namespaceObject.useState)("");
const [autocompleter, setAutocompleter] = (0,external_wp_element_namespaceObject.useState)(null);
const [AutocompleterUI, setAutocompleterUI] = (0,external_wp_element_namespaceObject.useState)(null);
const backspacingRef = (0,external_wp_element_namespaceObject.useRef)(false);
function insertCompletion(replacement) {
if (autocompleter === null) {
return;
}
const end = record.start;
const start = end - autocompleter.triggerPrefix.length - filterValue.length;
const toInsert = (0,external_wp_richText_namespaceObject.create)({
html: (0,external_wp_element_namespaceObject.renderToString)(replacement)
});
onChange((0,external_wp_richText_namespaceObject.insert)(record, toInsert, start, end));
}
function select(option) {
const {
getOptionCompletion
} = autocompleter || {};
if (option.isDisabled) {
return;
}
if (getOptionCompletion) {
const completion = getOptionCompletion(option.value, filterValue);
const isCompletionObject = (obj) => {
return obj !== null && typeof obj === "object" && "action" in obj && obj.action !== void 0 && "value" in obj && obj.value !== void 0;
};
const completionObject = isCompletionObject(completion) ? completion : {
action: "insert-at-caret",
value: completion
};
if ("replace" === completionObject.action) {
onReplace([completionObject.value]);
return;
} else if ("insert-at-caret" === completionObject.action) {
insertCompletion(completionObject.value);
}
}
reset();
contentRef.current?.focus();
}
function reset() {
setSelectedIndex(0);
setFilteredOptions(EMPTY_FILTERED_OPTIONS);
setFilterValue("");
setAutocompleter(null);
setAutocompleterUI(null);
}
function onChangeOptions(options) {
setSelectedIndex(options.length === filteredOptions.length ? selectedIndex : 0);
setFilteredOptions(options);
}
function handleKeyDown(event) {
backspacingRef.current = event.key === "Backspace";
if (!autocompleter) {
return;
}
if (filteredOptions.length === 0) {
return;
}
if (event.defaultPrevented) {
return;
}
switch (event.key) {
case "ArrowUp": {
const newIndex = (selectedIndex === 0 ? filteredOptions.length : selectedIndex) - 1;
setSelectedIndex(newIndex);
if ((0,external_wp_keycodes_namespaceObject.isAppleOS)()) {
(0,external_wp_a11y_namespaceObject.speak)(get_node_text_default(filteredOptions[newIndex].label), "assertive");
}
break;
}
case "ArrowDown": {
const newIndex = (selectedIndex + 1) % filteredOptions.length;
setSelectedIndex(newIndex);
if ((0,external_wp_keycodes_namespaceObject.isAppleOS)()) {
(0,external_wp_a11y_namespaceObject.speak)(get_node_text_default(filteredOptions[newIndex].label), "assertive");
}
break;
}
case "Escape":
setAutocompleter(null);
setAutocompleterUI(null);
event.preventDefault();
break;
case "Enter":
select(filteredOptions[selectedIndex]);
break;
case "ArrowLeft":
case "ArrowRight":
reset();
return;
default:
return;
}
event.preventDefault();
}
const textContent = (0,external_wp_element_namespaceObject.useMemo)(() => {
if ((0,external_wp_richText_namespaceObject.isCollapsed)(record)) {
return (0,external_wp_richText_namespaceObject.getTextContent)((0,external_wp_richText_namespaceObject.slice)(record, 0));
}
return "";
}, [record]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!textContent) {
if (autocompleter) {
reset();
}
return;
}
const completer = completers.reduce((lastTrigger, currentCompleter) => {
const triggerIndex2 = textContent.lastIndexOf(currentCompleter.triggerPrefix);
const lastTriggerIndex = lastTrigger !== null ? textContent.lastIndexOf(lastTrigger.triggerPrefix) : -1;
return triggerIndex2 > lastTriggerIndex ? currentCompleter : lastTrigger;
}, null);
if (!completer) {
if (autocompleter) {
reset();
}
return;
}
const {
allowContext,
triggerPrefix
} = completer;
const triggerIndex = textContent.lastIndexOf(triggerPrefix);
const textWithoutTrigger = textContent.slice(triggerIndex + triggerPrefix.length);
const tooDistantFromTrigger = textWithoutTrigger.length > 50;
if (tooDistantFromTrigger) {
return;
}
const mismatch = filteredOptions.length === 0;
const wordsFromTrigger = textWithoutTrigger.split(/\s/);
const hasOneTriggerWord = wordsFromTrigger.length === 1;
const matchingWhileBackspacing = backspacingRef.current && wordsFromTrigger.length <= 3;
if (mismatch && !(matchingWhileBackspacing || hasOneTriggerWord)) {
if (autocompleter) {
reset();
}
return;
}
const textAfterSelection = (0,external_wp_richText_namespaceObject.getTextContent)((0,external_wp_richText_namespaceObject.slice)(record, void 0, (0,external_wp_richText_namespaceObject.getTextContent)(record).length));
if (allowContext && !allowContext(textContent.slice(0, triggerIndex), textAfterSelection)) {
if (autocompleter) {
reset();
}
return;
}
if (/^\s/.test(textWithoutTrigger) || /\s\s+$/.test(textWithoutTrigger)) {
if (autocompleter) {
reset();
}
return;
}
if (!/[\u0000-\uFFFF]*$/.test(textWithoutTrigger)) {
if (autocompleter) {
reset();
}
return;
}
const safeTrigger = escapeRegExp(completer.triggerPrefix);
const text = remove_accents_default()(textContent);
const match = text.slice(text.lastIndexOf(completer.triggerPrefix)).match(new RegExp(`${safeTrigger}([\0-\uFFFF]*)$`));
const query = match && match[1];
setAutocompleter(completer);
setAutocompleterUI(() => completer !== autocompleter ? getAutoCompleterUI(completer) : AutocompleterUI);
setFilterValue(query === null ? "" : query);
}, [textContent]);
const {
key: selectedKey = ""
} = filteredOptions[selectedIndex] || {};
const {
className
} = autocompleter || {};
const isExpanded = !!autocompleter && filteredOptions.length > 0;
const listBoxId = isExpanded ? `components-autocomplete-listbox-${instanceId}` : void 0;
const activeId = isExpanded ? `components-autocomplete-item-${instanceId}-${selectedKey}` : null;
const hasSelection = record.start !== void 0;
const showPopover = !!textContent && hasSelection && !!AutocompleterUI;
return {
listBoxId,
activeId,
onKeyDown: withIgnoreIMEEvents(handleKeyDown),
popover: showPopover && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(AutocompleterUI, {
className,
filterValue,
instanceId,
listBoxId,
selectedIndex,
onChangeOptions,
onSelect: select,
value: record,
contentRef,
reset
})
};
}
function useLastDifferentValue(value) {
const history = (0,external_wp_element_namespaceObject.useRef)(/* @__PURE__ */ new Set());
history.current.add(value);
if (history.current.size > 2) {
history.current.delete(Array.from(history.current)[0]);
}
return Array.from(history.current)[0];
}
function useAutocompleteProps(options) {
const ref = (0,external_wp_element_namespaceObject.useRef)(null);
const onKeyDownRef = (0,external_wp_element_namespaceObject.useRef)();
const {
record
} = options;
const previousRecord = useLastDifferentValue(record);
const {
popover,
listBoxId,
activeId,
onKeyDown
} = useAutocomplete({
...options,
contentRef: ref
});
onKeyDownRef.current = onKeyDown;
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, (0,external_wp_compose_namespaceObject.useRefEffect)((element) => {
function _onKeyDown(event) {
onKeyDownRef.current?.(event);
}
element.addEventListener("keydown", _onKeyDown);
return () => {
element.removeEventListener("keydown", _onKeyDown);
};
}, [])]);
const didUserInput = record.text !== previousRecord?.text;
if (!didUserInput) {
return {
ref: mergedRefs
};
}
return {
ref: mergedRefs,
children: popover,
"aria-autocomplete": listBoxId ? "list" : void 0,
"aria-owns": listBoxId,
"aria-activedescendant": activeId
};
}
function Autocomplete({
children,
isSelected,
...options
}) {
const {
popover,
...props
} = useAutocomplete(options);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [children(props), isSelected && popover]
});
}
;// ./node_modules/@wordpress/components/build-module/base-control/hooks.js
function useBaseControlProps(props) {
const {
help,
id: preferredId,
...restProps
} = props;
const uniqueId = (0,external_wp_compose_namespaceObject.useInstanceId)(base_control_default, "wp-components-base-control", preferredId);
return {
baseControlProps: {
id: uniqueId,
help,
...restProps
},
controlProps: {
id: uniqueId,
...!!help ? {
"aria-describedby": `${uniqueId}__help`
} : {}
}
};
}
;// ./node_modules/@wordpress/icons/build-module/library/link.js
var link_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M10 17.389H8.444A5.194 5.194 0 1 1 8.444 7H10v1.5H8.444a3.694 3.694 0 0 0 0 7.389H10v1.5ZM14 7h1.556a5.194 5.194 0 0 1 0 10.39H14v-1.5h1.556a3.694 3.694 0 0 0 0-7.39H14V7Zm-4.5 6h5v-1.5h-5V13Z" }) });
;// ./node_modules/@wordpress/icons/build-module/library/link-off.js
var link_off_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M17.031 4.703 15.576 4l-1.56 3H14v.03l-2.324 4.47H9.5V13h1.396l-1.502 2.889h-.95a3.694 3.694 0 0 1 0-7.389H10V7H8.444a5.194 5.194 0 1 0 0 10.389h.17L7.5 19.53l1.416.719L15.049 8.5h.507a3.694 3.694 0 0 1 0 7.39H14v1.5h1.556a5.194 5.194 0 0 0 .273-10.383l1.202-2.304Z" }) });
;// ./node_modules/@wordpress/components/build-module/border-box-control/styles.js
function border_box_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const borderBoxControl = /* @__PURE__ */ emotion_react_browser_esm_css( true ? "" : 0, true ? "" : 0);
const linkedBorderControl = () => /* @__PURE__ */ emotion_react_browser_esm_css("flex:1;", rtl({
marginRight: "24px"
})(), ";" + ( true ? "" : 0), true ? "" : 0);
const wrapper = true ? {
name: "bjn8wh",
styles: "position:relative"
} : 0;
const borderBoxControlLinkedButton = (size) => {
return /* @__PURE__ */ emotion_react_browser_esm_css("position:absolute;top:", size === "__unstable-large" ? "8px" : "3px", ";", rtl({
right: 0
})(), " line-height:0;" + ( true ? "" : 0), true ? "" : 0);
};
const borderBoxStyleWithFallback = (border) => {
const {
color = COLORS.gray[200],
style = "solid",
width = config_values_default.borderWidth
} = border || {};
const clampedWidth = width !== config_values_default.borderWidth ? `clamp(1px, ${width}, 10px)` : width;
const hasVisibleBorder = !!width && width !== "0" || !!color;
const borderStyle = hasVisibleBorder ? style || "solid" : style;
return `${color} ${borderStyle} ${clampedWidth}`;
};
const borderBoxControlVisualizer = (borders, size) => {
return /* @__PURE__ */ emotion_react_browser_esm_css("position:absolute;top:", size === "__unstable-large" ? "20px" : "15px", ";right:", size === "__unstable-large" ? "39px" : "29px", ";bottom:", size === "__unstable-large" ? "20px" : "15px", ";left:", size === "__unstable-large" ? "39px" : "29px", ";border-top:", borderBoxStyleWithFallback(borders?.top), ";border-bottom:", borderBoxStyleWithFallback(borders?.bottom), ";", rtl({
borderLeft: borderBoxStyleWithFallback(borders?.left)
})(), " ", rtl({
borderRight: borderBoxStyleWithFallback(borders?.right)
})(), ";" + ( true ? "" : 0), true ? "" : 0);
};
const borderBoxControlSplitControls = (size) => /* @__PURE__ */ emotion_react_browser_esm_css("position:relative;flex:1;width:", size === "__unstable-large" ? void 0 : "80%", ";" + ( true ? "" : 0), true ? "" : 0);
const centeredBorderControl = true ? {
name: "1nwbfnf",
styles: "grid-column:span 2;margin:0 auto"
} : 0;
const rightBorderControl = () => /* @__PURE__ */ emotion_react_browser_esm_css(rtl({
marginLeft: "auto"
})(), ";" + ( true ? "" : 0), true ? "" : 0);
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control-linked-button/hook.js
function useBorderBoxControlLinkedButton(props) {
const {
className,
size = "default",
...otherProps
} = useContextSystem(props, "BorderBoxControlLinkedButton");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderBoxControlLinkedButton(size), className);
}, [className, cx, size]);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control-linked-button/component.js
const BorderBoxControlLinkedButton = (props, forwardedRef) => {
const {
className,
isLinked,
...buttonProps
} = useBorderBoxControlLinkedButton(props);
const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)("Unlink sides") : (0,external_wp_i18n_namespaceObject.__)("Link sides");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
...buttonProps,
size: "small",
icon: isLinked ? link_default : link_off_default,
iconSize: 24,
label,
ref: forwardedRef,
className
});
};
const ConnectedBorderBoxControlLinkedButton = contextConnect(BorderBoxControlLinkedButton, "BorderBoxControlLinkedButton");
var border_box_control_linked_button_component_component_default = ConnectedBorderBoxControlLinkedButton;
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control-visualizer/hook.js
function useBorderBoxControlVisualizer(props) {
const {
className,
value,
size = "default",
...otherProps
} = useContextSystem(props, "BorderBoxControlVisualizer");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderBoxControlVisualizer(value, size), className);
}, [cx, className, value, size]);
return {
...otherProps,
className: classes,
value
};
}
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control-visualizer/component.js
const BorderBoxControlVisualizer = (props, forwardedRef) => {
const {
value,
...otherProps
} = useBorderBoxControlVisualizer(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...otherProps,
ref: forwardedRef
});
};
const ConnectedBorderBoxControlVisualizer = contextConnect(BorderBoxControlVisualizer, "BorderBoxControlVisualizer");
var border_box_control_visualizer_component_component_default = ConnectedBorderBoxControlVisualizer;
;// ./node_modules/@wordpress/icons/build-module/library/line-solid.js
var line_solid_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M5 11.25h14v1.5H5z" }) });
;// ./node_modules/@wordpress/icons/build-module/library/line-dashed.js
var line_dashed_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
external_wp_primitives_namespaceObject.Path,
{
fillRule: "evenodd",
d: "M5 11.25h3v1.5H5v-1.5zm5.5 0h3v1.5h-3v-1.5zm8.5 0h-3v1.5h3v-1.5z",
clipRule: "evenodd"
}
) });
;// ./node_modules/@wordpress/icons/build-module/library/line-dotted.js
var line_dotted_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
external_wp_primitives_namespaceObject.Path,
{
fillRule: "evenodd",
d: "M5.25 11.25h1.5v1.5h-1.5v-1.5zm3 0h1.5v1.5h-1.5v-1.5zm4.5 0h-1.5v1.5h1.5v-1.5zm1.5 0h1.5v1.5h-1.5v-1.5zm4.5 0h-1.5v1.5h1.5v-1.5z",
clipRule: "evenodd"
}
) });
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control/styles.js
function toggle_group_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const toggleGroupControl = ({
isBlock,
isDeselectable,
size
}) => /* @__PURE__ */ emotion_react_browser_esm_css("background:", COLORS.ui.background, ";border:1px solid transparent;border-radius:", config_values_default.radiusSmall, ";display:inline-flex;min-width:0;position:relative;", toggleGroupControlSize(size), " ", !isDeselectable && enclosingBorders(isBlock), "@media not ( prefers-reduced-motion ){&[data-indicator-animated]::before{transition-property:transform,border-radius;transition-duration:0.2s;transition-timing-function:ease-out;}}&::before{content:'';position:absolute;pointer-events:none;background:", COLORS.theme.foreground, ";outline:2px solid transparent;outline-offset:-3px;--antialiasing-factor:100;border-radius:calc(\n ", config_values_default.radiusXSmall, " /\n (\n var( --selected-width, 0 ) /\n var( --antialiasing-factor )\n )\n )/", config_values_default.radiusXSmall, ";left:-1px;width:calc( var( --antialiasing-factor ) * 1px );height:calc( var( --selected-height, 0 ) * 1px );transform-origin:left top;transform:translateX( calc( var( --selected-left, 0 ) * 1px ) ) scaleX(\n calc(\n var( --selected-width, 0 ) / var( --antialiasing-factor )\n )\n );}" + ( true ? "" : 0), true ? "" : 0);
const enclosingBorders = (isBlock) => {
const enclosingBorder = /* @__PURE__ */ emotion_react_browser_esm_css("border-color:", COLORS.ui.border, ";" + ( true ? "" : 0), true ? "" : 0);
return /* @__PURE__ */ emotion_react_browser_esm_css(isBlock && enclosingBorder, " &:hover{border-color:", COLORS.ui.borderHover, ";}&:focus-within{border-color:", COLORS.ui.borderFocus, ";box-shadow:", config_values_default.controlBoxShadowFocus, ";z-index:1;outline:2px solid transparent;outline-offset:-2px;}" + ( true ? "" : 0), true ? "" : 0);
};
var styles_ref = true ? {
name: "1aqh2c7",
styles: "min-height:40px;padding:3px"
} : 0;
var _ref2 = true ? {
name: "1ndywgm",
styles: "min-height:36px;padding:2px"
} : 0;
const toggleGroupControlSize = (size) => {
const styles = {
default: _ref2,
"__unstable-large": styles_ref
};
return styles[size];
};
const toggle_group_control_styles_block = true ? {
name: "7whenc",
styles: "display:flex;width:100%"
} : 0;
const VisualLabelWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eakva830"
} : 0)( true ? {
name: "zjik7",
styles: "display:flex"
} : 0);
;// ./node_modules/@ariakit/core/esm/radio/radio-store.js
"use client";
// src/radio/radio-store.ts
function createRadioStore(_a = {}) {
var props = _3YLGPPWQ_objRest(_a, []);
var _a2;
const syncState = (_a2 = props.store) == null ? void 0 : _a2.getState();
const composite = createCompositeStore(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, props), {
focusLoop: defaultValue(props.focusLoop, syncState == null ? void 0 : syncState.focusLoop, true)
}));
const initialState = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, composite.getState()), {
value: defaultValue(
props.value,
syncState == null ? void 0 : syncState.value,
props.defaultValue,
null
)
});
const radio = createStore(initialState, composite, props.store);
return _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, composite), radio), {
setValue: (value) => radio.setState("value", value)
});
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/4BXJGRNH.js
"use client";
// src/radio/radio-store.ts
function useRadioStoreProps(store, update, props) {
store = useCompositeStoreProps(store, update, props);
useStoreProps(store, props, "value", "setValue");
return store;
}
function useRadioStore(props = {}) {
const [store, update] = YV4JVR4I_useStore(createRadioStore, props);
return useRadioStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/UVUMR3WP.js
"use client";
// src/radio/radio-context.tsx
var UVUMR3WP_ctx = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var useRadioContext = UVUMR3WP_ctx.useContext;
var useRadioScopedContext = UVUMR3WP_ctx.useScopedContext;
var useRadioProviderContext = UVUMR3WP_ctx.useProviderContext;
var RadioContextProvider = UVUMR3WP_ctx.ContextProvider;
var RadioScopedContextProvider = UVUMR3WP_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/radio/radio-group.js
"use client";
// src/radio/radio-group.tsx
var radio_group_TagName = "div";
var useRadioGroup = createHook(
function useRadioGroup2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useRadioProviderContext();
store = store || context;
invariant(
store,
false && 0
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RadioScopedContextProvider, { value: store, children: element }),
[store]
);
props = _3YLGPPWQ_spreadValues({
role: "radiogroup"
}, props);
props = useComposite(_3YLGPPWQ_spreadValues({ store }, props));
return props;
}
);
var RadioGroup = forwardRef2(function RadioGroup2(props) {
const htmlProps = useRadioGroup(props);
return LMDWO4NN_createElement(radio_group_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/context.js
const ToggleGroupControlContext = (0,external_wp_element_namespaceObject.createContext)({});
ToggleGroupControlContext.displayName = "ToggleGroupControlContext";
const useToggleGroupControlContext = () => (0,external_wp_element_namespaceObject.useContext)(ToggleGroupControlContext);
var context_context_default = ToggleGroupControlContext;
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control/utils.js
function useComputeControlledOrUncontrolledValue(valueProp) {
const isInitialRenderRef = (0,external_wp_element_namespaceObject.useRef)(true);
const prevValueProp = (0,external_wp_compose_namespaceObject.usePrevious)(valueProp);
const prevIsControlledRef = (0,external_wp_element_namespaceObject.useRef)(false);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (isInitialRenderRef.current) {
isInitialRenderRef.current = false;
}
}, []);
const isControlled = prevIsControlledRef.current || !isInitialRenderRef.current && prevValueProp !== valueProp;
(0,external_wp_element_namespaceObject.useEffect)(() => {
prevIsControlledRef.current = isControlled;
}, [isControlled]);
if (isControlled) {
return {
value: valueProp !== null && valueProp !== void 0 ? valueProp : "",
defaultValue: void 0
};
}
return {
value: void 0,
defaultValue: valueProp
};
}
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control/as-radio-group.js
function UnforwardedToggleGroupControlAsRadioGroup({
children,
isAdaptiveWidth,
label,
onChange: onChangeProp,
size,
value: valueProp,
id: idProp,
setSelectedElement,
...otherProps
}, forwardedRef) {
const generatedId = (0,external_wp_compose_namespaceObject.useInstanceId)(ToggleGroupControlAsRadioGroup, "toggle-group-control-as-radio-group");
const baseId = idProp || generatedId;
const {
value,
defaultValue
} = useComputeControlledOrUncontrolledValue(valueProp);
const wrappedOnChangeProp = onChangeProp ? (v) => {
onChangeProp(v !== null && v !== void 0 ? v : void 0);
} : void 0;
const radio = useRadioStore({
defaultValue,
value,
setValue: wrappedOnChangeProp,
rtl: (0,external_wp_i18n_namespaceObject.isRTL)()
});
const selectedValue = useStoreState(radio, "value");
const setValue = radio.setValue;
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (selectedValue === "") {
radio.setActiveId(void 0);
}
}, [radio, selectedValue]);
const groupContextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
activeItemIsNotFirstItem: () => radio.getState().activeId !== radio.first(),
baseId,
isBlock: !isAdaptiveWidth,
size,
// @ts-expect-error - This is wrong and we should fix it.
value: selectedValue,
// @ts-expect-error - This is wrong and we should fix it.
setValue,
setSelectedElement
}), [baseId, isAdaptiveWidth, radio, selectedValue, setSelectedElement, setValue, size]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(context_context_default.Provider, {
value: groupContextValue,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RadioGroup, {
store: radio,
"aria-label": label,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {}),
...otherProps,
id: baseId,
ref: forwardedRef,
children
})
});
}
const ToggleGroupControlAsRadioGroup = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToggleGroupControlAsRadioGroup);
;// ./node_modules/@wordpress/components/build-module/utils/hooks/use-controlled-value.js
function useControlledValue({
defaultValue,
onChange,
value: valueProp
}) {
const hasValue = typeof valueProp !== "undefined";
const initialValue = hasValue ? valueProp : defaultValue;
const [state, setState] = (0,external_wp_element_namespaceObject.useState)(initialValue);
const value = hasValue ? valueProp : state;
const uncontrolledSetValue = (0,external_wp_element_namespaceObject.useCallback)((nextValue, ...args) => {
setState(nextValue);
onChange?.(nextValue, ...args);
}, [onChange]);
let setValue;
if (hasValue && typeof onChange === "function") {
setValue = onChange;
} else if (!hasValue && typeof onChange === "function") {
setValue = uncontrolledSetValue;
} else {
setValue = setState;
}
return [value, setValue];
}
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control/as-button-group.js
function UnforwardedToggleGroupControlAsButtonGroup({
children,
isAdaptiveWidth,
label,
onChange,
size,
value: valueProp,
id: idProp,
setSelectedElement,
...otherProps
}, forwardedRef) {
const generatedId = (0,external_wp_compose_namespaceObject.useInstanceId)(ToggleGroupControlAsButtonGroup, "toggle-group-control-as-button-group");
const baseId = idProp || generatedId;
const {
value,
defaultValue
} = useComputeControlledOrUncontrolledValue(valueProp);
const [selectedValue, setSelectedValue] = useControlledValue({
defaultValue,
value,
onChange
});
const groupContextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
baseId,
value: selectedValue,
setValue: setSelectedValue,
isBlock: !isAdaptiveWidth,
isDeselectable: true,
size,
setSelectedElement
}), [baseId, selectedValue, setSelectedValue, isAdaptiveWidth, size, setSelectedElement]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(context_context_default.Provider, {
value: groupContextValue,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
"aria-label": label,
...otherProps,
ref: forwardedRef,
role: "group",
children
})
});
}
const ToggleGroupControlAsButtonGroup = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToggleGroupControlAsButtonGroup);
;// ./node_modules/@wordpress/components/build-module/utils/element-rect.js
const NULL_ELEMENT_OFFSET_RECT = {
element: void 0,
top: 0,
right: 0,
bottom: 0,
left: 0,
width: 0,
height: 0
};
function getElementOffsetRect(element) {
var _offsetParent$getBoun, _offsetParent$scrollL, _offsetParent$scrollT;
const rect = element.getBoundingClientRect();
if (rect.width === 0 || rect.height === 0) {
return;
}
const offsetParent = element.offsetParent;
const offsetParentRect = (_offsetParent$getBoun = offsetParent?.getBoundingClientRect()) !== null && _offsetParent$getBoun !== void 0 ? _offsetParent$getBoun : NULL_ELEMENT_OFFSET_RECT;
const offsetParentScrollX = (_offsetParent$scrollL = offsetParent?.scrollLeft) !== null && _offsetParent$scrollL !== void 0 ? _offsetParent$scrollL : 0;
const offsetParentScrollY = (_offsetParent$scrollT = offsetParent?.scrollTop) !== null && _offsetParent$scrollT !== void 0 ? _offsetParent$scrollT : 0;
const computedWidth = parseFloat(getComputedStyle(element).width);
const computedHeight = parseFloat(getComputedStyle(element).height);
const scaleX = computedWidth / rect.width;
const scaleY = computedHeight / rect.height;
return {
element,
// To obtain the adjusted values for the position:
// 1. Compute the element's position relative to the offset parent.
// 2. Correct for the scale factor.
// 3. Adjust for the scroll position of the offset parent.
top: (rect.top - offsetParentRect?.top) * scaleY + offsetParentScrollY,
right: (offsetParentRect?.right - rect.right) * scaleX - offsetParentScrollX,
bottom: (offsetParentRect?.bottom - rect.bottom) * scaleY - offsetParentScrollY,
left: (rect.left - offsetParentRect?.left) * scaleX + offsetParentScrollX,
// Computed dimensions don't need any adjustments.
width: computedWidth,
height: computedHeight
};
}
const POLL_RATE = 100;
function useTrackElementOffsetRect(targetElement, deps = []) {
const [indicatorPosition, setIndicatorPosition] = (0,external_wp_element_namespaceObject.useState)(NULL_ELEMENT_OFFSET_RECT);
const intervalRef = (0,external_wp_element_namespaceObject.useRef)();
const measure = (0,external_wp_compose_namespaceObject.useEvent)(() => {
if (targetElement && targetElement.isConnected) {
const elementOffsetRect = getElementOffsetRect(targetElement);
if (elementOffsetRect) {
setIndicatorPosition(elementOffsetRect);
clearInterval(intervalRef.current);
return true;
}
} else {
clearInterval(intervalRef.current);
}
return false;
});
const setElement = (0,external_wp_compose_namespaceObject.useResizeObserver)(() => {
if (!measure()) {
requestAnimationFrame(() => {
if (!measure()) {
intervalRef.current = setInterval(measure, POLL_RATE);
}
});
}
});
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
setElement(targetElement);
if (!targetElement) {
setIndicatorPosition(NULL_ELEMENT_OFFSET_RECT);
}
}, [setElement, targetElement]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
measure();
}, deps);
return indicatorPosition;
}
;// ./node_modules/@wordpress/components/build-module/utils/hooks/use-on-value-update.js
function useOnValueUpdate(value, onUpdate) {
const previousValueRef = (0,external_wp_element_namespaceObject.useRef)(value);
const updateCallbackEvent = (0,external_wp_compose_namespaceObject.useEvent)(onUpdate);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (previousValueRef.current !== value) {
updateCallbackEvent({
previousValue: previousValueRef.current
});
previousValueRef.current = value;
}
}, [updateCallbackEvent, value]);
}
;// ./node_modules/@wordpress/components/build-module/utils/hooks/use-animated-offset-rect.js
function useAnimatedOffsetRect(container, rect, {
prefix = "subelement",
dataAttribute = `${prefix}-animated`,
transitionEndFilter = () => true,
roundRect = false
} = {}) {
const setProperties = (0,external_wp_compose_namespaceObject.useEvent)(() => {
Object.keys(rect).forEach((property) => property !== "element" && container?.style.setProperty(`--${prefix}-${property}`, String(roundRect ? Math.floor(rect[property]) : rect[property])));
});
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
setProperties();
}, [rect, setProperties]);
useOnValueUpdate(rect.element, ({
previousValue
}) => {
if (rect.element && previousValue) {
container?.setAttribute(`data-${dataAttribute}`, "");
}
});
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
function onTransitionEnd(event) {
if (transitionEndFilter(event)) {
container?.removeAttribute(`data-${dataAttribute}`);
}
}
container?.addEventListener("transitionend", onTransitionEnd);
return () => container?.removeEventListener("transitionend", onTransitionEnd);
}, [dataAttribute, container, transitionEndFilter]);
}
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control/component.js
function UnconnectedToggleGroupControl(props, forwardedRef) {
const {
__nextHasNoMarginBottom = false,
__next40pxDefaultSize = false,
__shouldNotWarnDeprecated36pxSize,
className,
isAdaptiveWidth = false,
isBlock = false,
isDeselectable = false,
label,
hideLabelFromVision = false,
help,
onChange,
size = "default",
value,
children,
...otherProps
} = useContextSystem(props, "ToggleGroupControl");
const normalizedSize = __next40pxDefaultSize && size === "default" ? "__unstable-large" : size;
const [selectedElement, setSelectedElement] = (0,external_wp_element_namespaceObject.useState)();
const [controlElement, setControlElement] = (0,external_wp_element_namespaceObject.useState)();
const refs = (0,external_wp_compose_namespaceObject.useMergeRefs)([setControlElement, forwardedRef]);
const selectedRect = useTrackElementOffsetRect(value !== null && value !== void 0 ? selectedElement : void 0);
useAnimatedOffsetRect(controlElement, selectedRect, {
prefix: "selected",
dataAttribute: "indicator-animated",
transitionEndFilter: (event) => event.pseudoElement === "::before",
roundRect: true
});
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(toggleGroupControl({
isBlock,
isDeselectable,
size: normalizedSize
}), isBlock && toggle_group_control_styles_block, className), [className, cx, isBlock, isDeselectable, normalizedSize]);
const MainControl = isDeselectable ? ToggleGroupControlAsButtonGroup : ToggleGroupControlAsRadioGroup;
maybeWarnDeprecated36pxSize({
componentName: "ToggleGroupControl",
size,
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(base_control_default, {
help,
__nextHasNoMarginBottom,
__associatedWPComponentName: "ToggleGroupControl",
children: [!hideLabelFromVision && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(VisualLabelWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default.VisualLabel, {
children: label
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MainControl, {
...otherProps,
setSelectedElement,
className: classes,
isAdaptiveWidth,
label,
onChange,
ref: refs,
size: normalizedSize,
value,
children
})]
});
}
const ToggleGroupControl = contextConnect(UnconnectedToggleGroupControl, "ToggleGroupControl");
var toggle_group_control_component_component_default = ToggleGroupControl;
;// ./node_modules/@ariakit/react-core/esm/__chunks/NLEBE274.js
"use client";
// src/radio/radio.tsx
var NLEBE274_TagName = "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(_a) {
var _b = _a, {
store,
name,
value,
checked
} = _b, props = __objRest(_b, [
"store",
"name",
"value",
"checked"
]);
const context = useRadioContext();
store = store || context;
const id = useId(props.id);
const ref = (0,external_React_.useRef)(null);
const isChecked = useStoreState(
store,
(state) => checked != null ? checked : getIsChecked(value, state == null ? void 0 : state.value)
);
(0,external_React_.useEffect)(() => {
if (!id) return;
if (!isChecked) return;
const isActiveItem = (store == null ? void 0 : store.getState().activeId) === id;
if (isActiveItem) return;
store == null ? void 0 : store.setActiveId(id);
}, [store, isChecked, id]);
const onChangeProp = props.onChange;
const tagName = useTagName(ref, NLEBE274_TagName);
const nativeRadio = isNativeRadio(tagName, props.type);
const disabled = disabledFromProps(props);
const [propertyUpdated, schedulePropertyUpdate] = useForceUpdate();
(0,external_React_.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 (id && activeId !== id) return;
onChange(event);
});
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
role: !nativeRadio ? "radio" : void 0,
type: nativeRadio ? "radio" : void 0,
"aria-checked": isChecked
}, props), {
ref: useMergeRefs(ref, props.ref),
onChange,
onClick,
onFocus
});
props = useCompositeItem(_3YLGPPWQ_spreadValues({
store,
clickOnEnter: !nativeRadio
}, props));
return removeUndefinedValues(_3YLGPPWQ_spreadValues({
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 LMDWO4NN_createElement(NLEBE274_TagName, htmlProps);
})
);
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control-option-base/styles.js
function toggle_group_control_option_base_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const LabelView = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "et6ln9s1"
} : 0)( true ? {
name: "sln1fl",
styles: "display:inline-flex;max-width:100%;min-width:0;position:relative"
} : 0);
const labelBlock = true ? {
name: "82a6rk",
styles: "flex:1"
} : 0;
const buttonView = ({
isDeselectable,
isIcon,
isPressed,
size
}) => /* @__PURE__ */ emotion_react_browser_esm_css("align-items:center;appearance:none;background:transparent;border:none;border-radius:", config_values_default.radiusXSmall, ";color:", COLORS.theme.gray[700], ";fill:currentColor;cursor:pointer;display:flex;font-family:inherit;height:100%;justify-content:center;line-height:100%;outline:none;padding:0 12px;position:relative;text-align:center;@media not ( prefers-reduced-motion ){transition:background ", config_values_default.transitionDurationFast, " linear,color ", config_values_default.transitionDurationFast, " linear,font-weight 60ms linear;}user-select:none;width:100%;z-index:2;&::-moz-focus-inner{border:0;}&[disabled]{opacity:0.4;cursor:default;}&:active{background:", COLORS.ui.background, ";}", isDeselectable && deselectable, " ", isIcon && isIconStyles({
size
}), " ", isPressed && pressed, ";" + ( true ? "" : 0), true ? "" : 0);
const pressed = /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.theme.foregroundInverted, ";&:active{background:transparent;}" + ( true ? "" : 0), true ? "" : 0);
const deselectable = /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.theme.foreground, ";&:focus{box-shadow:inset 0 0 0 1px ", COLORS.ui.background, ",0 0 0 ", config_values_default.borderWidthFocus, " ", COLORS.theme.accent, ";outline:2px solid transparent;}" + ( true ? "" : 0), true ? "" : 0);
const ButtonContentView = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "et6ln9s0"
} : 0)("display:flex;font-size:", config_values_default.fontSize, ";line-height:1;" + ( true ? "" : 0));
const isIconStyles = ({
size = "default"
}) => {
const iconButtonSizes = {
default: "30px",
"__unstable-large": "32px"
};
return /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.theme.foreground, ";height:", iconButtonSizes[size], ";aspect-ratio:1;padding-left:0;padding-right:0;" + ( true ? "" : 0), true ? "" : 0);
};
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control-option-base/component.js
const {
/* ButtonContentView */ "Rp": component_ButtonContentView,
/* LabelView */ "y0": component_LabelView
} = toggle_group_control_option_base_styles_namespaceObject;
const WithToolTip = ({
showTooltip,
text,
children
}) => {
if (showTooltip && text) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tooltip_default, {
text,
placement: "top",
children
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children
});
};
function ToggleGroupControlOptionBase(props, forwardedRef) {
const toggleGroupControlContext = useToggleGroupControlContext();
const id = (0,external_wp_compose_namespaceObject.useInstanceId)(ToggleGroupControlOptionBase, toggleGroupControlContext.baseId || "toggle-group-control-option-base");
const buttonProps = useContextSystem({
...props,
id
}, "ToggleGroupControlOptionBase");
const {
isBlock = false,
isDeselectable = false,
size = "default"
} = toggleGroupControlContext;
const {
className,
isIcon = false,
value,
children,
showTooltip = false,
disabled,
...otherButtonProps
} = buttonProps;
const isPressed = toggleGroupControlContext.value === value;
const cx = useCx();
const labelViewClasses = (0,external_wp_element_namespaceObject.useMemo)(() => cx(isBlock && labelBlock), [cx, isBlock]);
const itemClasses = (0,external_wp_element_namespaceObject.useMemo)(() => cx(buttonView({
isDeselectable,
isIcon,
isPressed,
size
}), className), [cx, isDeselectable, isIcon, isPressed, size, className]);
const buttonOnClick = () => {
if (isDeselectable && isPressed) {
toggleGroupControlContext.setValue(void 0);
} else {
toggleGroupControlContext.setValue(value);
}
};
const commonProps = {
...otherButtonProps,
className: itemClasses,
"data-value": value,
ref: forwardedRef
};
const labelRef = (0,external_wp_element_namespaceObject.useRef)(null);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (isPressed && labelRef.current) {
toggleGroupControlContext.setSelectedElement(labelRef.current);
}
}, [isPressed, toggleGroupControlContext]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_LabelView, {
ref: labelRef,
className: labelViewClasses,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WithToolTip, {
showTooltip,
text: otherButtonProps["aria-label"],
children: isDeselectable ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("button", {
...commonProps,
disabled,
"aria-pressed": isPressed,
type: "button",
onClick: buttonOnClick,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_ButtonContentView, {
children
})
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Radio, {
disabled,
onFocusVisible: () => {
const selectedValueIsEmpty = toggleGroupControlContext.value === null || toggleGroupControlContext.value === "";
if (!selectedValueIsEmpty || toggleGroupControlContext.activeItemIsNotFirstItem?.()) {
toggleGroupControlContext.setValue(value);
}
},
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("button", {
type: "button",
...commonProps
}),
value,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_ButtonContentView, {
children
})
})
})
});
}
const ConnectedToggleGroupControlOptionBase = contextConnect(ToggleGroupControlOptionBase, "ToggleGroupControlOptionBase");
var toggle_group_control_option_base_component_component_default = ConnectedToggleGroupControlOptionBase;
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control-option-icon/component.js
function UnforwardedToggleGroupControlOptionIcon(props, ref) {
const {
icon,
label,
...restProps
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_option_base_component_component_default, {
...restProps,
isIcon: true,
"aria-label": label,
showTooltip: true,
ref,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon
})
});
}
const ToggleGroupControlOptionIcon = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToggleGroupControlOptionIcon);
var toggle_group_control_option_icon_component_component_default = ToggleGroupControlOptionIcon;
;// ./node_modules/@wordpress/components/build-module/border-control/border-control-style-picker/component.js
const BORDER_STYLES = [{
label: (0,external_wp_i18n_namespaceObject.__)("Solid"),
icon: line_solid_default,
value: "solid"
}, {
label: (0,external_wp_i18n_namespaceObject.__)("Dashed"),
icon: line_dashed_default,
value: "dashed"
}, {
label: (0,external_wp_i18n_namespaceObject.__)("Dotted"),
icon: line_dotted_default,
value: "dotted"
}];
function UnconnectedBorderControlStylePicker({
onChange,
...restProps
}, forwardedRef) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_component_component_default, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize: true,
ref: forwardedRef,
isDeselectable: true,
onChange: (value) => {
onChange?.(value);
},
...restProps,
children: BORDER_STYLES.map((borderStyle) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_option_icon_component_component_default, {
value: borderStyle.value,
icon: borderStyle.icon,
label: borderStyle.label
}, borderStyle.value))
});
}
const BorderControlStylePicker = contextConnect(UnconnectedBorderControlStylePicker, "BorderControlStylePicker");
var border_control_style_picker_component_component_default = BorderControlStylePicker;
;// ./node_modules/@wordpress/components/build-module/color-indicator/index.js
function UnforwardedColorIndicator(props, forwardedRef) {
const {
className,
colorValue,
...additionalProps
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: dist_clsx("component-color-indicator", className),
style: {
background: colorValue
},
ref: forwardedRef,
...additionalProps
});
}
const ColorIndicator = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedColorIndicator);
var color_indicator_default = ColorIndicator;
;// ./node_modules/colord/plugins/a11y.mjs
var a11y_o=function(o){var t=o/255;return t<.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)},a11y_t=function(t){return.2126*a11y_o(t.r)+.7152*a11y_o(t.g)+.0722*a11y_o(t.b)};/* harmony default export */ function a11y(o){o.prototype.luminance=function(){return o=a11y_t(this.rgba),void 0===(r=2)&&(r=0),void 0===n&&(n=Math.pow(10,r)),Math.round(n*o)/n+0;var o,r,n},o.prototype.contrast=function(r){void 0===r&&(r="#FFF");var n,a,i,e,v,u,d,c=r instanceof o?r:new o(r);return e=this.rgba,v=c.toRgb(),u=a11y_t(e),d=a11y_t(v),n=u>d?(u+.05)/(d+.05):(d+.05)/(u+.05),void 0===(a=2)&&(a=0),void 0===i&&(i=Math.pow(10,a)),Math.floor(i*n)/i+0},o.prototype.isReadable=function(o,t){return void 0===o&&(o="#FFF"),void 0===t&&(t={}),this.contrast(o)>=(e=void 0===(i=(r=t).size)?"normal":i,"AAA"===(a=void 0===(n=r.level)?"AA":n)&&"normal"===e?7:"AA"===a&&"large"===e?3:4.5);var r,n,a,i,e}}
;// ./node_modules/@wordpress/components/build-module/dropdown/index.js
const UnconnectedDropdown = (props, forwardedRef) => {
const {
renderContent,
renderToggle,
className,
contentClassName,
expandOnMobile,
headerTitle,
focusOnMount,
popoverProps,
onClose,
onToggle,
style,
open,
defaultOpen,
// Deprecated props
position,
// From context system
variant
} = useContextSystem(props, "Dropdown");
if (position !== void 0) {
external_wp_deprecated_default()("`position` prop in wp.components.Dropdown", {
since: "6.2",
alternative: "`popoverProps.placement` prop",
hint: "Note that the `position` prop will override any values passed through the `popoverProps.placement` prop."
});
}
const [fallbackPopoverAnchor, setFallbackPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
const containerRef = (0,external_wp_element_namespaceObject.useRef)();
const [isOpen, setIsOpen] = useControlledValue({
defaultValue: defaultOpen,
value: open,
onChange: onToggle
});
function closeIfFocusOutside() {
if (!containerRef.current) {
return;
}
const {
ownerDocument
} = containerRef.current;
const dialog = ownerDocument?.activeElement?.closest('[role="dialog"]');
if (!containerRef.current.contains(ownerDocument.activeElement) && (!dialog || dialog.contains(containerRef.current))) {
close();
}
}
function close() {
onClose?.();
setIsOpen(false);
}
const args = {
isOpen: !!isOpen,
onToggle: () => setIsOpen(!isOpen),
onClose: close
};
const popoverPropsHaveAnchor = !!popoverProps?.anchor || // Note: `anchorRef`, `getAnchorRect` and `anchorRect` are deprecated and
// be removed from `Popover` from WordPress 6.3
!!popoverProps?.anchorRef || !!popoverProps?.getAnchorRect || !!popoverProps?.anchorRect;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className,
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([containerRef, forwardedRef, setFallbackPopoverAnchor]),
tabIndex: -1,
style,
children: [renderToggle(args), isOpen && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(popover_default, {
position,
onClose: close,
onFocusOutside: closeIfFocusOutside,
expandOnMobile,
headerTitle,
focusOnMount,
offset: 13,
anchor: !popoverPropsHaveAnchor ? fallbackPopoverAnchor : void 0,
variant,
...popoverProps,
className: dist_clsx("components-dropdown__content", popoverProps?.className, contentClassName),
children: renderContent(args)
})]
});
};
const Dropdown = contextConnect(UnconnectedDropdown, "Dropdown");
var dropdown_default = Dropdown;
;// ./node_modules/@wordpress/components/build-module/input-control/input-suffix-wrapper.js
function UnconnectedInputControlSuffixWrapper(props, forwardedRef) {
const derivedProps = useContextSystem(props, "InputControlSuffixWrapper");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PrefixSuffixWrapper, {
...derivedProps,
ref: forwardedRef
});
}
const InputControlSuffixWrapper = contextConnect(UnconnectedInputControlSuffixWrapper, "InputControlSuffixWrapper");
var input_suffix_wrapper_default = InputControlSuffixWrapper;
;// ./node_modules/@wordpress/components/build-module/select-control/styles/select-control-styles.js
function select_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const select_control_styles_disabledStyles = ({
disabled
}) => {
if (!disabled) {
return "";
}
return /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.ui.textDisabled, ";cursor:default;" + ( true ? "" : 0), true ? "" : 0);
};
var select_control_styles_ref2 = true ? {
name: "1lv1yo7",
styles: "display:inline-flex"
} : 0;
const inputBaseVariantStyles = ({
variant
}) => {
if (variant === "minimal") {
return select_control_styles_ref2;
}
return "";
};
const StyledInputBase = /* @__PURE__ */ emotion_styled_base_browser_esm(input_base_default, true ? {
target: "e1mv6sxx3"
} : 0)("color:", COLORS.theme.foreground, ";cursor:pointer;", select_control_styles_disabledStyles, " ", inputBaseVariantStyles, ";" + ( true ? "" : 0));
const select_control_styles_sizeStyles = ({
__next40pxDefaultSize,
multiple,
selectSize = "default"
}) => {
if (multiple) {
return;
}
const sizes = {
default: {
height: 40,
minHeight: 40,
paddingTop: 0,
paddingBottom: 0
},
small: {
height: 24,
minHeight: 24,
paddingTop: 0,
paddingBottom: 0
},
compact: {
height: 32,
minHeight: 32,
paddingTop: 0,
paddingBottom: 0
},
"__unstable-large": {
height: 40,
minHeight: 40,
paddingTop: 0,
paddingBottom: 0
}
};
if (!__next40pxDefaultSize) {
sizes.default = sizes.compact;
}
const style = sizes[selectSize] || sizes.default;
return /* @__PURE__ */ emotion_react_browser_esm_css(style, true ? "" : 0, true ? "" : 0);
};
const chevronIconSize = 18;
const sizePaddings = ({
__next40pxDefaultSize,
multiple,
selectSize = "default"
}) => {
const padding = {
default: config_values_default.controlPaddingX,
small: config_values_default.controlPaddingXSmall,
compact: config_values_default.controlPaddingXSmall,
"__unstable-large": config_values_default.controlPaddingX
};
if (!__next40pxDefaultSize) {
padding.default = padding.compact;
}
const selectedPadding = padding[selectSize] || padding.default;
return rtl({
paddingLeft: selectedPadding,
paddingRight: selectedPadding + chevronIconSize,
...multiple ? {
paddingTop: selectedPadding,
paddingBottom: selectedPadding
} : {}
});
};
const overflowStyles = ({
multiple
}) => {
return {
overflow: multiple ? "auto" : "hidden"
};
};
var select_control_styles_ref = true ? {
name: "n1jncc",
styles: "field-sizing:content"
} : 0;
const variantStyles = ({
variant
}) => {
if (variant === "minimal") {
return select_control_styles_ref;
}
return "";
};
const Select = /* @__PURE__ */ emotion_styled_base_browser_esm("select", true ? {
target: "e1mv6sxx2"
} : 0)("&&&{appearance:none;background:transparent;box-sizing:border-box;border:none;box-shadow:none!important;color:currentColor;cursor:inherit;display:block;font-family:inherit;margin:0;width:100%;max-width:none;white-space:nowrap;text-overflow:ellipsis;", fontSizeStyles, ";", select_control_styles_sizeStyles, ";", sizePaddings, ";", overflowStyles, " ", variantStyles, ";}" + ( true ? "" : 0));
const DownArrowWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1mv6sxx1"
} : 0)("margin-inline-end:", space(-1), ";line-height:0;path{fill:currentColor;}" + ( true ? "" : 0));
const InputControlSuffixWrapperWithClickThrough = /* @__PURE__ */ emotion_styled_base_browser_esm(input_suffix_wrapper_default, true ? {
target: "e1mv6sxx0"
} : 0)("position:absolute;pointer-events:none;", rtl({
right: 0
}), ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/icons/build-module/icon/index.js
var build_module_icon_icon_default = (0,external_wp_element_namespaceObject.forwardRef)(
({ icon, size = 24, ...props }, ref) => {
return (0,external_wp_element_namespaceObject.cloneElement)(icon, {
width: size,
height: size,
...props,
ref
});
}
);
;// ./node_modules/@wordpress/icons/build-module/library/chevron-down.js
var chevron_down_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M17.5 11.6L12 16l-5.5-4.4.9-1.2L12 14l4.5-3.6 1 1.2z" }) });
;// ./node_modules/@wordpress/components/build-module/select-control/chevron-down.js
const SelectControlChevronDown = () => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputControlSuffixWrapperWithClickThrough, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DownArrowWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: chevron_down_default,
size: chevronIconSize
})
})
});
};
var chevron_down_chevron_down_default = SelectControlChevronDown;
;// ./node_modules/@wordpress/components/build-module/select-control/index.js
function select_control_useUniqueId(idProp) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(SelectControl);
const id = `inspector-select-control-${instanceId}`;
return idProp || id;
}
function SelectOptions({
options
}) {
return options.map(({
id,
label,
value,
...optionProps
}, index) => {
const key = id || `${label}-${value}-${index}`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("option", {
value,
...optionProps,
children: label
}, key);
});
}
function UnforwardedSelectControl(props, ref) {
const {
className,
disabled = false,
help,
hideLabelFromVision,
id: idProp,
label,
multiple = false,
onChange,
options = [],
size = "default",
value: valueProp,
labelPosition = "top",
children,
prefix,
suffix,
variant = "default",
__next40pxDefaultSize = false,
__nextHasNoMarginBottom = false,
__shouldNotWarnDeprecated36pxSize,
...restProps
} = useDeprecated36pxDefaultSizeProp(props);
const id = select_control_useUniqueId(idProp);
const helpId = help ? `${id}__help` : void 0;
if (!options?.length && !children) {
return null;
}
const handleOnChange = (event) => {
if (props.multiple) {
const selectedOptions = Array.from(event.target.options).filter(({
selected
}) => selected);
const newValues = selectedOptions.map(({
value
}) => value);
props.onChange?.(newValues, {
event
});
return;
}
props.onChange?.(event.target.value, {
event
});
};
const classes = dist_clsx("components-select-control", className);
maybeWarnDeprecated36pxSize({
componentName: "SelectControl",
__next40pxDefaultSize,
size,
__shouldNotWarnDeprecated36pxSize
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
help,
id,
className: classes,
__nextHasNoMarginBottom,
__associatedWPComponentName: "SelectControl",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledInputBase, {
disabled,
hideLabelFromVision,
id,
isBorderless: variant === "minimal",
label,
size,
suffix: suffix || !multiple && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(chevron_down_chevron_down_default, {}),
prefix,
labelPosition,
__unstableInputWidth: variant === "minimal" ? "auto" : void 0,
variant,
__next40pxDefaultSize,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Select, {
...restProps,
__next40pxDefaultSize,
"aria-describedby": helpId,
className: "components-select-control__input",
disabled,
id,
multiple,
onChange: handleOnChange,
ref,
selectSize: size,
value: valueProp,
variant,
children: children || /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectOptions, {
options
})
})
})
});
}
const SelectControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedSelectControl);
var select_control_default = SelectControl;
;// ./node_modules/@wordpress/components/build-module/utils/hooks/use-controlled-state.js
const defaultOptions = {
initial: void 0,
/**
* Defaults to empty string, as that is preferred for usage with
* <input />, <textarea />, and <select /> form elements.
*/
fallback: ""
};
function useControlledState(currentState, options = defaultOptions) {
const {
initial,
fallback
} = {
...defaultOptions,
...options
};
const [internalState, setInternalState] = (0,external_wp_element_namespaceObject.useState)(currentState);
const hasCurrentState = isValueDefined(currentState);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (hasCurrentState && internalState) {
setInternalState(void 0);
}
}, [hasCurrentState, internalState]);
const state = getDefinedValue([currentState, internalState, initial], fallback);
const setState = (0,external_wp_element_namespaceObject.useCallback)((nextState) => {
if (!hasCurrentState) {
setInternalState(nextState);
}
}, [hasCurrentState]);
return [state, setState];
}
var use_controlled_state_default = useControlledState;
;// ./node_modules/@wordpress/components/build-module/range-control/utils.js
function floatClamp(value, min, max) {
if (typeof value !== "number") {
return null;
}
return parseFloat(`${math_clamp(value, min, max)}`);
}
function useControlledRangeValue(settings) {
const {
min,
max,
value: valueProp,
initial
} = settings;
const [state, setInternalState] = use_controlled_state_default(floatClamp(valueProp, min, max), {
initial: floatClamp(initial !== null && initial !== void 0 ? initial : null, min, max),
fallback: null
});
const setState = (0,external_wp_element_namespaceObject.useCallback)((nextValue) => {
if (nextValue === null) {
setInternalState(null);
} else {
setInternalState(floatClamp(nextValue, min, max));
}
}, [min, max, setInternalState]);
return [state, setState];
}
;// ./node_modules/@wordpress/components/build-module/range-control/styles/range-control-styles.js
function range_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const rangeHeightValue = 30;
const railHeight = 4;
const rangeHeight = () => /* @__PURE__ */ emotion_react_browser_esm_css({
height: rangeHeightValue,
minHeight: rangeHeightValue
}, true ? "" : 0, true ? "" : 0);
const thumbSize = 12;
const deprecatedHeight = ({
__next40pxDefaultSize
}) => !__next40pxDefaultSize && /* @__PURE__ */ emotion_react_browser_esm_css({
minHeight: rangeHeightValue
}, true ? "" : 0, true ? "" : 0);
const range_control_styles_Root = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1epgpqk14"
} : 0)("-webkit-tap-highlight-color:transparent;align-items:center;display:flex;justify-content:flex-start;padding:0;position:relative;touch-action:none;width:100%;min-height:40px;", deprecatedHeight, ";" + ( true ? "" : 0));
const wrapperColor = ({
color = COLORS.ui.borderFocus
}) => /* @__PURE__ */ emotion_react_browser_esm_css({
color
}, true ? "" : 0, true ? "" : 0);
const wrapperMargin = ({
marks,
__nextHasNoMarginBottom
}) => {
if (!__nextHasNoMarginBottom) {
return /* @__PURE__ */ emotion_react_browser_esm_css({
marginBottom: marks ? 16 : void 0
}, true ? "" : 0, true ? "" : 0);
}
return "";
};
const range_control_styles_Wrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
shouldForwardProp: (prop) => !["color", "__nextHasNoMarginBottom", "marks"].includes(prop),
target: "e1epgpqk13"
} : 0)("display:block;flex:1;position:relative;width:100%;", wrapperColor, ";", rangeHeight, ";", wrapperMargin, ";" + ( true ? "" : 0));
const BeforeIconWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk12"
} : 0)("display:flex;margin-top:", railHeight, "px;", rtl({
marginRight: 6
}), ";" + ( true ? "" : 0));
const AfterIconWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk11"
} : 0)("display:flex;margin-top:", railHeight, "px;", rtl({
marginLeft: 6
}), ";" + ( true ? "" : 0));
const railBackgroundColor = ({
disabled,
railColor
}) => {
let background = railColor || "";
if (disabled) {
background = COLORS.ui.backgroundDisabled;
}
return /* @__PURE__ */ emotion_react_browser_esm_css({
background
}, true ? "" : 0, true ? "" : 0);
};
const Rail = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk10"
} : 0)("background-color:", COLORS.gray[300], ";left:0;pointer-events:none;right:0;display:block;height:", railHeight, "px;position:absolute;margin-top:", (rangeHeightValue - railHeight) / 2, "px;top:0;border-radius:", config_values_default.radiusFull, ";", railBackgroundColor, ";" + ( true ? "" : 0));
const trackBackgroundColor = ({
disabled,
trackColor
}) => {
let background = trackColor || "currentColor";
if (disabled) {
background = COLORS.gray[400];
}
return /* @__PURE__ */ emotion_react_browser_esm_css({
background
}, true ? "" : 0, true ? "" : 0);
};
const Track = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk9"
} : 0)("background-color:currentColor;border-radius:", config_values_default.radiusFull, ";height:", railHeight, "px;pointer-events:none;display:block;position:absolute;margin-top:", (rangeHeightValue - railHeight) / 2, "px;top:0;.is-marked &{@media not ( prefers-reduced-motion ){transition:width ease 0.1s;}}", trackBackgroundColor, ";" + ( true ? "" : 0));
const MarksWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk8"
} : 0)( true ? {
name: "g5kg28",
styles: "display:block;pointer-events:none;position:relative;width:100%;user-select:none;margin-top:17px"
} : 0);
const Mark = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk7"
} : 0)("position:absolute;left:0;top:-4px;height:4px;width:2px;transform:translateX( -50% );background-color:", COLORS.ui.background, ";z-index:1;" + ( true ? "" : 0));
const markLabelFill = ({
isFilled
}) => {
return /* @__PURE__ */ emotion_react_browser_esm_css({
color: isFilled ? COLORS.gray[700] : COLORS.gray[300]
}, true ? "" : 0, true ? "" : 0);
};
const MarkLabel = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk6"
} : 0)("color:", COLORS.gray[300], ";font-size:11px;position:absolute;top:8px;white-space:nowrap;", rtl({
left: 0
}), ";", rtl({
transform: "translateX( -50% )"
}, {
transform: "translateX( 50% )"
}), ";", markLabelFill, ";" + ( true ? "" : 0));
const thumbColor = ({
disabled
}) => disabled ? /* @__PURE__ */ emotion_react_browser_esm_css("background-color:", COLORS.gray[400], ";" + ( true ? "" : 0), true ? "" : 0) : /* @__PURE__ */ emotion_react_browser_esm_css("background-color:", COLORS.theme.accent, ";" + ( true ? "" : 0), true ? "" : 0);
const ThumbWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk5"
} : 0)("align-items:center;display:flex;height:", thumbSize, "px;justify-content:center;margin-top:", (rangeHeightValue - thumbSize) / 2, "px;outline:0;pointer-events:none;position:absolute;top:0;user-select:none;width:", thumbSize, "px;border-radius:", config_values_default.radiusRound, ";z-index:3;.is-marked &{@media not ( prefers-reduced-motion ){transition:left ease 0.1s;}}", thumbColor, ";", rtl({
marginLeft: -10
}), ";", rtl({
transform: "translateX( 4.5px )"
}, {
transform: "translateX( -4.5px )"
}), ";" + ( true ? "" : 0));
const thumbFocus = ({
isFocused
}) => {
return isFocused ? /* @__PURE__ */ emotion_react_browser_esm_css("&::before{content:' ';position:absolute;background-color:", COLORS.theme.accent, ";opacity:0.4;border-radius:", config_values_default.radiusRound, ";height:", thumbSize + 8, "px;width:", thumbSize + 8, "px;top:-4px;left:-4px;}" + ( true ? "" : 0), true ? "" : 0) : "";
};
const Thumb = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk4"
} : 0)("align-items:center;border-radius:", config_values_default.radiusRound, ";height:100%;outline:0;position:absolute;user-select:none;width:100%;box-shadow:", config_values_default.elevationXSmall, ";", thumbColor, ";", thumbFocus, ";" + ( true ? "" : 0));
const InputRange = /* @__PURE__ */ emotion_styled_base_browser_esm("input", true ? {
target: "e1epgpqk3"
} : 0)("box-sizing:border-box;cursor:pointer;display:block;height:100%;left:0;margin:0 -", thumbSize / 2, "px;opacity:0;outline:none;position:absolute;right:0;top:0;width:calc( 100% + ", thumbSize, "px );" + ( true ? "" : 0));
const tooltipShow = ({
show
}) => {
return /* @__PURE__ */ emotion_react_browser_esm_css("display:", show ? "inline-block" : "none", ";opacity:", show ? 1 : 0, ";@media not ( prefers-reduced-motion ){transition:opacity 120ms ease,display 120ms ease allow-discrete;}@starting-style{opacity:0;}" + ( true ? "" : 0), true ? "" : 0);
};
var range_control_styles_ref = true ? {
name: "1cypxip",
styles: "top:-80%"
} : 0;
var range_control_styles_ref2 = true ? {
name: "1lr98c4",
styles: "bottom:-80%"
} : 0;
const tooltipPlacement = ({
placement
}) => {
const isBottom = placement === "bottom";
if (isBottom) {
return range_control_styles_ref2;
}
return range_control_styles_ref;
};
const range_control_styles_Tooltip = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk2"
} : 0)("background:rgba( 0, 0, 0, 0.8 );border-radius:", config_values_default.radiusSmall, ";color:white;font-size:12px;min-width:32px;padding:4px 8px;pointer-events:none;position:absolute;text-align:center;user-select:none;line-height:1.4;", tooltipShow, ";", tooltipPlacement, ";", rtl({
transform: "translateX(-50%)"
}, {
transform: "translateX(50%)"
}), ";" + ( true ? "" : 0));
const InputNumber = /* @__PURE__ */ emotion_styled_base_browser_esm(number_control_default, true ? {
target: "e1epgpqk1"
} : 0)("display:inline-block;font-size:13px;margin-top:0;input[type='number']&{", rangeHeight, ";}", rtl({
marginLeft: `${space(4)} !important`
}), ";" + ( true ? "" : 0));
const ActionRightWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1epgpqk0"
} : 0)("display:block;margin-top:0;button,button.is-small{margin-left:0;", rangeHeight, ";}", rtl({
marginLeft: 8
}), ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/range-control/input-range.js
function input_range_InputRange(props, ref) {
const {
describedBy,
label,
value,
...otherProps
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputRange, {
...otherProps,
"aria-describedby": describedBy,
"aria-label": label,
"aria-hidden": false,
ref,
tabIndex: 0,
type: "range",
value
});
}
const input_range_ForwardedComponent = (0,external_wp_element_namespaceObject.forwardRef)(input_range_InputRange);
var input_range_default = input_range_ForwardedComponent;
;// ./node_modules/@wordpress/components/build-module/range-control/mark.js
function RangeMark(props) {
const {
className,
isFilled = false,
label,
style = {},
...otherProps
} = props;
const classes = dist_clsx("components-range-control__mark", isFilled && "is-filled", className);
const labelClasses = dist_clsx("components-range-control__mark-label", isFilled && "is-filled");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Mark, {
...otherProps,
"aria-hidden": "true",
className: classes,
style
}), label && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MarkLabel, {
"aria-hidden": "true",
className: labelClasses,
isFilled,
style,
children: label
})]
});
}
;// ./node_modules/@wordpress/components/build-module/range-control/rail.js
function RangeRail(props) {
const {
disabled = false,
marks = false,
min = 0,
max = 100,
step = 1,
value = 0,
...restProps
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Rail, {
disabled,
...restProps
}), marks && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Marks, {
disabled,
marks,
min,
max,
step,
value
})]
});
}
function Marks(props) {
const {
disabled = false,
marks = false,
min = 0,
max = 100,
step: stepProp = 1,
value = 0
} = props;
const step = stepProp === "any" ? 1 : stepProp;
const marksData = useMarks({
marks,
min,
max,
step,
value
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MarksWrapper, {
"aria-hidden": "true",
className: "components-range-control__marks",
children: marksData.map((mark) => /* @__PURE__ */ (0,external_React_.createElement)(RangeMark, {
...mark,
key: mark.key,
"aria-hidden": "true",
disabled
}))
});
}
function useMarks({
marks,
min = 0,
max = 100,
step = 1,
value = 0
}) {
if (!marks) {
return [];
}
const range = max - min;
if (!Array.isArray(marks)) {
marks = [];
const count = 1 + Math.round(range / step);
while (count > marks.push({
value: step * marks.length + min
})) {
}
}
const placedMarks = [];
marks.forEach((mark, index) => {
if (mark.value < min || mark.value > max) {
return;
}
const key = `mark-${index}`;
const isFilled = mark.value <= value;
const offset = `${(mark.value - min) / range * 100}%`;
const offsetStyle = {
[(0,external_wp_i18n_namespaceObject.isRTL)() ? "right" : "left"]: offset
};
placedMarks.push({
...mark,
isFilled,
key,
style: offsetStyle
});
});
return placedMarks;
}
;// ./node_modules/@wordpress/components/build-module/range-control/tooltip.js
function SimpleTooltip(props) {
const {
className,
inputRef,
tooltipPlacement,
show = false,
style = {},
value = 0,
renderTooltipContent = (v) => v,
zIndex = 100,
...restProps
} = props;
const placement = useTooltipPlacement({
inputRef,
tooltipPlacement
});
const classes = dist_clsx("components-simple-tooltip", className);
const styles = {
...style,
zIndex
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(range_control_styles_Tooltip, {
...restProps,
"aria-hidden": "false",
className: classes,
placement,
show,
role: "tooltip",
style: styles,
children: renderTooltipContent(value)
});
}
function useTooltipPlacement({
inputRef,
tooltipPlacement
}) {
const [placement, setPlacement] = (0,external_wp_element_namespaceObject.useState)();
const setTooltipPlacement = (0,external_wp_element_namespaceObject.useCallback)(() => {
if (inputRef && inputRef.current) {
setPlacement(tooltipPlacement);
}
}, [tooltipPlacement, inputRef]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
setTooltipPlacement();
}, [setTooltipPlacement]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
window.addEventListener("resize", setTooltipPlacement);
return () => {
window.removeEventListener("resize", setTooltipPlacement);
};
});
return placement;
}
;// ./node_modules/@wordpress/components/build-module/range-control/index.js
const range_control_noop = () => {
};
function computeResetValue({
resetFallbackValue,
initialPosition
}) {
if (resetFallbackValue !== void 0) {
return !Number.isNaN(resetFallbackValue) ? resetFallbackValue : null;
}
if (initialPosition !== void 0) {
return !Number.isNaN(initialPosition) ? initialPosition : null;
}
return null;
}
function UnforwardedRangeControl(props, forwardedRef) {
const {
__nextHasNoMarginBottom = false,
afterIcon,
allowReset = false,
beforeIcon,
className,
color: colorProp = COLORS.theme.accent,
currentInput,
disabled = false,
help,
hideLabelFromVision = false,
initialPosition,
isShiftStepEnabled = true,
label,
marks = false,
max = 100,
min = 0,
onBlur = range_control_noop,
onChange = range_control_noop,
onFocus = range_control_noop,
onMouseLeave = range_control_noop,
onMouseMove = range_control_noop,
railColor,
renderTooltipContent = (v) => v,
resetFallbackValue,
__next40pxDefaultSize = false,
shiftStep = 10,
showTooltip: showTooltipProp,
step = 1,
trackColor,
value: valueProp,
withInputField = true,
__shouldNotWarnDeprecated36pxSize,
...otherProps
} = props;
const [value, setValue] = useControlledRangeValue({
min,
max,
value: valueProp !== null && valueProp !== void 0 ? valueProp : null,
initial: initialPosition
});
const isResetPendent = (0,external_wp_element_namespaceObject.useRef)(false);
let hasTooltip = showTooltipProp;
let hasInputField = withInputField;
if (step === "any") {
hasTooltip = false;
hasInputField = false;
}
const [showTooltip, setShowTooltip] = (0,external_wp_element_namespaceObject.useState)(hasTooltip);
const [isFocused, setIsFocused] = (0,external_wp_element_namespaceObject.useState)(false);
const inputRef = (0,external_wp_element_namespaceObject.useRef)();
const isCurrentlyFocused = inputRef.current?.matches(":focus");
const isThumbFocused = !disabled && isFocused;
const isValueReset = value === null;
const currentValue = value !== void 0 ? value : currentInput;
const inputSliderValue = isValueReset ? "" : currentValue;
const rangeFillValue = isValueReset ? (max - min) / 2 + min : value;
const fillValue = isValueReset ? 50 : (value - min) / (max - min) * 100;
const fillValueOffset = `${math_clamp(fillValue, 0, 100)}%`;
const classes = dist_clsx("components-range-control", className);
const wrapperClasses = dist_clsx("components-range-control__wrapper", !!marks && "is-marked");
const id = (0,external_wp_compose_namespaceObject.useInstanceId)(UnforwardedRangeControl, "inspector-range-control");
const describedBy = !!help ? `${id}__help` : void 0;
const enableTooltip = hasTooltip !== false && Number.isFinite(value);
const handleOnRangeChange = (event) => {
const nextValue = parseFloat(event.target.value);
setValue(nextValue);
onChange(nextValue);
};
const handleOnChange = (next) => {
let nextValue = parseFloat(next);
setValue(nextValue);
if (!isNaN(nextValue)) {
if (nextValue < min || nextValue > max) {
nextValue = floatClamp(nextValue, min, max);
}
onChange(nextValue);
isResetPendent.current = false;
} else if (allowReset) {
isResetPendent.current = true;
}
};
const handleOnInputNumberBlur = () => {
if (isResetPendent.current) {
handleOnReset();
isResetPendent.current = false;
}
};
const handleOnReset = () => {
const resetValue = Number.isNaN(resetFallbackValue) ? null : resetFallbackValue !== null && resetFallbackValue !== void 0 ? resetFallbackValue : null;
setValue(resetValue);
onChange(resetValue !== null && resetValue !== void 0 ? resetValue : void 0);
};
const handleShowTooltip = () => setShowTooltip(true);
const handleHideTooltip = () => setShowTooltip(false);
const handleOnBlur = (event) => {
onBlur(event);
setIsFocused(false);
handleHideTooltip();
};
const handleOnFocus = (event) => {
onFocus(event);
setIsFocused(true);
handleShowTooltip();
};
const offsetStyle = {
[(0,external_wp_i18n_namespaceObject.isRTL)() ? "right" : "left"]: fillValueOffset
};
maybeWarnDeprecated36pxSize({
componentName: "RangeControl",
__next40pxDefaultSize,
size: void 0,
__shouldNotWarnDeprecated36pxSize
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
__nextHasNoMarginBottom,
__associatedWPComponentName: "RangeControl",
className: classes,
label,
hideLabelFromVision,
id: `${id}`,
help,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(range_control_styles_Root, {
className: "components-range-control__root",
__next40pxDefaultSize,
children: [beforeIcon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BeforeIconWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon: beforeIcon
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(range_control_styles_Wrapper, {
__nextHasNoMarginBottom,
className: wrapperClasses,
color: colorProp,
marks: !!marks,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(input_range_default, {
...otherProps,
className: "components-range-control__slider",
describedBy,
disabled,
id: `${id}`,
label,
max,
min,
onBlur: handleOnBlur,
onChange: handleOnRangeChange,
onFocus: handleOnFocus,
onMouseMove,
onMouseLeave,
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([inputRef, forwardedRef]),
step,
value: inputSliderValue !== null && inputSliderValue !== void 0 ? inputSliderValue : void 0
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RangeRail, {
"aria-hidden": true,
disabled,
marks,
max,
min,
railColor,
step,
value: rangeFillValue
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Track, {
"aria-hidden": true,
className: "components-range-control__track",
disabled,
style: {
width: fillValueOffset
},
trackColor
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ThumbWrapper, {
className: "components-range-control__thumb-wrapper",
style: offsetStyle,
disabled,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Thumb, {
"aria-hidden": true,
isFocused: isThumbFocused,
disabled
})
}), enableTooltip && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SimpleTooltip, {
className: "components-range-control__tooltip",
inputRef,
tooltipPlacement: "bottom",
renderTooltipContent,
show: isCurrentlyFocused || showTooltip,
style: offsetStyle,
value
})]
}), afterIcon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(AfterIconWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon: afterIcon
})
}), hasInputField && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputNumber, {
"aria-label": label,
className: "components-range-control__number",
disabled,
inputMode: "decimal",
isShiftStepEnabled,
max,
min,
onBlur: handleOnInputNumberBlur,
onChange: handleOnChange,
shiftStep,
size: __next40pxDefaultSize ? "__unstable-large" : "default",
__unstableInputWidth: __next40pxDefaultSize ? space(20) : space(16),
step,
value: inputSliderValue,
__shouldNotWarnDeprecated36pxSize: true
}), allowReset && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ActionRightWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
className: "components-range-control__reset",
accessibleWhenDisabled: !disabled,
disabled: disabled || value === computeResetValue({
resetFallbackValue,
initialPosition
}),
variant: "secondary",
size: "small",
onClick: handleOnReset,
children: (0,external_wp_i18n_namespaceObject.__)("Reset")
})
})]
})
});
}
const RangeControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedRangeControl);
var range_control_default = RangeControl;
;// ./node_modules/@wordpress/components/build-module/color-picker/styles.js
const NumberControlWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(number_control_default, true ? {
target: "ez9hsf46"
} : 0)("width:", space(24), ";" + ( true ? "" : 0));
const styles_SelectControl = /* @__PURE__ */ emotion_styled_base_browser_esm(select_control_default, true ? {
target: "ez9hsf45"
} : 0)("margin-left:", space(-2), ";" + ( true ? "" : 0));
const styles_RangeControl = /* @__PURE__ */ emotion_styled_base_browser_esm(range_control_default, true ? {
target: "ez9hsf44"
} : 0)("flex:1;margin-right:", space(2), ";" + ( true ? "" : 0));
const interactiveHueStyles = `
.react-colorful__interactive {
width: calc( 100% - ${space(2)} );
margin-left: ${space(1)};
}`;
const AuxiliaryColorArtefactWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "ez9hsf43"
} : 0)("padding-top:", space(2), ";padding-right:0;padding-left:0;padding-bottom:0;" + ( true ? "" : 0));
const AuxiliaryColorArtefactHStackHeader = /* @__PURE__ */ emotion_styled_base_browser_esm(h_stack_component_component_default, true ? {
target: "ez9hsf42"
} : 0)("padding-left:", space(4), ";padding-right:", space(4), ";" + ( true ? "" : 0));
const ColorInputWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_component_component_default, true ? {
target: "ez9hsf41"
} : 0)("padding-top:", space(4), ";padding-left:", space(4), ";padding-right:", space(3), ";padding-bottom:", space(5), ";" + ( true ? "" : 0));
const ColorfulWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "ez9hsf40"
} : 0)(boxSizingReset, ";width:216px;.react-colorful{display:flex;flex-direction:column;align-items:center;width:216px;height:auto;}.react-colorful__saturation{width:100%;border-radius:0;height:216px;margin-bottom:", space(4), ";border-bottom:none;}.react-colorful__hue,.react-colorful__alpha{width:184px;height:16px;border-radius:", config_values_default.radiusFull, ";margin-bottom:", space(2), ";}.react-colorful__pointer{height:16px;width:16px;border:none;box-shadow:0 0 2px 0 rgba( 0, 0, 0, 0.25 );outline:2px solid transparent;@media not ( prefers-reduced-motion ){transition:transform ", config_values_default.transitionDurationFast, " ease-in-out;}}.react-colorful__interactive:focus .react-colorful__pointer{box-shadow:0 0 0 ", config_values_default.borderWidthFocus, " ", config_values_default.surfaceColor, ";border:", config_values_default.borderWidthFocus, " solid black;transform:translate( -50%, -50% ) scale( 1.5 );}.react-colorful__pointer-fill{box-shadow:inset 0 0 0 ", config_values_default.borderWidthFocus, " #fff;}", interactiveHueStyles, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/icons/build-module/library/check.js
var check_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M16.5 7.5 10 13.9l-2.5-2.4-1 1 3.5 3.6 7.5-7.6z" }) });
;// ./node_modules/@wordpress/icons/build-module/library/copy.js
var copy_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
external_wp_primitives_namespaceObject.Path,
{
fillRule: "evenodd",
clipRule: "evenodd",
d: "M5 4.5h11a.5.5 0 0 1 .5.5v11a.5.5 0 0 1-.5.5H5a.5.5 0 0 1-.5-.5V5a.5.5 0 0 1 .5-.5ZM3 5a2 2 0 0 1 2-2h11a2 2 0 0 1 2 2v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5Zm17 3v10.75c0 .69-.56 1.25-1.25 1.25H6v1.5h12.75a2.75 2.75 0 0 0 2.75-2.75V8H20Z"
}
) });
;// ./node_modules/@wordpress/components/build-module/color-picker/color-copy-button.js
const ColorCopyButton = (props) => {
const {
color,
colorType
} = props;
const [copiedColor, setCopiedColor] = (0,external_wp_element_namespaceObject.useState)(null);
const copyTimerRef = (0,external_wp_element_namespaceObject.useRef)();
const copyRef = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(() => {
switch (colorType) {
case "hsl": {
return color.toHslString();
}
case "rgb": {
return color.toRgbString();
}
default:
case "hex": {
return color.toHex();
}
}
}, () => {
if (copyTimerRef.current) {
clearTimeout(copyTimerRef.current);
}
setCopiedColor(color.toHex());
copyTimerRef.current = setTimeout(() => {
setCopiedColor(null);
copyTimerRef.current = void 0;
}, 3e3);
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
return () => {
if (copyTimerRef.current) {
clearTimeout(copyTimerRef.current);
}
};
}, []);
const isCopied = copiedColor === color.toHex();
const label = isCopied ? (0,external_wp_i18n_namespaceObject.__)("Copied!") : (0,external_wp_i18n_namespaceObject.__)("Copy");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tooltip_default, {
delay: 0,
hideOnClick: false,
text: label,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Button, {
size: "compact",
"aria-label": label,
ref: copyRef,
icon: isCopied ? check_default : copy_default,
showTooltip: false
})
});
};
;// ./node_modules/@wordpress/components/build-module/input-control/input-prefix-wrapper.js
function UnconnectedInputControlPrefixWrapper(props, forwardedRef) {
const derivedProps = useContextSystem(props, "InputControlPrefixWrapper");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PrefixSuffixWrapper, {
...derivedProps,
isPrefix: true,
ref: forwardedRef
});
}
const InputControlPrefixWrapper = contextConnect(UnconnectedInputControlPrefixWrapper, "InputControlPrefixWrapper");
var input_prefix_wrapper_default = InputControlPrefixWrapper;
;// ./node_modules/@wordpress/components/build-module/color-picker/input-with-slider.js
const InputWithSlider = ({
min,
max,
label,
abbreviation,
onChange,
value
}) => {
const onNumberControlChange = (newValue) => {
if (!newValue) {
onChange(0);
return;
}
if (typeof newValue === "string") {
onChange(parseInt(newValue, 10));
return;
}
onChange(newValue);
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
spacing: 4,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NumberControlWrapper, {
__next40pxDefaultSize: true,
min,
max,
label,
hideLabelFromVision: true,
value,
onChange: onNumberControlChange,
prefix: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(input_prefix_wrapper_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(text_component_component_default, {
color: COLORS.theme.accent,
lineHeight: 1,
children: abbreviation
})
}),
spinControls: "none"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_RangeControl, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize: true,
label,
hideLabelFromVision: true,
min,
max,
value,
onChange,
withInputField: false
})]
});
};
;// ./node_modules/@wordpress/components/build-module/color-picker/rgb-input.js
const RgbInput = ({
color,
onChange,
enableAlpha
}) => {
const {
r,
g,
b,
a
} = color.toRgb();
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 255,
label: "Red",
abbreviation: "R",
value: r,
onChange: (nextR) => onChange(w({
r: nextR,
g,
b,
a
}))
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 255,
label: "Green",
abbreviation: "G",
value: g,
onChange: (nextG) => onChange(w({
r,
g: nextG,
b,
a
}))
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 255,
label: "Blue",
abbreviation: "B",
value: b,
onChange: (nextB) => onChange(w({
r,
g,
b: nextB,
a
}))
}), enableAlpha && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 100,
label: "Alpha",
abbreviation: "A",
value: Math.trunc(a * 100),
onChange: (nextA) => onChange(w({
r,
g,
b,
a: nextA / 100
}))
})]
});
};
;// ./node_modules/@wordpress/components/build-module/color-picker/hsl-input.js
const HslInput = ({
color,
onChange,
enableAlpha
}) => {
const colorPropHSLA = (0,external_wp_element_namespaceObject.useMemo)(() => color.toHsl(), [color]);
const [internalHSLA, setInternalHSLA] = (0,external_wp_element_namespaceObject.useState)({
...colorPropHSLA
});
const isInternalColorSameAsReceivedColor = color.isEqual(w(internalHSLA));
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!isInternalColorSameAsReceivedColor) {
setInternalHSLA(colorPropHSLA);
}
}, [colorPropHSLA, isInternalColorSameAsReceivedColor]);
const colorValue = isInternalColorSameAsReceivedColor ? internalHSLA : colorPropHSLA;
const updateHSLAValue = (partialNewValue) => {
const nextOnChangeValue = w({
...colorValue,
...partialNewValue
});
if (!color.isEqual(nextOnChangeValue)) {
onChange(nextOnChangeValue);
} else {
setInternalHSLA((prevHSLA) => ({
...prevHSLA,
...partialNewValue
}));
}
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 359,
label: "Hue",
abbreviation: "H",
value: colorValue.h,
onChange: (nextH) => {
updateHSLAValue({
h: nextH
});
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 100,
label: "Saturation",
abbreviation: "S",
value: colorValue.s,
onChange: (nextS) => {
updateHSLAValue({
s: nextS
});
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 100,
label: "Lightness",
abbreviation: "L",
value: colorValue.l,
onChange: (nextL) => {
updateHSLAValue({
l: nextL
});
}
}), enableAlpha && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWithSlider, {
min: 0,
max: 100,
label: "Alpha",
abbreviation: "A",
value: Math.trunc(100 * colorValue.a),
onChange: (nextA) => {
updateHSLAValue({
a: nextA / 100
});
}
})]
});
};
;// ./node_modules/@wordpress/components/build-module/color-picker/hex-input.js
const HexInput = ({
color,
onChange,
enableAlpha
}) => {
const handleChange = (nextValue) => {
if (!nextValue) {
return;
}
const hexValue = nextValue.startsWith("#") ? nextValue : "#" + nextValue;
onChange(w(hexValue));
};
const stateReducer = (state, action) => {
const nativeEvent = action.payload?.event?.nativeEvent;
if ("insertFromPaste" !== nativeEvent?.inputType) {
return {
...state
};
}
const value = state.value?.startsWith("#") ? state.value.slice(1).toUpperCase() : state.value?.toUpperCase();
return {
...state,
value
};
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputControl, {
prefix: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(input_prefix_wrapper_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(text_component_component_default, {
color: COLORS.theme.accent,
lineHeight: 1,
children: "#"
})
}),
value: color.toHex().slice(1).toUpperCase(),
onChange: handleChange,
maxLength: enableAlpha ? 9 : 7,
label: (0,external_wp_i18n_namespaceObject.__)("Hex color"),
hideLabelFromVision: true,
size: "__unstable-large",
__unstableStateReducer: stateReducer,
__unstableInputWidth: "9em"
});
};
;// ./node_modules/@wordpress/components/build-module/color-picker/color-input.js
const ColorInput = ({
colorType,
color,
onChange,
enableAlpha
}) => {
const props = {
color,
onChange,
enableAlpha
};
switch (colorType) {
case "hsl":
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(HslInput, {
...props
});
case "rgb":
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RgbInput, {
...props
});
default:
case "hex":
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(HexInput, {
...props
});
}
};
;// ./node_modules/react-colorful/dist/index.mjs
function dist_u(){return(dist_u=Object.assign||function(e){for(var r=1;r<arguments.length;r++){var t=arguments[r];for(var n in t)Object.prototype.hasOwnProperty.call(t,n)&&(e[n]=t[n])}return e}).apply(this,arguments)}function dist_c(e,r){if(null==e)return{};var t,n,o={},a=Object.keys(e);for(n=0;n<a.length;n++)r.indexOf(t=a[n])>=0||(o[t]=e[t]);return o}function dist_i(e){var t=(0,external_React_.useRef)(e),n=(0,external_React_.useRef)(function(e){t.current&&t.current(e)});return t.current=e,n.current}var dist_s=function(e,r,t){return void 0===r&&(r=0),void 0===t&&(t=1),e>t?t:e<r?r:e},dist_f=function(e){return"touches"in e},dist_v=function(e){return e&&e.ownerDocument.defaultView||self},dist_d=function(e,r,t){var n=e.getBoundingClientRect(),o=dist_f(r)?function(e,r){for(var t=0;t<e.length;t++)if(e[t].identifier===r)return e[t];return e[0]}(r.touches,t):r;return{left:dist_s((o.pageX-(n.left+dist_v(e).pageXOffset))/n.width),top:dist_s((o.pageY-(n.top+dist_v(e).pageYOffset))/n.height)}},dist_h=function(e){!dist_f(e)&&e.preventDefault()},dist_m=external_React_.memo(function(o){var a=o.onMove,l=o.onKey,s=dist_c(o,["onMove","onKey"]),m=(0,external_React_.useRef)(null),g=dist_i(a),p=dist_i(l),b=(0,external_React_.useRef)(null),_=(0,external_React_.useRef)(!1),x=(0,external_React_.useMemo)(function(){var e=function(e){dist_h(e),(dist_f(e)?e.touches.length>0:e.buttons>0)&&m.current?g(dist_d(m.current,e,b.current)):t(!1)},r=function(){return t(!1)};function t(t){var n=_.current,o=dist_v(m.current),a=t?o.addEventListener:o.removeEventListener;a(n?"touchmove":"mousemove",e),a(n?"touchend":"mouseup",r)}return[function(e){var r=e.nativeEvent,n=m.current;if(n&&(dist_h(r),!function(e,r){return r&&!dist_f(e)}(r,_.current)&&n)){if(dist_f(r)){_.current=!0;var o=r.changedTouches||[];o.length&&(b.current=o[0].identifier)}n.focus(),g(dist_d(n,r,b.current)),t(!0)}},function(e){var r=e.which||e.keyCode;r<37||r>40||(e.preventDefault(),p({left:39===r?.05:37===r?-.05:0,top:40===r?.05:38===r?-.05:0}))},t]},[p,g]),C=x[0],E=x[1],H=x[2];return (0,external_React_.useEffect)(function(){return H},[H]),external_React_.createElement("div",dist_u({},s,{onTouchStart:C,onMouseDown:C,className:"react-colorful__interactive",ref:m,onKeyDown:E,tabIndex:0,role:"slider"}))}),dist_g=function(e){return e.filter(Boolean).join(" ")},dist_p=function(r){var t=r.color,n=r.left,o=r.top,a=void 0===o?.5:o,l=dist_g(["react-colorful__pointer",r.className]);return external_React_.createElement("div",{className:l,style:{top:100*a+"%",left:100*n+"%"}},external_React_.createElement("div",{className:"react-colorful__pointer-fill",style:{backgroundColor:t}}))},dist_b=function(e,r,t){return void 0===r&&(r=0),void 0===t&&(t=Math.pow(10,r)),Math.round(t*e)/t},_={grad:.9,turn:360,rad:360/(2*Math.PI)},dist_x=function(e){return L(C(e))},C=function(e){return"#"===e[0]&&(e=e.substring(1)),e.length<6?{r:parseInt(e[0]+e[0],16),g:parseInt(e[1]+e[1],16),b:parseInt(e[2]+e[2],16),a:4===e.length?dist_b(parseInt(e[3]+e[3],16)/255,2):1}:{r:parseInt(e.substring(0,2),16),g:parseInt(e.substring(2,4),16),b:parseInt(e.substring(4,6),16),a:8===e.length?dist_b(parseInt(e.substring(6,8),16)/255,2):1}},dist_E=function(e,r){return void 0===r&&(r="deg"),Number(e)*(_[r]||1)},dist_H=function(e){var r=/hsla?\(?\s*(-?\d*\.?\d+)(deg|rad|grad|turn)?[,\s]+(-?\d*\.?\d+)%?[,\s]+(-?\d*\.?\d+)%?,?\s*[/\s]*(-?\d*\.?\d+)?(%)?\s*\)?/i.exec(e);return r?dist_N({h:dist_E(r[1],r[2]),s:Number(r[3]),l:Number(r[4]),a:void 0===r[5]?1:Number(r[5])/(r[6]?100:1)}):{h:0,s:0,v:0,a:1}},dist_M=dist_H,dist_N=function(e){var r=e.s,t=e.l;return{h:e.h,s:(r*=(t<50?t:100-t)/100)>0?2*r/(t+r)*100:0,v:t+r,a:e.a}},dist_w=function(e){return K(dist_I(e))},dist_y=function(e){var r=e.s,t=e.v,n=e.a,o=(200-r)*t/100;return{h:dist_b(e.h),s:dist_b(o>0&&o<200?r*t/100/(o<=100?o:200-o)*100:0),l:dist_b(o/2),a:dist_b(n,2)}},q=function(e){var r=dist_y(e);return"hsl("+r.h+", "+r.s+"%, "+r.l+"%)"},dist_k=function(e){var r=dist_y(e);return"hsla("+r.h+", "+r.s+"%, "+r.l+"%, "+r.a+")"},dist_I=function(e){var r=e.h,t=e.s,n=e.v,o=e.a;r=r/360*6,t/=100,n/=100;var a=Math.floor(r),l=n*(1-t),u=n*(1-(r-a)*t),c=n*(1-(1-r+a)*t),i=a%6;return{r:dist_b(255*[n,u,l,l,c,n][i]),g:dist_b(255*[c,n,n,u,l,l][i]),b:dist_b(255*[l,l,c,n,n,u][i]),a:dist_b(o,2)}},O=function(e){var r=/hsva?\(?\s*(-?\d*\.?\d+)(deg|rad|grad|turn)?[,\s]+(-?\d*\.?\d+)%?[,\s]+(-?\d*\.?\d+)%?,?\s*[/\s]*(-?\d*\.?\d+)?(%)?\s*\)?/i.exec(e);return r?A({h:dist_E(r[1],r[2]),s:Number(r[3]),v:Number(r[4]),a:void 0===r[5]?1:Number(r[5])/(r[6]?100:1)}):{h:0,s:0,v:0,a:1}},dist_j=O,z=function(e){var r=/rgba?\(?\s*(-?\d*\.?\d+)(%)?[,\s]+(-?\d*\.?\d+)(%)?[,\s]+(-?\d*\.?\d+)(%)?,?\s*[/\s]*(-?\d*\.?\d+)?(%)?\s*\)?/i.exec(e);return r?L({r:Number(r[1])/(r[2]?100/255:1),g:Number(r[3])/(r[4]?100/255:1),b:Number(r[5])/(r[6]?100/255:1),a:void 0===r[7]?1:Number(r[7])/(r[8]?100:1)}):{h:0,s:0,v:0,a:1}},B=z,D=function(e){var r=e.toString(16);return r.length<2?"0"+r:r},K=function(e){var r=e.r,t=e.g,n=e.b,o=e.a,a=o<1?D(dist_b(255*o)):"";return"#"+D(r)+D(t)+D(n)+a},L=function(e){var r=e.r,t=e.g,n=e.b,o=e.a,a=Math.max(r,t,n),l=a-Math.min(r,t,n),u=l?a===r?(t-n)/l:a===t?2+(n-r)/l:4+(r-t)/l:0;return{h:dist_b(60*(u<0?u+6:u)),s:dist_b(a?l/a*100:0),v:dist_b(a/255*100),a:o}},A=function(e){return{h:dist_b(e.h),s:dist_b(e.s),v:dist_b(e.v),a:dist_b(e.a,2)}},dist_S=external_React_.memo(function(r){var t=r.hue,n=r.onChange,o=dist_g(["react-colorful__hue",r.className]);return external_React_.createElement("div",{className:o},external_React_.createElement(dist_m,{onMove:function(e){n({h:360*e.left})},onKey:function(e){n({h:dist_s(t+360*e.left,0,360)})},"aria-label":"Hue","aria-valuenow":dist_b(t),"aria-valuemax":"360","aria-valuemin":"0"},external_React_.createElement(dist_p,{className:"react-colorful__hue-pointer",left:t/360,color:q({h:t,s:100,v:100,a:1})})))}),T=external_React_.memo(function(r){var t=r.hsva,n=r.onChange,o={backgroundColor:q({h:t.h,s:100,v:100,a:1})};return external_React_.createElement("div",{className:"react-colorful__saturation",style:o},external_React_.createElement(dist_m,{onMove:function(e){n({s:100*e.left,v:100-100*e.top})},onKey:function(e){n({s:dist_s(t.s+100*e.left,0,100),v:dist_s(t.v-100*e.top,0,100)})},"aria-label":"Color","aria-valuetext":"Saturation "+dist_b(t.s)+"%, Brightness "+dist_b(t.v)+"%"},external_React_.createElement(dist_p,{className:"react-colorful__saturation-pointer",top:1-t.v/100,left:t.s/100,color:q(t)})))}),F=function(e,r){if(e===r)return!0;for(var t in e)if(e[t]!==r[t])return!1;return!0},P=function(e,r){return e.replace(/\s/g,"")===r.replace(/\s/g,"")},X=function(e,r){return e.toLowerCase()===r.toLowerCase()||F(C(e),C(r))};function Y(e,t,l){var u=dist_i(l),c=(0,external_React_.useState)(function(){return e.toHsva(t)}),s=c[0],f=c[1],v=(0,external_React_.useRef)({color:t,hsva:s});(0,external_React_.useEffect)(function(){if(!e.equal(t,v.current.color)){var r=e.toHsva(t);v.current={hsva:r,color:t},f(r)}},[t,e]),(0,external_React_.useEffect)(function(){var r;F(s,v.current.hsva)||e.equal(r=e.fromHsva(s),v.current.color)||(v.current={hsva:s,color:r},u(r))},[s,e,u]);var d=(0,external_React_.useCallback)(function(e){f(function(r){return Object.assign({},r,e)})},[]);return[s,d]}var R,dist_V="undefined"!=typeof window?external_React_.useLayoutEffect:external_React_.useEffect,dist_$=function(){return R||( true?__webpack_require__.nc:0)},G=function(e){R=e},J=new Map,Q=function(e){dist_V(function(){var r=e.current?e.current.ownerDocument:document;if(void 0!==r&&!J.has(r)){var t=r.createElement("style");t.innerHTML='.react-colorful{position:relative;display:flex;flex-direction:column;width:200px;height:200px;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;cursor:default}.react-colorful__saturation{position:relative;flex-grow:1;border-color:transparent;border-bottom:12px solid #000;border-radius:8px 8px 0 0;background-image:linear-gradient(0deg,#000,transparent),linear-gradient(90deg,#fff,hsla(0,0%,100%,0))}.react-colorful__alpha-gradient,.react-colorful__pointer-fill{content:"";position:absolute;left:0;top:0;right:0;bottom:0;pointer-events:none;border-radius:inherit}.react-colorful__alpha-gradient,.react-colorful__saturation{box-shadow:inset 0 0 0 1px rgba(0,0,0,.05)}.react-colorful__alpha,.react-colorful__hue{position:relative;height:24px}.react-colorful__hue{background:linear-gradient(90deg,red 0,#ff0 17%,#0f0 33%,#0ff 50%,#00f 67%,#f0f 83%,red)}.react-colorful__last-control{border-radius:0 0 8px 8px}.react-colorful__interactive{position:absolute;left:0;top:0;right:0;bottom:0;border-radius:inherit;outline:none;touch-action:none}.react-colorful__pointer{position:absolute;z-index:1;box-sizing:border-box;width:28px;height:28px;transform:translate(-50%,-50%);background-color:#fff;border:2px solid #fff;border-radius:50%;box-shadow:0 2px 4px rgba(0,0,0,.2)}.react-colorful__interactive:focus .react-colorful__pointer{transform:translate(-50%,-50%) scale(1.1)}.react-colorful__alpha,.react-colorful__alpha-pointer{background-color:#fff;background-image:url(\'data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" fill-opacity=".05"><path d="M8 0h8v8H8zM0 8h8v8H0z"/></svg>\')}.react-colorful__saturation-pointer{z-index:3}.react-colorful__hue-pointer{z-index:2}',J.set(r,t);var n=dist_$();n&&t.setAttribute("nonce",n),r.head.appendChild(t)}},[])},U=function(t){var n=t.className,o=t.colorModel,a=t.color,l=void 0===a?o.defaultColor:a,i=t.onChange,s=dist_c(t,["className","colorModel","color","onChange"]),f=(0,external_React_.useRef)(null);Q(f);var v=Y(o,l,i),d=v[0],h=v[1],m=dist_g(["react-colorful",n]);return external_React_.createElement("div",dist_u({},s,{ref:f,className:m}),external_React_.createElement(T,{hsva:d,onChange:h}),external_React_.createElement(dist_S,{hue:d.h,onChange:h,className:"react-colorful__last-control"}))},W={defaultColor:"000",toHsva:dist_x,fromHsva:function(e){return dist_w({h:e.h,s:e.s,v:e.v,a:1})},equal:X},Z=function(r){return e.createElement(U,dist_u({},r,{colorModel:W}))},ee=function(r){var t=r.className,n=r.hsva,o=r.onChange,a={backgroundImage:"linear-gradient(90deg, "+dist_k(Object.assign({},n,{a:0}))+", "+dist_k(Object.assign({},n,{a:1}))+")"},l=dist_g(["react-colorful__alpha",t]),u=dist_b(100*n.a);return external_React_.createElement("div",{className:l},external_React_.createElement("div",{className:"react-colorful__alpha-gradient",style:a}),external_React_.createElement(dist_m,{onMove:function(e){o({a:e.left})},onKey:function(e){o({a:dist_s(n.a+e.left)})},"aria-label":"Alpha","aria-valuetext":u+"%","aria-valuenow":u,"aria-valuemin":"0","aria-valuemax":"100"},external_React_.createElement(dist_p,{className:"react-colorful__alpha-pointer",left:n.a,color:dist_k(n)})))},re=function(t){var n=t.className,o=t.colorModel,a=t.color,l=void 0===a?o.defaultColor:a,i=t.onChange,s=dist_c(t,["className","colorModel","color","onChange"]),f=(0,external_React_.useRef)(null);Q(f);var v=Y(o,l,i),d=v[0],h=v[1],m=dist_g(["react-colorful",n]);return external_React_.createElement("div",dist_u({},s,{ref:f,className:m}),external_React_.createElement(T,{hsva:d,onChange:h}),external_React_.createElement(dist_S,{hue:d.h,onChange:h}),external_React_.createElement(ee,{hsva:d,onChange:h,className:"react-colorful__last-control"}))},te={defaultColor:"0001",toHsva:dist_x,fromHsva:dist_w,equal:X},ne=function(r){return e.createElement(re,dist_u({},r,{colorModel:te}))},oe={defaultColor:{h:0,s:0,l:0,a:1},toHsva:dist_N,fromHsva:dist_y,equal:F},ae=function(r){return e.createElement(re,dist_u({},r,{colorModel:oe}))},le={defaultColor:"hsla(0, 0%, 0%, 1)",toHsva:dist_H,fromHsva:dist_k,equal:P},ue=function(r){return e.createElement(re,dist_u({},r,{colorModel:le}))},ce={defaultColor:{h:0,s:0,l:0},toHsva:function(e){return dist_N({h:e.h,s:e.s,l:e.l,a:1})},fromHsva:function(e){return{h:(r=dist_y(e)).h,s:r.s,l:r.l};var r},equal:F},ie=function(r){return e.createElement(U,dist_u({},r,{colorModel:ce}))},se={defaultColor:"hsl(0, 0%, 0%)",toHsva:dist_M,fromHsva:q,equal:P},fe=function(r){return e.createElement(U,dist_u({},r,{colorModel:se}))},ve={defaultColor:{h:0,s:0,v:0,a:1},toHsva:function(e){return e},fromHsva:A,equal:F},de=function(r){return e.createElement(re,dist_u({},r,{colorModel:ve}))},he={defaultColor:"hsva(0, 0%, 0%, 1)",toHsva:O,fromHsva:function(e){var r=A(e);return"hsva("+r.h+", "+r.s+"%, "+r.v+"%, "+r.a+")"},equal:P},me=function(r){return e.createElement(re,dist_u({},r,{colorModel:he}))},ge={defaultColor:{h:0,s:0,v:0},toHsva:function(e){return{h:e.h,s:e.s,v:e.v,a:1}},fromHsva:function(e){var r=A(e);return{h:r.h,s:r.s,v:r.v}},equal:F},pe=function(r){return e.createElement(U,dist_u({},r,{colorModel:ge}))},be={defaultColor:"hsv(0, 0%, 0%)",toHsva:dist_j,fromHsva:function(e){var r=A(e);return"hsv("+r.h+", "+r.s+"%, "+r.v+"%)"},equal:P},_e=function(r){return e.createElement(U,dist_u({},r,{colorModel:be}))},xe={defaultColor:{r:0,g:0,b:0,a:1},toHsva:L,fromHsva:dist_I,equal:F},Ce=function(r){return e.createElement(re,dist_u({},r,{colorModel:xe}))},Ee={defaultColor:"rgba(0, 0, 0, 1)",toHsva:z,fromHsva:function(e){var r=dist_I(e);return"rgba("+r.r+", "+r.g+", "+r.b+", "+r.a+")"},equal:P},He=function(r){return external_React_.createElement(re,dist_u({},r,{colorModel:Ee}))},Me={defaultColor:{r:0,g:0,b:0},toHsva:function(e){return L({r:e.r,g:e.g,b:e.b,a:1})},fromHsva:function(e){return{r:(r=dist_I(e)).r,g:r.g,b:r.b};var r},equal:F},Ne=function(r){return e.createElement(U,dist_u({},r,{colorModel:Me}))},we={defaultColor:"rgb(0, 0, 0)",toHsva:B,fromHsva:function(e){var r=dist_I(e);return"rgb("+r.r+", "+r.g+", "+r.b+")"},equal:P},ye=function(r){return external_React_.createElement(U,dist_u({},r,{colorModel:we}))},qe=/^#?([0-9A-F]{3,8})$/i,ke=function(r){var t=r.color,l=void 0===t?"":t,s=r.onChange,f=r.onBlur,v=r.escape,d=r.validate,h=r.format,m=r.process,g=dist_c(r,["color","onChange","onBlur","escape","validate","format","process"]),p=o(function(){return v(l)}),b=p[0],_=p[1],x=dist_i(s),C=dist_i(f),E=a(function(e){var r=v(e.target.value);_(r),d(r)&&x(m?m(r):r)},[v,m,d,x]),H=a(function(e){d(e.target.value)||_(v(l)),C(e)},[l,v,d,C]);return n(function(){_(v(l))},[l,v]),e.createElement("input",dist_u({},g,{value:h?h(b):b,spellCheck:"false",onChange:E,onBlur:H}))},Ie=function(e){return"#"+e},Oe=function(r){var t=r.prefixed,n=r.alpha,o=dist_c(r,["prefixed","alpha"]),l=a(function(e){return e.replace(/([^0-9A-F]+)/gi,"").substring(0,n?8:6)},[n]),i=a(function(e){return function(e,r){var t=qe.exec(e),n=t?t[1].length:0;return 3===n||6===n||!!r&&4===n||!!r&&8===n}(e,n)},[n]);return e.createElement(ke,dist_u({},o,{escape:l,format:t?Ie:void 0,process:Ie,validate:i}))};
//# sourceMappingURL=index.module.js.map
;// ./node_modules/@wordpress/components/build-module/color-picker/picker.js
const Picker = ({
color,
enableAlpha,
onChange
}) => {
const Component = enableAlpha ? He : ye;
const rgbColor = (0,external_wp_element_namespaceObject.useMemo)(() => color.toRgbString(), [color]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
color: rgbColor,
onChange: (nextColor) => {
onChange(w(nextColor));
},
onPointerDown: ({
currentTarget,
pointerId
}) => {
currentTarget.setPointerCapture(pointerId);
},
onPointerUp: ({
currentTarget,
pointerId
}) => {
currentTarget.releasePointerCapture(pointerId);
}
});
};
;// ./node_modules/@wordpress/components/build-module/color-picker/component.js
k([names]);
const options = [{
label: "RGB",
value: "rgb"
}, {
label: "HSL",
value: "hsl"
}, {
label: "Hex",
value: "hex"
}];
const UnconnectedColorPicker = (props, forwardedRef) => {
const {
enableAlpha = false,
color: colorProp,
onChange,
defaultValue = "#fff",
copyFormat,
...divProps
} = useContextSystem(props, "ColorPicker");
const [color, setColor] = useControlledValue({
onChange,
value: colorProp,
defaultValue
});
const safeColordColor = (0,external_wp_element_namespaceObject.useMemo)(() => {
return w(color || "");
}, [color]);
const debouncedSetColor = (0,external_wp_compose_namespaceObject.useDebounce)(setColor);
const handleChange = (0,external_wp_element_namespaceObject.useCallback)((nextValue) => {
debouncedSetColor(nextValue.toHex());
}, [debouncedSetColor]);
const [colorType, setColorType] = (0,external_wp_element_namespaceObject.useState)(copyFormat || "hex");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ColorfulWrapper, {
ref: forwardedRef,
...divProps,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Picker, {
onChange: handleChange,
color: safeColordColor,
enableAlpha
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(AuxiliaryColorArtefactWrapper, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(AuxiliaryColorArtefactHStackHeader, {
justify: "space-between",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_SelectControl, {
__nextHasNoMarginBottom: true,
size: "compact",
options,
value: colorType,
onChange: (nextColorType) => setColorType(nextColorType),
label: (0,external_wp_i18n_namespaceObject.__)("Color format"),
hideLabelFromVision: true,
variant: "minimal"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorCopyButton, {
color: safeColordColor,
colorType: copyFormat || colorType
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorInputWrapper, {
direction: "column",
gap: 2,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorInput, {
colorType,
color: safeColordColor,
onChange: handleChange,
enableAlpha
})
})]
})]
});
};
const ColorPicker = contextConnect(UnconnectedColorPicker, "ColorPicker");
var color_picker_component_component_default = ColorPicker;
;// ./node_modules/@wordpress/components/build-module/color-picker/use-deprecated-props.js
function isLegacyProps(props) {
return typeof props.onChangeComplete !== "undefined" || typeof props.disableAlpha !== "undefined" || typeof props.color?.hex === "string";
}
function getColorFromLegacyProps(color) {
if (color === void 0) {
return;
}
if (typeof color === "string") {
return color;
}
if (color.hex) {
return color.hex;
}
return void 0;
}
const transformColorStringToLegacyColor = memize((color) => {
const colordColor = w(color);
const hex = colordColor.toHex();
const rgb = colordColor.toRgb();
const hsv = colordColor.toHsv();
const hsl = colordColor.toHsl();
return {
hex,
rgb,
hsv,
hsl,
source: "hex",
oldHue: hsl.h
};
});
function use_deprecated_props_useDeprecatedProps(props) {
const {
onChangeComplete
} = props;
const legacyChangeHandler = (0,external_wp_element_namespaceObject.useCallback)((color) => {
onChangeComplete(transformColorStringToLegacyColor(color));
}, [onChangeComplete]);
if (isLegacyProps(props)) {
return {
color: getColorFromLegacyProps(props.color),
enableAlpha: !props.disableAlpha,
onChange: legacyChangeHandler
};
}
return {
...props,
color: props.color,
enableAlpha: props.enableAlpha,
onChange: props.onChange
};
}
;// ./node_modules/@wordpress/components/build-module/color-picker/legacy-adapter.js
const LegacyAdapter = (props) => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_picker_component_component_default, {
...use_deprecated_props_useDeprecatedProps(props)
});
};
;// ./node_modules/@wordpress/components/build-module/circular-option-picker/circular-option-picker-context.js
const CircularOptionPickerContext = (0,external_wp_element_namespaceObject.createContext)({});
CircularOptionPickerContext.displayName = "CircularOptionPickerContext";
;// ./node_modules/@wordpress/components/build-module/circular-option-picker/circular-option-picker-option.js
function UnforwardedOptionAsButton(props, forwardedRef) {
const {
isPressed,
label,
...additionalProps
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
...additionalProps,
"aria-pressed": isPressed,
ref: forwardedRef,
label
});
}
const OptionAsButton = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedOptionAsButton);
function UnforwardedOptionAsOption(props, forwardedRef) {
const {
id,
isSelected,
label,
...additionalProps
} = props;
const {
setActiveId,
activeId
} = (0,external_wp_element_namespaceObject.useContext)(CircularOptionPickerContext);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (isSelected && !activeId) {
window.setTimeout(() => setActiveId?.(id), 0);
}
}, [isSelected, setActiveId, activeId, id]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(composite_Composite.Item, {
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
...additionalProps,
role: "option",
"aria-selected": !!isSelected,
ref: forwardedRef,
label
}),
id
});
}
const OptionAsOption = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedOptionAsOption);
function Option({
className,
isSelected,
selectedIconProps = {},
tooltipText,
...additionalProps
}) {
const {
baseId,
setActiveId
} = (0,external_wp_element_namespaceObject.useContext)(CircularOptionPickerContext);
const id = (0,external_wp_compose_namespaceObject.useInstanceId)(Option, baseId || "components-circular-option-picker__option");
const commonProps = {
id,
className: "components-circular-option-picker__option",
__next40pxDefaultSize: true,
...additionalProps
};
const isListbox = setActiveId !== void 0;
const optionControl = isListbox ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OptionAsOption, {
...commonProps,
label: tooltipText,
isSelected
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OptionAsButton, {
...commonProps,
label: tooltipText,
isPressed: isSelected
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: dist_clsx(className, "components-circular-option-picker__option-wrapper"),
children: [optionControl, isSelected && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: check_default,
...selectedIconProps
})]
});
}
;// ./node_modules/@wordpress/components/build-module/circular-option-picker/circular-option-picker-option-group.js
function OptionGroup({
className,
options,
...additionalProps
}) {
const role = "aria-label" in additionalProps || "aria-labelledby" in additionalProps ? "group" : void 0;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...additionalProps,
role,
className: dist_clsx("components-circular-option-picker__option-group", "components-circular-option-picker__swatches", className),
children: options
});
}
;// ./node_modules/@wordpress/components/build-module/circular-option-picker/circular-option-picker-actions.js
function DropdownLinkAction({
buttonProps,
className,
dropdownProps,
linkText
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_default, {
className: dist_clsx("components-circular-option-picker__dropdown-link-action", className),
renderToggle: ({
isOpen,
onToggle
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
"aria-expanded": isOpen,
"aria-haspopup": "true",
onClick: onToggle,
variant: "link",
...buttonProps,
children: linkText
}),
...dropdownProps
});
}
function ButtonAction({
className,
children,
...additionalProps
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
className: dist_clsx("components-circular-option-picker__clear", className),
variant: "tertiary",
...additionalProps,
children
});
}
;// ./node_modules/@wordpress/components/build-module/circular-option-picker/circular-option-picker.js
function ListboxCircularOptionPicker(props) {
const {
actions,
options,
baseId,
className,
loop = true,
children,
...additionalProps
} = props;
const [activeId, setActiveId] = (0,external_wp_element_namespaceObject.useState)(void 0);
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
baseId,
activeId,
setActiveId
}), [baseId, activeId, setActiveId]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(CircularOptionPickerContext.Provider, {
value: contextValue,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(composite_Composite, {
...additionalProps,
id: baseId,
focusLoop: loop,
rtl: (0,external_wp_i18n_namespaceObject.isRTL)(),
role: "listbox",
activeId,
setActiveId,
children: options
}), children, actions]
})
});
}
function ButtonsCircularOptionPicker(props) {
const {
actions,
options,
children,
baseId,
...additionalProps
} = props;
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
baseId
}), [baseId]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...additionalProps,
role: "group",
id: baseId,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(CircularOptionPickerContext.Provider, {
value: contextValue,
children: [options, children, actions]
})
});
}
function CircularOptionPicker(props) {
const {
asButtons,
actions: actionsProp,
options: optionsProp,
children,
className,
...additionalProps
} = props;
const baseId = (0,external_wp_compose_namespaceObject.useInstanceId)(CircularOptionPicker, "components-circular-option-picker", additionalProps.id);
const OptionPickerImplementation = asButtons ? ButtonsCircularOptionPicker : ListboxCircularOptionPicker;
const actions = actionsProp ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-circular-option-picker__custom-clear-wrapper",
children: actionsProp
}) : void 0;
const options = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-circular-option-picker__swatches",
children: optionsProp
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OptionPickerImplementation, {
...additionalProps,
baseId,
className: dist_clsx("components-circular-option-picker", className),
actions,
options,
children
});
}
CircularOptionPicker.Option = Option;
CircularOptionPicker.OptionGroup = OptionGroup;
CircularOptionPicker.ButtonAction = ButtonAction;
CircularOptionPicker.DropdownLinkAction = DropdownLinkAction;
var circular_option_picker_default = CircularOptionPicker;
;// ./node_modules/@wordpress/components/build-module/circular-option-picker/index.js
var circular_option_picker_circular_option_picker_default = circular_option_picker_default;
;// ./node_modules/@wordpress/components/build-module/circular-option-picker/utils.js
function getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby) {
const metaProps = asButtons ? {
asButtons: true
} : {
asButtons: false,
loop
};
const labelProps = {
"aria-labelledby": ariaLabelledby,
"aria-label": ariaLabelledby ? void 0 : ariaLabel || (0,external_wp_i18n_namespaceObject.__)("Custom color picker")
};
return {
metaProps,
labelProps
};
}
;// ./node_modules/@wordpress/components/build-module/v-stack/hook.js
function useVStack(props) {
const {
expanded = false,
alignment = "stretch",
...otherProps
} = useContextSystem(props, "VStack");
const hStackProps = useHStack({
direction: "column",
expanded,
alignment,
...otherProps
});
return hStackProps;
}
;// ./node_modules/@wordpress/components/build-module/v-stack/component.js
function UnconnectedVStack(props, forwardedRef) {
const vStackProps = useVStack(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...vStackProps,
ref: forwardedRef
});
}
const VStack = contextConnect(UnconnectedVStack, "VStack");
var v_stack_component_component_default = VStack;
;// ./node_modules/@wordpress/components/build-module/truncate/component.js
function UnconnectedTruncate(props, forwardedRef) {
const truncateProps = useTruncate(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
as: "span",
...truncateProps,
ref: forwardedRef
});
}
const component_Truncate = contextConnect(UnconnectedTruncate, "Truncate");
var truncate_component_component_default = component_Truncate;
;// ./node_modules/@wordpress/components/build-module/heading/hook.js
function useHeading(props) {
const {
as: asProp,
level = 2,
color = COLORS.theme.foreground,
isBlock = true,
weight = config_values_default.fontWeightHeading,
...otherProps
} = useContextSystem(props, "Heading");
const as = asProp || `h${level}`;
const a11yProps = {};
if (typeof as === "string" && as[0] !== "h") {
a11yProps.role = "heading";
a11yProps["aria-level"] = typeof level === "string" ? parseInt(level) : level;
}
const textProps = useText({
color,
isBlock,
weight,
size: getHeadingFontSize(level),
...otherProps
});
return {
...textProps,
...a11yProps,
as
};
}
;// ./node_modules/@wordpress/components/build-module/heading/component.js
function UnconnectedHeading(props, forwardedRef) {
const headerProps = useHeading(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...headerProps,
ref: forwardedRef
});
}
const Heading = contextConnect(UnconnectedHeading, "Heading");
var heading_component_component_default = Heading;
;// ./node_modules/@wordpress/components/build-module/color-palette/styles.js
function color_palette_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const ColorHeading = /* @__PURE__ */ emotion_styled_base_browser_esm(heading_component_component_default, true ? {
target: "ev9wop70"
} : 0)( true ? {
name: "13lxv2o",
styles: "text-transform:uppercase;line-height:24px;font-weight:500;&&&{font-size:11px;margin-bottom:0;}"
} : 0);
;// ./node_modules/@wordpress/components/build-module/dropdown/styles.js
const padding = ({
paddingSize = "small"
}) => {
if (paddingSize === "none") {
return;
}
const paddingValues = {
small: space(2),
medium: space(4)
};
return /* @__PURE__ */ emotion_react_browser_esm_css("padding:", paddingValues[paddingSize] || paddingValues.small, ";" + ( true ? "" : 0), true ? "" : 0);
};
const DropdownContentWrapperDiv = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eovvns30"
} : 0)("margin-left:", space(-2), ";margin-right:", space(-2), ";&:first-of-type{margin-top:", space(-2), ";}&:last-of-type{margin-bottom:", space(-2), ";}", padding, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/dropdown/dropdown-content-wrapper.js
function UnconnectedDropdownContentWrapper(props, forwardedRef) {
const {
paddingSize = "small",
...derivedProps
} = useContextSystem(props, "DropdownContentWrapper");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DropdownContentWrapperDiv, {
...derivedProps,
paddingSize,
ref: forwardedRef
});
}
const DropdownContentWrapper = contextConnect(UnconnectedDropdownContentWrapper, "DropdownContentWrapper");
var dropdown_content_wrapper_default = DropdownContentWrapper;
;// ./node_modules/@wordpress/components/build-module/color-palette/utils.js
k([names, a11y]);
const isSimpleCSSColor = (value) => {
const valueIsCssVariable = /var\(/.test(value !== null && value !== void 0 ? value : "");
const valueIsColorMix = /color-mix\(/.test(value !== null && value !== void 0 ? value : "");
return !valueIsCssVariable && !valueIsColorMix;
};
const extractColorNameFromCurrentValue = (currentValue, colors = [], showMultiplePalettes = false) => {
if (!currentValue) {
return "";
}
const currentValueIsSimpleColor = currentValue ? isSimpleCSSColor(currentValue) : false;
const normalizedCurrentValue = currentValueIsSimpleColor ? w(currentValue).toHex() : currentValue;
const colorPalettes = showMultiplePalettes ? colors : [{
colors
}];
for (const {
colors: paletteColors
} of colorPalettes) {
for (const {
name: colorName,
color: colorValue
} of paletteColors) {
const normalizedColorValue = currentValueIsSimpleColor ? w(colorValue).toHex() : colorValue;
if (normalizedCurrentValue === normalizedColorValue) {
return colorName;
}
}
}
return (0,external_wp_i18n_namespaceObject.__)("Custom");
};
const isMultiplePaletteObject = (obj) => Array.isArray(obj.colors) && !("color" in obj);
const isMultiplePaletteArray = (arr) => {
return arr.length > 0 && arr.every((colorObj) => isMultiplePaletteObject(colorObj));
};
const normalizeColorValue = (value, element) => {
if (!value || !element || isSimpleCSSColor(value)) {
return value;
}
const {
ownerDocument
} = element;
const {
defaultView
} = ownerDocument;
const computedBackgroundColor = defaultView?.getComputedStyle(element).backgroundColor;
return computedBackgroundColor ? w(computedBackgroundColor).toHex() : value;
};
;// ./node_modules/@wordpress/components/build-module/color-palette/index.js
k([names, a11y]);
function SinglePalette({
className,
clearColor,
colors,
onChange,
value,
...additionalProps
}) {
const colorOptions = (0,external_wp_element_namespaceObject.useMemo)(() => {
return colors.map(({
color,
name
}, index) => {
const colordColor = w(color);
const isSelected = value === color;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.Option, {
isSelected,
selectedIconProps: isSelected ? {
fill: colordColor.contrast() > colordColor.contrast("#000") ? "#fff" : "#000"
} : {},
tooltipText: name || // translators: %s: color hex code e.g: "#f00".
(0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("Color code: %s"), color),
style: {
backgroundColor: color,
color
},
onClick: isSelected ? clearColor : () => onChange(color, index)
}, `${color}-${index}`);
});
}, [colors, value, onChange, clearColor]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.OptionGroup, {
className,
options: colorOptions,
...additionalProps
});
}
function MultiplePalettes({
className,
clearColor,
colors,
onChange,
value,
headingLevel
}) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(MultiplePalettes, "color-palette");
if (colors.length === 0) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(v_stack_component_component_default, {
spacing: 3,
className,
children: colors.map(({
name,
colors: colorPalette
}, index) => {
const id = `${instanceId}-${index}`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
spacing: 2,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorHeading, {
id,
level: headingLevel,
children: name
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SinglePalette, {
clearColor,
colors: colorPalette,
onChange: (newColor) => onChange(newColor, index),
value,
"aria-labelledby": id
})]
}, index);
})
});
}
function CustomColorPickerDropdown({
isRenderedInSidebar,
popoverProps: receivedPopoverProps,
...props
}) {
const popoverProps = (0,external_wp_element_namespaceObject.useMemo)(() => ({
shift: true,
// Disabling resize as it would otherwise cause the popover to show
// scrollbars while dragging the color picker's handle close to the
// popover edge.
resize: false,
...isRenderedInSidebar ? {
// When in the sidebar: open to the left (stacking),
// leaving the same gap as the parent popover.
placement: "left-start",
offset: 34
} : {
// Default behavior: open below the anchor
placement: "bottom",
offset: 8
},
...receivedPopoverProps
}), [isRenderedInSidebar, receivedPopoverProps]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_default, {
contentClassName: "components-color-palette__custom-color-dropdown-content",
popoverProps,
...props
});
}
function UnforwardedColorPalette(props, forwardedRef) {
const {
asButtons,
loop,
clearable = true,
colors = [],
disableCustomColors = false,
enableAlpha = false,
onChange,
value,
__experimentalIsRenderedInSidebar = false,
headingLevel = 2,
"aria-label": ariaLabel,
"aria-labelledby": ariaLabelledby,
...additionalProps
} = props;
const [normalizedColorValue, setNormalizedColorValue] = (0,external_wp_element_namespaceObject.useState)(value);
const clearColor = (0,external_wp_element_namespaceObject.useCallback)(() => onChange(void 0), [onChange]);
const customColorPaletteCallbackRef = (0,external_wp_element_namespaceObject.useCallback)((node) => {
setNormalizedColorValue(normalizeColorValue(value, node));
}, [value]);
const hasMultipleColorOrigins = isMultiplePaletteArray(colors);
const buttonLabelName = (0,external_wp_element_namespaceObject.useMemo)(() => extractColorNameFromCurrentValue(value, colors, hasMultipleColorOrigins), [value, colors, hasMultipleColorOrigins]);
const renderCustomColorPicker = () => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_content_wrapper_default, {
paddingSize: "none",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LegacyAdapter, {
color: normalizedColorValue,
onChange: (color) => onChange(color),
enableAlpha
})
});
const isHex = value?.startsWith("#");
const displayValue = value?.replace(/^var\((.+)\)$/, "$1");
const customColorAccessibleLabel = !!displayValue ? (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The name of the color e.g: "vivid red". 2: The color's hex code e.g: "#f00".
(0,external_wp_i18n_namespaceObject.__)('Custom color picker. The currently selected color is called "%1$s" and has a value of "%2$s".'),
buttonLabelName,
displayValue
) : (0,external_wp_i18n_namespaceObject.__)("Custom color picker");
const paletteCommonProps = {
clearColor,
onChange,
value
};
const actions = !!clearable && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.ButtonAction, {
onClick: clearColor,
accessibleWhenDisabled: true,
disabled: !value,
children: (0,external_wp_i18n_namespaceObject.__)("Clear")
});
const {
metaProps,
labelProps
} = getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
spacing: 3,
ref: forwardedRef,
...additionalProps,
children: [!disableCustomColors && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomColorPickerDropdown, {
isRenderedInSidebar: __experimentalIsRenderedInSidebar,
renderContent: renderCustomColorPicker,
renderToggle: ({
isOpen,
onToggle
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
className: "components-color-palette__custom-color-wrapper",
spacing: 0,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("button", {
ref: customColorPaletteCallbackRef,
className: "components-color-palette__custom-color-button",
"aria-expanded": isOpen,
"aria-haspopup": "true",
onClick: onToggle,
"aria-label": customColorAccessibleLabel,
style: {
background: value
},
type: "button"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
className: "components-color-palette__custom-color-text-wrapper",
spacing: 0.5,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(truncate_component_component_default, {
className: "components-color-palette__custom-color-name",
children: value ? buttonLabelName : (0,external_wp_i18n_namespaceObject.__)("No color selected")
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(truncate_component_component_default, {
className: dist_clsx("components-color-palette__custom-color-value", {
"components-color-palette__custom-color-value--is-hex": isHex
}),
children: displayValue
})]
})]
})
}), (colors.length > 0 || actions) && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default, {
...metaProps,
...labelProps,
actions,
options: hasMultipleColorOrigins ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MultiplePalettes, {
...paletteCommonProps,
headingLevel,
colors,
value
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SinglePalette, {
...paletteCommonProps,
colors,
value
})
})]
});
}
const ColorPalette = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedColorPalette);
var color_palette_default = ColorPalette;
;// ./node_modules/@wordpress/components/build-module/unit-control/styles/unit-control-styles.js
const ValueInput = /* @__PURE__ */ emotion_styled_base_browser_esm(number_control_default, true ? {
target: "e1bagdl32"
} : 0)("&&&{input{display:block;width:100%;}", BackdropUI, "{transition:box-shadow 0.1s linear;}}" + ( true ? "" : 0));
const baseUnitLabelStyles = ({
selectSize
}) => {
const sizes = {
small: /* @__PURE__ */ emotion_react_browser_esm_css("box-sizing:border-box;padding:2px 1px;width:20px;font-size:8px;line-height:1;letter-spacing:-0.5px;text-transform:uppercase;text-align-last:center;&:not( :disabled ){color:", COLORS.gray[800], ";}" + ( true ? "" : 0), true ? "" : 0),
default: /* @__PURE__ */ emotion_react_browser_esm_css("box-sizing:border-box;min-width:24px;max-width:48px;height:24px;margin-inline-end:", space(2), ";padding:", space(1), ";font-size:13px;line-height:1;text-align-last:center;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;field-sizing:content;&:not( :disabled ){color:", COLORS.theme.accent, ";}" + ( true ? "" : 0), true ? "" : 0)
};
return sizes[selectSize];
};
const UnitLabel = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1bagdl31"
} : 0)("&&&{pointer-events:none;", baseUnitLabelStyles, ";color:", COLORS.gray[900], ";}" + ( true ? "" : 0));
const unitSelectSizes = ({
selectSize = "default"
}) => {
const sizes = {
small: /* @__PURE__ */ emotion_react_browser_esm_css("height:100%;border:1px solid transparent;transition:box-shadow 0.1s linear,border 0.1s linear;", rtl({
borderTopLeftRadius: 0,
borderBottomLeftRadius: 0
})(), " &:not(:disabled):hover{background-color:", COLORS.gray[100], ";}&:focus{border:1px solid ", COLORS.ui.borderFocus, ";box-shadow:inset 0 0 0 ", config_values_default.borderWidth + " " + COLORS.ui.borderFocus, ";outline-offset:0;outline:2px solid transparent;z-index:1;}" + ( true ? "" : 0), true ? "" : 0),
default: /* @__PURE__ */ emotion_react_browser_esm_css("display:flex;justify-content:center;align-items:center;&:where( :not( :disabled ) ):hover{box-shadow:0 0 0 ", config_values_default.borderWidth + " " + COLORS.ui.borderFocus, ";outline:", config_values_default.borderWidth, " solid transparent;}&:focus{box-shadow:0 0 0 ", config_values_default.borderWidthFocus + " " + COLORS.ui.borderFocus, ";outline:", config_values_default.borderWidthFocus, " solid transparent;}" + ( true ? "" : 0), true ? "" : 0)
};
return sizes[selectSize];
};
const UnitSelect = /* @__PURE__ */ emotion_styled_base_browser_esm("select", true ? {
target: "e1bagdl30"
} : 0)("&&&{appearance:none;background:transparent;border-radius:", config_values_default.radiusXSmall, ";border:none;display:block;outline:none;margin:0;min-height:auto;font-family:inherit;", baseUnitLabelStyles, ";", unitSelectSizes, ";&:not( :disabled ){cursor:pointer;}}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/border-control/styles.js
function border_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const focusBoxShadow = /* @__PURE__ */ emotion_react_browser_esm_css("box-shadow:inset ", config_values_default.controlBoxShadowFocus, ";" + ( true ? "" : 0), true ? "" : 0);
const borderControl = /* @__PURE__ */ emotion_react_browser_esm_css("border:0;padding:0;margin:0;", boxSizingReset, ";" + ( true ? "" : 0), true ? "" : 0);
const innerWrapper = () => /* @__PURE__ */ emotion_react_browser_esm_css(ValueInput, "{flex:1 1 40%;}&& ", UnitSelect, "{min-height:0;}" + ( true ? "" : 0), true ? "" : 0);
const styles_wrapperWidth = /* @__PURE__ */ emotion_react_browser_esm_css(ValueInput, "{flex:0 0 auto;}" + ( true ? "" : 0), true ? "" : 0);
const wrapperHeight = (size) => {
return /* @__PURE__ */ emotion_react_browser_esm_css("height:", size === "__unstable-large" ? "40px" : "30px", ";" + ( true ? "" : 0), true ? "" : 0);
};
const borderControlDropdown = /* @__PURE__ */ emotion_react_browser_esm_css("background:#fff;&&>button{aspect-ratio:1;padding:0;display:flex;align-items:center;justify-content:center;", rtl({
borderRadius: `2px 0 0 2px`
}, {
borderRadius: `0 2px 2px 0`
})(), " border:", config_values_default.borderWidth, " solid ", COLORS.ui.border, ";&:focus,&:hover:not( :disabled ){", focusBoxShadow, " border-color:", COLORS.ui.borderFocus, ";z-index:1;position:relative;}}" + ( true ? "" : 0), true ? "" : 0);
const colorIndicatorBorder = (border) => {
const {
color,
style
} = border || {};
const fallbackColor = !!style && style !== "none" ? COLORS.gray[300] : void 0;
return /* @__PURE__ */ emotion_react_browser_esm_css("border-style:", style === "none" ? "solid" : style, ";border-color:", color || fallbackColor, ";" + ( true ? "" : 0), true ? "" : 0);
};
const colorIndicatorWrapper = (border, size) => {
const {
style
} = border || {};
return /* @__PURE__ */ emotion_react_browser_esm_css("border-radius:", config_values_default.radiusFull, ";border:2px solid transparent;", style ? colorIndicatorBorder(border) : void 0, " width:", size === "__unstable-large" ? "24px" : "22px", ";height:", size === "__unstable-large" ? "24px" : "22px", ";padding:", size === "__unstable-large" ? "2px" : "1px", ";&>span{height:", space(4), ";width:", space(4), ";background:linear-gradient(\n -45deg,\n transparent 48%,\n rgb( 0 0 0 / 20% ) 48%,\n rgb( 0 0 0 / 20% ) 52%,\n transparent 52%\n );}" + ( true ? "" : 0), true ? "" : 0);
};
const swatchSize = 28;
const swatchGap = 12;
const borderControlPopoverControls = /* @__PURE__ */ emotion_react_browser_esm_css("width:", swatchSize * 6 + swatchGap * 5, "px;>div:first-of-type>", StyledLabel, "{margin-bottom:0;}&& ", StyledLabel, "+button:not( .has-text ){min-width:24px;padding:0;}" + ( true ? "" : 0), true ? "" : 0);
const borderControlPopoverContent = /* @__PURE__ */ emotion_react_browser_esm_css( true ? "" : 0, true ? "" : 0);
const borderColorIndicator = /* @__PURE__ */ emotion_react_browser_esm_css( true ? "" : 0, true ? "" : 0);
const resetButtonWrapper = true ? {
name: "1ghe26v",
styles: "display:flex;justify-content:flex-end;margin-top:12px"
} : 0;
const borderSlider = () => /* @__PURE__ */ emotion_react_browser_esm_css("flex:1 1 60%;", rtl({
marginRight: space(3)
})(), ";" + ( true ? "" : 0), true ? "" : 0);
;// ./node_modules/@wordpress/components/build-module/unit-control/utils.js
const isWeb = external_wp_element_namespaceObject.Platform.OS === "web";
const allUnits = {
px: {
value: "px",
label: isWeb ? "px" : (0,external_wp_i18n_namespaceObject.__)("Pixels (px)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Pixels (px)"),
step: 1
},
"%": {
value: "%",
label: isWeb ? "%" : (0,external_wp_i18n_namespaceObject.__)("Percentage (%)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Percent (%)"),
step: 0.1
},
em: {
value: "em",
label: isWeb ? "em" : (0,external_wp_i18n_namespaceObject.__)("Relative to parent font size (em)"),
a11yLabel: (0,external_wp_i18n_namespaceObject._x)("ems", "Relative to parent font size (em)"),
step: 0.01
},
rem: {
value: "rem",
label: isWeb ? "rem" : (0,external_wp_i18n_namespaceObject.__)("Relative to root font size (rem)"),
a11yLabel: (0,external_wp_i18n_namespaceObject._x)("rems", "Relative to root font size (rem)"),
step: 0.01
},
vw: {
value: "vw",
label: isWeb ? "vw" : (0,external_wp_i18n_namespaceObject.__)("Viewport width (vw)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Viewport width (vw)"),
step: 0.1
},
vh: {
value: "vh",
label: isWeb ? "vh" : (0,external_wp_i18n_namespaceObject.__)("Viewport height (vh)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Viewport height (vh)"),
step: 0.1
},
vmin: {
value: "vmin",
label: isWeb ? "vmin" : (0,external_wp_i18n_namespaceObject.__)("Viewport smallest dimension (vmin)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Viewport smallest dimension (vmin)"),
step: 0.1
},
vmax: {
value: "vmax",
label: isWeb ? "vmax" : (0,external_wp_i18n_namespaceObject.__)("Viewport largest dimension (vmax)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Viewport largest dimension (vmax)"),
step: 0.1
},
ch: {
value: "ch",
label: isWeb ? "ch" : (0,external_wp_i18n_namespaceObject.__)("Width of the zero (0) character (ch)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Width of the zero (0) character (ch)"),
step: 0.01
},
ex: {
value: "ex",
label: isWeb ? "ex" : (0,external_wp_i18n_namespaceObject.__)("x-height of the font (ex)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("x-height of the font (ex)"),
step: 0.01
},
cm: {
value: "cm",
label: isWeb ? "cm" : (0,external_wp_i18n_namespaceObject.__)("Centimeters (cm)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Centimeters (cm)"),
step: 1e-3
},
mm: {
value: "mm",
label: isWeb ? "mm" : (0,external_wp_i18n_namespaceObject.__)("Millimeters (mm)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Millimeters (mm)"),
step: 0.1
},
in: {
value: "in",
label: isWeb ? "in" : (0,external_wp_i18n_namespaceObject.__)("Inches (in)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Inches (in)"),
step: 1e-3
},
pc: {
value: "pc",
label: isWeb ? "pc" : (0,external_wp_i18n_namespaceObject.__)("Picas (pc)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Picas (pc)"),
step: 1
},
pt: {
value: "pt",
label: isWeb ? "pt" : (0,external_wp_i18n_namespaceObject.__)("Points (pt)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Points (pt)"),
step: 1
},
svw: {
value: "svw",
label: isWeb ? "svw" : (0,external_wp_i18n_namespaceObject.__)("Small viewport width (svw)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Small viewport width (svw)"),
step: 0.1
},
svh: {
value: "svh",
label: isWeb ? "svh" : (0,external_wp_i18n_namespaceObject.__)("Small viewport height (svh)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Small viewport height (svh)"),
step: 0.1
},
svi: {
value: "svi",
label: isWeb ? "svi" : (0,external_wp_i18n_namespaceObject.__)("Viewport smallest size in the inline direction (svi)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Small viewport width or height (svi)"),
step: 0.1
},
svb: {
value: "svb",
label: isWeb ? "svb" : (0,external_wp_i18n_namespaceObject.__)("Viewport smallest size in the block direction (svb)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Small viewport width or height (svb)"),
step: 0.1
},
svmin: {
value: "svmin",
label: isWeb ? "svmin" : (0,external_wp_i18n_namespaceObject.__)("Small viewport smallest dimension (svmin)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Small viewport smallest dimension (svmin)"),
step: 0.1
},
lvw: {
value: "lvw",
label: isWeb ? "lvw" : (0,external_wp_i18n_namespaceObject.__)("Large viewport width (lvw)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Large viewport width (lvw)"),
step: 0.1
},
lvh: {
value: "lvh",
label: isWeb ? "lvh" : (0,external_wp_i18n_namespaceObject.__)("Large viewport height (lvh)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Large viewport height (lvh)"),
step: 0.1
},
lvi: {
value: "lvi",
label: isWeb ? "lvi" : (0,external_wp_i18n_namespaceObject.__)("Large viewport width or height (lvi)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Large viewport width or height (lvi)"),
step: 0.1
},
lvb: {
value: "lvb",
label: isWeb ? "lvb" : (0,external_wp_i18n_namespaceObject.__)("Large viewport width or height (lvb)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Large viewport width or height (lvb)"),
step: 0.1
},
lvmin: {
value: "lvmin",
label: isWeb ? "lvmin" : (0,external_wp_i18n_namespaceObject.__)("Large viewport smallest dimension (lvmin)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Large viewport smallest dimension (lvmin)"),
step: 0.1
},
dvw: {
value: "dvw",
label: isWeb ? "dvw" : (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport width (dvw)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport width (dvw)"),
step: 0.1
},
dvh: {
value: "dvh",
label: isWeb ? "dvh" : (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport height (dvh)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport height (dvh)"),
step: 0.1
},
dvi: {
value: "dvi",
label: isWeb ? "dvi" : (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport width or height (dvi)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport width or height (dvi)"),
step: 0.1
},
dvb: {
value: "dvb",
label: isWeb ? "dvb" : (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport width or height (dvb)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport width or height (dvb)"),
step: 0.1
},
dvmin: {
value: "dvmin",
label: isWeb ? "dvmin" : (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport smallest dimension (dvmin)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport smallest dimension (dvmin)"),
step: 0.1
},
dvmax: {
value: "dvmax",
label: isWeb ? "dvmax" : (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport largest dimension (dvmax)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Dynamic viewport largest dimension (dvmax)"),
step: 0.1
},
svmax: {
value: "svmax",
label: isWeb ? "svmax" : (0,external_wp_i18n_namespaceObject.__)("Small viewport largest dimension (svmax)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Small viewport largest dimension (svmax)"),
step: 0.1
},
lvmax: {
value: "lvmax",
label: isWeb ? "lvmax" : (0,external_wp_i18n_namespaceObject.__)("Large viewport largest dimension (lvmax)"),
a11yLabel: (0,external_wp_i18n_namespaceObject.__)("Large viewport largest dimension (lvmax)"),
step: 0.1
}
};
const ALL_CSS_UNITS = Object.values(allUnits);
const CSS_UNITS = [allUnits.px, allUnits["%"], allUnits.em, allUnits.rem, allUnits.vw, allUnits.vh];
const DEFAULT_UNIT = allUnits.px;
function getParsedQuantityAndUnit(rawValue, fallbackUnit, allowedUnits) {
const initialValue = fallbackUnit ? `${rawValue !== null && rawValue !== void 0 ? rawValue : ""}${fallbackUnit}` : rawValue;
return parseQuantityAndUnitFromRawValue(initialValue, allowedUnits);
}
function hasUnits(units) {
return Array.isArray(units) && !!units.length;
}
function parseQuantityAndUnitFromRawValue(rawValue, allowedUnits = ALL_CSS_UNITS) {
let trimmedValue;
let quantityToReturn;
if (typeof rawValue !== "undefined" || rawValue === null) {
trimmedValue = `${rawValue}`.trim();
const parsedQuantity = parseFloat(trimmedValue);
quantityToReturn = !isFinite(parsedQuantity) ? void 0 : parsedQuantity;
}
const unitMatch = trimmedValue?.match(/[\d.\-\+]*\s*(.*)/);
const matchedUnit = unitMatch?.[1]?.toLowerCase();
let unitToReturn;
if (hasUnits(allowedUnits)) {
const match = allowedUnits.find((item) => item.value === matchedUnit);
unitToReturn = match?.value;
} else {
unitToReturn = DEFAULT_UNIT.value;
}
return [quantityToReturn, unitToReturn];
}
function getValidParsedQuantityAndUnit(rawValue, allowedUnits, fallbackQuantity, fallbackUnit) {
const [parsedQuantity, parsedUnit] = parseQuantityAndUnitFromRawValue(rawValue, allowedUnits);
const quantityToReturn = parsedQuantity !== null && parsedQuantity !== void 0 ? parsedQuantity : fallbackQuantity;
let unitToReturn = parsedUnit || fallbackUnit;
if (!unitToReturn && hasUnits(allowedUnits)) {
unitToReturn = allowedUnits[0].value;
}
return [quantityToReturn, unitToReturn];
}
function getAccessibleLabelForUnit(unit) {
const match = ALL_CSS_UNITS.find((item) => item.value === unit);
return match?.a11yLabel ? match?.a11yLabel : match?.value;
}
function filterUnitsWithSettings(allowedUnitValues = [], availableUnits) {
return Array.isArray(availableUnits) ? availableUnits.filter((unit) => allowedUnitValues.includes(unit.value)) : [];
}
const useCustomUnits = ({
units = ALL_CSS_UNITS,
availableUnits = [],
defaultValues
}) => {
const customUnitsToReturn = filterUnitsWithSettings(availableUnits, units);
if (!defaultValues) {
return customUnitsToReturn;
}
return customUnitsToReturn.map((unit) => {
const [defaultValue] = defaultValues[unit.value] ? parseQuantityAndUnitFromRawValue(defaultValues[unit.value]) : [];
return {
...unit,
default: defaultValue
};
});
};
function getUnitsWithCurrentUnit(rawValue, legacyUnit, units = ALL_CSS_UNITS) {
const unitsToReturn = Array.isArray(units) ? [...units] : [];
const [, currentUnit] = getParsedQuantityAndUnit(rawValue, legacyUnit, ALL_CSS_UNITS);
if (currentUnit && !unitsToReturn.some((unit) => unit.value === currentUnit)) {
if (allUnits[currentUnit]) {
unitsToReturn.unshift(allUnits[currentUnit]);
}
}
return unitsToReturn;
}
;// ./node_modules/@wordpress/components/build-module/border-control/border-control-dropdown/hook.js
function useBorderControlDropdown(props) {
const {
border,
className,
colors = [],
enableAlpha = false,
enableStyle = true,
onChange,
previousStyleSelection,
size = "default",
__experimentalIsRenderedInSidebar = false,
...otherProps
} = useContextSystem(props, "BorderControlDropdown");
const [widthValue] = parseQuantityAndUnitFromRawValue(border?.width);
const hasZeroWidth = widthValue === 0;
const onColorChange = (color) => {
const style = border?.style === "none" ? previousStyleSelection : border?.style;
const width = hasZeroWidth && !!color ? "1px" : border?.width;
onChange({
color,
style,
width
});
};
const onStyleChange = (style) => {
const width = hasZeroWidth && !!style ? "1px" : border?.width;
onChange({
...border,
style,
width
});
};
const onReset = () => {
onChange({
...border,
color: void 0,
style: void 0
});
};
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderControlDropdown, className);
}, [className, cx]);
const indicatorClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderColorIndicator);
}, [cx]);
const indicatorWrapperClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(colorIndicatorWrapper(border, size));
}, [border, cx, size]);
const popoverControlsClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderControlPopoverControls);
}, [cx]);
const popoverContentClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderControlPopoverContent);
}, [cx]);
const resetButtonWrapperClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(resetButtonWrapper);
}, [cx]);
return {
...otherProps,
border,
className: classes,
colors,
enableAlpha,
enableStyle,
indicatorClassName,
indicatorWrapperClassName,
onColorChange,
onStyleChange,
onReset,
popoverContentClassName,
popoverControlsClassName,
resetButtonWrapperClassName,
size,
__experimentalIsRenderedInSidebar
};
}
;// ./node_modules/@wordpress/components/build-module/border-control/border-control-dropdown/component.js
const getAriaLabelColorValue = (colorValue) => {
return colorValue.replace(/^var\((.+)\)$/, "$1");
};
const getColorObject = (colorValue, colors) => {
if (!colorValue || !colors) {
return;
}
if (isMultiplePaletteArray(colors)) {
let matchedColor;
colors.some((origin) => origin.colors.some((color) => {
if (color.color === colorValue) {
matchedColor = color;
return true;
}
return false;
}));
return matchedColor;
}
return colors.find((color) => color.color === colorValue);
};
const getToggleAriaLabel = (colorValue, colorObject, style, isStyleEnabled) => {
if (isStyleEnabled) {
if (colorObject) {
const ariaLabelValue = getAriaLabelColorValue(colorObject.color);
return style ? (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The name of the color e.g. "vivid red". 2: The color's hex code e.g.: "#f00:". 3: The current border style selection e.g. "solid".
(0,external_wp_i18n_namespaceObject.__)('Border color and style picker. The currently selected color is called "%1$s" and has a value of "%2$s". The currently selected style is "%3$s".'),
colorObject.name,
ariaLabelValue,
style
) : (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The name of the color e.g. "vivid red". 2: The color's hex code e.g.: "#f00:".
(0,external_wp_i18n_namespaceObject.__)('Border color and style picker. The currently selected color is called "%1$s" and has a value of "%2$s".'),
colorObject.name,
ariaLabelValue
);
}
if (colorValue) {
const ariaLabelValue = getAriaLabelColorValue(colorValue);
return style ? (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The color's hex code e.g.: "#f00:". 2: The current border style selection e.g. "solid".
(0,external_wp_i18n_namespaceObject.__)('Border color and style picker. The currently selected color has a value of "%1$s". The currently selected style is "%2$s".'),
ariaLabelValue,
style
) : (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The color's hex code e.g: "#f00".
(0,external_wp_i18n_namespaceObject.__)('Border color and style picker. The currently selected color has a value of "%s".'),
ariaLabelValue
);
}
return (0,external_wp_i18n_namespaceObject.__)("Border color and style picker.");
}
if (colorObject) {
return (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The name of the color e.g. "vivid red". 2: The color's hex code e.g: "#f00".
(0,external_wp_i18n_namespaceObject.__)('Border color picker. The currently selected color is called "%1$s" and has a value of "%2$s".'),
colorObject.name,
getAriaLabelColorValue(colorObject.color)
);
}
if (colorValue) {
return (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The color's hex code e.g: "#f00".
(0,external_wp_i18n_namespaceObject.__)('Border color picker. The currently selected color has a value of "%s".'),
getAriaLabelColorValue(colorValue)
);
}
return (0,external_wp_i18n_namespaceObject.__)("Border color picker.");
};
const BorderControlDropdown = (props, forwardedRef) => {
const {
__experimentalIsRenderedInSidebar,
border,
colors,
disableCustomColors,
enableAlpha,
enableStyle,
indicatorClassName,
indicatorWrapperClassName,
isStyleSettable,
onReset,
onColorChange,
onStyleChange,
popoverContentClassName,
popoverControlsClassName,
resetButtonWrapperClassName,
size,
__unstablePopoverProps,
...otherProps
} = useBorderControlDropdown(props);
const {
color,
style
} = border || {};
const colorObject = getColorObject(color, colors);
const toggleAriaLabel = getToggleAriaLabel(color, colorObject, style, enableStyle);
const enableResetButton = color || style && style !== "none";
const dropdownPosition = __experimentalIsRenderedInSidebar ? "bottom left" : void 0;
const renderToggle = ({
onToggle
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
onClick: onToggle,
variant: "tertiary",
"aria-label": toggleAriaLabel,
tooltipPosition: dropdownPosition,
label: (0,external_wp_i18n_namespaceObject.__)("Border color and style picker"),
showTooltip: true,
__next40pxDefaultSize: size === "__unstable-large",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: indicatorWrapperClassName,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_indicator_default, {
className: indicatorClassName,
colorValue: color
})
})
});
const renderContent = () => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(dropdown_content_wrapper_default, {
paddingSize: "medium",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
className: popoverControlsClassName,
spacing: 6,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_palette_default, {
className: popoverContentClassName,
value: color,
onChange: onColorChange,
colors,
disableCustomColors,
__experimentalIsRenderedInSidebar,
clearable: false,
enableAlpha
}), enableStyle && isStyleSettable && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_control_style_picker_component_component_default, {
label: (0,external_wp_i18n_namespaceObject.__)("Style"),
value: style,
onChange: onStyleChange
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: resetButtonWrapperClassName,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
variant: "tertiary",
onClick: () => {
onReset();
},
disabled: !enableResetButton,
accessibleWhenDisabled: true,
__next40pxDefaultSize: true,
children: (0,external_wp_i18n_namespaceObject.__)("Reset")
})
})]
})
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_default, {
renderToggle,
renderContent,
popoverProps: {
...__unstablePopoverProps
},
...otherProps,
ref: forwardedRef
});
};
const ConnectedBorderControlDropdown = contextConnect(BorderControlDropdown, "BorderControlDropdown");
var border_control_dropdown_component_component_default = ConnectedBorderControlDropdown;
;// ./node_modules/@wordpress/components/build-module/unit-control/unit-select-control.js
function UnitSelectControl({
className,
isUnitSelectTabbable: isTabbable = true,
onChange,
size = "default",
unit = "px",
units = CSS_UNITS,
...props
}, ref) {
if (!hasUnits(units) || units?.length === 1) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(UnitLabel, {
className: "components-unit-control__unit-label",
selectSize: size,
children: unit
});
}
const handleOnChange = (event) => {
const {
value: unitValue
} = event.target;
const data = units.find((option) => option.value === unitValue);
onChange?.(unitValue, {
event,
data
});
};
const classes = dist_clsx("components-unit-control__select", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(UnitSelect, {
ref,
className: classes,
onChange: handleOnChange,
selectSize: size,
tabIndex: isTabbable ? void 0 : -1,
value: unit,
...props,
children: units.map((option) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("option", {
value: option.value,
children: option.label
}, option.value))
});
}
var unit_select_control_default = (0,external_wp_element_namespaceObject.forwardRef)(UnitSelectControl);
;// ./node_modules/@wordpress/components/build-module/unit-control/index.js
function UnforwardedUnitControl(unitControlProps, forwardedRef) {
const {
__unstableStateReducer,
autoComplete = "off",
// @ts-expect-error Ensure that children is omitted from restProps
children,
className,
disabled = false,
disableUnits = false,
isPressEnterToChange = false,
isResetValueOnUnitChange = false,
isUnitSelectTabbable = true,
label,
onChange: onChangeProp,
onUnitChange,
size = "default",
unit: unitProp,
units: unitsProp = CSS_UNITS,
value: valueProp,
onFocus: onFocusProp,
__shouldNotWarnDeprecated36pxSize,
...props
} = useDeprecated36pxDefaultSizeProp(unitControlProps);
maybeWarnDeprecated36pxSize({
componentName: "UnitControl",
__next40pxDefaultSize: props.__next40pxDefaultSize,
size,
__shouldNotWarnDeprecated36pxSize
});
if ("unit" in unitControlProps) {
external_wp_deprecated_default()("UnitControl unit prop", {
since: "5.6",
hint: "The unit should be provided within the `value` prop.",
version: "6.2"
});
}
const nonNullValueProp = valueProp !== null && valueProp !== void 0 ? valueProp : void 0;
const [units, reFirstCharacterOfUnits] = (0,external_wp_element_namespaceObject.useMemo)(() => {
const list = getUnitsWithCurrentUnit(nonNullValueProp, unitProp, unitsProp);
const [{
value: firstUnitValue = ""
} = {}, ...rest] = list;
const firstCharacters = rest.reduce((carry, {
value
}) => {
const first = escapeRegExp(value?.substring(0, 1) || "");
return carry.includes(first) ? carry : `${carry}|${first}`;
}, escapeRegExp(firstUnitValue.substring(0, 1)));
return [list, new RegExp(`^(?:${firstCharacters})$`, "i")];
}, [nonNullValueProp, unitProp, unitsProp]);
const [parsedQuantity, parsedUnit] = getParsedQuantityAndUnit(nonNullValueProp, unitProp, units);
const [unit, setUnit] = use_controlled_state_default(units.length === 1 ? units[0].value : unitProp, {
initial: parsedUnit,
fallback: ""
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (parsedUnit !== void 0) {
setUnit(parsedUnit);
}
}, [parsedUnit, setUnit]);
const classes = dist_clsx(
"components-unit-control",
// This class is added for legacy purposes to maintain it on the outer
// wrapper. See: https://github.com/WordPress/gutenberg/pull/45139
"components-unit-control-wrapper",
className
);
const handleOnQuantityChange = (nextQuantityValue, changeProps) => {
if (nextQuantityValue === "" || typeof nextQuantityValue === "undefined" || nextQuantityValue === null) {
onChangeProp?.("", changeProps);
return;
}
const onChangeValue = getValidParsedQuantityAndUnit(nextQuantityValue, units, parsedQuantity, unit).join("");
onChangeProp?.(onChangeValue, changeProps);
};
const handleOnUnitChange = (nextUnitValue, changeProps) => {
const {
data
} = changeProps;
let nextValue = `${parsedQuantity !== null && parsedQuantity !== void 0 ? parsedQuantity : ""}${nextUnitValue}`;
if (isResetValueOnUnitChange && data?.default !== void 0) {
nextValue = `${data.default}${nextUnitValue}`;
}
onChangeProp?.(nextValue, changeProps);
onUnitChange?.(nextUnitValue, changeProps);
setUnit(nextUnitValue);
};
let handleOnKeyDown;
if (!disableUnits && isUnitSelectTabbable && units.length) {
handleOnKeyDown = (event) => {
props.onKeyDown?.(event);
if (!event.metaKey && !event.ctrlKey && reFirstCharacterOfUnits.test(event.key)) {
refInputSuffix.current?.focus();
}
};
}
const refInputSuffix = (0,external_wp_element_namespaceObject.useRef)(null);
const inputSuffix = !disableUnits ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(unit_select_control_default, {
ref: refInputSuffix,
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Select unit"),
disabled,
isUnitSelectTabbable,
onChange: handleOnUnitChange,
size: ["small", "compact"].includes(size) || size === "default" && !props.__next40pxDefaultSize ? "small" : "default",
unit,
units,
onFocus: onFocusProp,
onBlur: unitControlProps.onBlur
}) : null;
let step = props.step;
if (!step && units) {
var _activeUnit$step;
const activeUnit = units.find((option) => option.value === unit);
step = (_activeUnit$step = activeUnit?.step) !== null && _activeUnit$step !== void 0 ? _activeUnit$step : 1;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ValueInput, {
...props,
__shouldNotWarnDeprecated36pxSize: true,
autoComplete,
className: classes,
disabled,
spinControls: "none",
isPressEnterToChange,
label,
onKeyDown: handleOnKeyDown,
onChange: handleOnQuantityChange,
ref: forwardedRef,
size,
suffix: inputSuffix,
type: isPressEnterToChange ? "text" : "number",
value: parsedQuantity !== null && parsedQuantity !== void 0 ? parsedQuantity : "",
step,
onFocus: onFocusProp,
__unstableStateReducer
});
}
const UnitControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedUnitControl);
var unit_control_default = UnitControl;
;// ./node_modules/@wordpress/components/build-module/border-control/border-control/hook.js
const isValidBorder = (border) => {
const hasWidth = border?.width !== void 0 && border.width !== "";
const hasColor = border?.color !== void 0;
return hasWidth || hasColor;
};
function useBorderControl(props) {
const {
className,
colors = [],
isCompact,
onChange,
enableAlpha = true,
enableStyle = true,
shouldSanitizeBorder = true,
size = "default",
value: border,
width,
__experimentalIsRenderedInSidebar = false,
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize,
...otherProps
} = useContextSystem(props, "BorderControl");
maybeWarnDeprecated36pxSize({
componentName: "BorderControl",
__next40pxDefaultSize,
size,
__shouldNotWarnDeprecated36pxSize
});
const computedSize = size === "default" && __next40pxDefaultSize ? "__unstable-large" : size;
const [widthValue, originalWidthUnit] = parseQuantityAndUnitFromRawValue(border?.width);
const widthUnit = originalWidthUnit || "px";
const hadPreviousZeroWidth = widthValue === 0;
const [colorSelection, setColorSelection] = (0,external_wp_element_namespaceObject.useState)();
const [styleSelection, setStyleSelection] = (0,external_wp_element_namespaceObject.useState)();
const isStyleSettable = shouldSanitizeBorder ? isValidBorder(border) : true;
const onBorderChange = (0,external_wp_element_namespaceObject.useCallback)((newBorder) => {
if (shouldSanitizeBorder && !isValidBorder(newBorder)) {
onChange(void 0);
return;
}
onChange(newBorder);
}, [onChange, shouldSanitizeBorder]);
const onWidthChange = (0,external_wp_element_namespaceObject.useCallback)((newWidth) => {
const newWidthValue = newWidth === "" ? void 0 : newWidth;
const [parsedValue] = parseQuantityAndUnitFromRawValue(newWidth);
const hasZeroWidth = parsedValue === 0;
const updatedBorder = {
...border,
width: newWidthValue
};
if (hasZeroWidth && !hadPreviousZeroWidth) {
setColorSelection(border?.color);
setStyleSelection(border?.style);
updatedBorder.color = void 0;
updatedBorder.style = "none";
}
if (!hasZeroWidth && hadPreviousZeroWidth) {
if (updatedBorder.color === void 0) {
updatedBorder.color = colorSelection;
}
if (updatedBorder.style === "none") {
updatedBorder.style = styleSelection;
}
}
onBorderChange(updatedBorder);
}, [border, hadPreviousZeroWidth, colorSelection, styleSelection, onBorderChange]);
const onSliderChange = (0,external_wp_element_namespaceObject.useCallback)((value) => {
onWidthChange(`${value}${widthUnit}`);
}, [onWidthChange, widthUnit]);
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderControl, className);
}, [className, cx]);
let wrapperWidth = width;
if (isCompact) {
wrapperWidth = size === "__unstable-large" ? "116px" : "90px";
}
const innerWrapperClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
const widthStyle = !!wrapperWidth && styles_wrapperWidth;
const heightStyle = wrapperHeight(computedSize);
return cx(innerWrapper(), widthStyle, heightStyle);
}, [wrapperWidth, cx, computedSize]);
const sliderClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderSlider());
}, [cx]);
return {
...otherProps,
className: classes,
colors,
enableAlpha,
enableStyle,
innerWrapperClassName,
inputWidth: wrapperWidth,
isStyleSettable,
onBorderChange,
onSliderChange,
onWidthChange,
previousStyleSelection: styleSelection,
sliderClassName,
value: border,
widthUnit,
widthValue,
size: computedSize,
__experimentalIsRenderedInSidebar,
__next40pxDefaultSize
};
}
;// ./node_modules/@wordpress/components/build-module/border-control/border-control/component.js
const BorderLabel = (props) => {
const {
label,
hideLabelFromVision
} = props;
if (!label) {
return null;
}
return hideLabelFromVision ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "legend",
children: label
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledLabel, {
as: "legend",
children: label
});
};
const UnconnectedBorderControl = (props, forwardedRef) => {
const {
__next40pxDefaultSize = false,
colors,
disableCustomColors,
disableUnits,
enableAlpha,
enableStyle,
hideLabelFromVision,
innerWrapperClassName,
inputWidth,
isStyleSettable,
label,
onBorderChange,
onSliderChange,
onWidthChange,
placeholder,
__unstablePopoverProps,
previousStyleSelection,
showDropdownHeader,
size,
sliderClassName,
value: border,
widthUnit,
widthValue,
withSlider,
__experimentalIsRenderedInSidebar,
...otherProps
} = useBorderControl(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(component_default, {
as: "fieldset",
...otherProps,
ref: forwardedRef,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BorderLabel, {
label,
hideLabelFromVision
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
spacing: 4,
className: innerWrapperClassName,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(unit_control_default, {
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true,
prefix: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
marginRight: 1,
marginBottom: 0,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_control_dropdown_component_component_default, {
border,
colors,
__unstablePopoverProps,
disableCustomColors,
enableAlpha,
enableStyle,
isStyleSettable,
onChange: onBorderChange,
previousStyleSelection,
__experimentalIsRenderedInSidebar,
size
})
}),
label: (0,external_wp_i18n_namespaceObject.__)("Border width"),
hideLabelFromVision: true,
min: 0,
onChange: onWidthChange,
value: border?.width || "",
placeholder,
disableUnits,
__unstableInputWidth: inputWidth,
size
}), withSlider && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(range_control_default, {
__nextHasNoMarginBottom: true,
label: (0,external_wp_i18n_namespaceObject.__)("Border width"),
hideLabelFromVision: true,
className: sliderClassName,
initialPosition: 0,
max: 100,
min: 0,
onChange: onSliderChange,
step: ["px", "%"].includes(widthUnit) ? 1 : 0.1,
value: widthValue || void 0,
withInputField: false,
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true
})]
})]
});
};
const BorderControl = contextConnect(UnconnectedBorderControl, "BorderControl");
var border_control_component_component_default = BorderControl;
;// ./node_modules/@wordpress/components/build-module/grid/utils.js
const utils_ALIGNMENTS = {
bottom: {
alignItems: "flex-end",
justifyContent: "center"
},
bottomLeft: {
alignItems: "flex-start",
justifyContent: "flex-end"
},
bottomRight: {
alignItems: "flex-end",
justifyContent: "flex-end"
},
center: {
alignItems: "center",
justifyContent: "center"
},
spaced: {
alignItems: "center",
justifyContent: "space-between"
},
left: {
alignItems: "center",
justifyContent: "flex-start"
},
right: {
alignItems: "center",
justifyContent: "flex-end"
},
stretch: {
alignItems: "stretch"
},
top: {
alignItems: "flex-start",
justifyContent: "center"
},
topLeft: {
alignItems: "flex-start",
justifyContent: "flex-start"
},
topRight: {
alignItems: "flex-start",
justifyContent: "flex-end"
}
};
function utils_getAlignmentProps(alignment) {
const alignmentProps = alignment ? utils_ALIGNMENTS[alignment] : {};
return alignmentProps;
}
;// ./node_modules/@wordpress/components/build-module/grid/hook.js
function useGrid(props) {
const {
align,
alignment,
className,
columnGap,
columns = 2,
gap = 3,
isInline = false,
justify,
rowGap,
rows,
templateColumns,
templateRows,
...otherProps
} = useContextSystem(props, "Grid");
const columnsAsArray = Array.isArray(columns) ? columns : [columns];
const column = useResponsiveValue(columnsAsArray);
const rowsAsArray = Array.isArray(rows) ? rows : [rows];
const row = useResponsiveValue(rowsAsArray);
const gridTemplateColumns = templateColumns || !!columns && `repeat( ${column}, 1fr )`;
const gridTemplateRows = templateRows || !!rows && `repeat( ${row}, 1fr )`;
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
const alignmentProps = utils_getAlignmentProps(alignment);
const gridClasses = /* @__PURE__ */ emotion_react_browser_esm_css({
alignItems: align,
display: isInline ? "inline-grid" : "grid",
gap: `calc( ${config_values_default.gridBase} * ${gap} )`,
gridTemplateColumns: gridTemplateColumns || void 0,
gridTemplateRows: gridTemplateRows || void 0,
gridRowGap: rowGap,
gridColumnGap: columnGap,
justifyContent: justify,
verticalAlign: isInline ? "middle" : void 0,
...alignmentProps
}, true ? "" : 0, true ? "" : 0);
return cx(gridClasses, className);
}, [align, alignment, className, columnGap, cx, gap, gridTemplateColumns, gridTemplateRows, isInline, justify, rowGap]);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/grid/component.js
function UnconnectedGrid(props, forwardedRef) {
const gridProps = useGrid(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...gridProps,
ref: forwardedRef
});
}
const Grid = contextConnect(UnconnectedGrid, "Grid");
var grid_component_component_default = Grid;
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control-split-controls/hook.js
function useBorderBoxControlSplitControls(props) {
const {
className,
colors = [],
enableAlpha = false,
enableStyle = true,
size = "default",
__experimentalIsRenderedInSidebar = false,
...otherProps
} = useContextSystem(props, "BorderBoxControlSplitControls");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderBoxControlSplitControls(size), className);
}, [cx, className, size]);
const centeredClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(centeredBorderControl, className);
}, [cx, className]);
const rightAlignedClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(rightBorderControl(), className);
}, [cx, className]);
return {
...otherProps,
centeredClassName,
className: classes,
colors,
enableAlpha,
enableStyle,
rightAlignedClassName,
size,
__experimentalIsRenderedInSidebar
};
}
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control-split-controls/component.js
const BorderBoxControlSplitControls = (props, forwardedRef) => {
const {
centeredClassName,
colors,
disableCustomColors,
enableAlpha,
enableStyle,
onChange,
popoverPlacement,
popoverOffset,
rightAlignedClassName,
size = "default",
value,
__experimentalIsRenderedInSidebar,
...otherProps
} = useBorderBoxControlSplitControls(props);
const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
const popoverProps = (0,external_wp_element_namespaceObject.useMemo)(() => popoverPlacement ? {
placement: popoverPlacement,
offset: popoverOffset,
anchor: popoverAnchor,
shift: true
} : void 0, [popoverPlacement, popoverOffset, popoverAnchor]);
const sharedBorderControlProps = {
colors,
disableCustomColors,
enableAlpha,
enableStyle,
isCompact: true,
__experimentalIsRenderedInSidebar,
size,
__shouldNotWarnDeprecated36pxSize: true
};
const mergedRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([setPopoverAnchor, forwardedRef]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(grid_component_component_default, {
...otherProps,
ref: mergedRef,
gap: 3,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_box_control_visualizer_component_component_default, {
value,
size
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_control_component_component_default, {
className: centeredClassName,
hideLabelFromVision: true,
label: (0,external_wp_i18n_namespaceObject.__)("Top border"),
onChange: (newBorder) => onChange(newBorder, "top"),
__unstablePopoverProps: popoverProps,
value: value?.top,
...sharedBorderControlProps
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_control_component_component_default, {
hideLabelFromVision: true,
label: (0,external_wp_i18n_namespaceObject.__)("Left border"),
onChange: (newBorder) => onChange(newBorder, "left"),
__unstablePopoverProps: popoverProps,
value: value?.left,
...sharedBorderControlProps
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_control_component_component_default, {
className: rightAlignedClassName,
hideLabelFromVision: true,
label: (0,external_wp_i18n_namespaceObject.__)("Right border"),
onChange: (newBorder) => onChange(newBorder, "right"),
__unstablePopoverProps: popoverProps,
value: value?.right,
...sharedBorderControlProps
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_control_component_component_default, {
className: centeredClassName,
hideLabelFromVision: true,
label: (0,external_wp_i18n_namespaceObject.__)("Bottom border"),
onChange: (newBorder) => onChange(newBorder, "bottom"),
__unstablePopoverProps: popoverProps,
value: value?.bottom,
...sharedBorderControlProps
})]
});
};
const ConnectedBorderBoxControlSplitControls = contextConnect(BorderBoxControlSplitControls, "BorderBoxControlSplitControls");
var border_box_control_split_controls_component_component_default = ConnectedBorderBoxControlSplitControls;
;// ./node_modules/@wordpress/components/build-module/utils/unit-values.js
const UNITED_VALUE_REGEX = /^([\d.\-+]*)\s*(fr|cm|mm|Q|in|pc|pt|px|em|ex|ch|rem|lh|vw|vh|vmin|vmax|%|cap|ic|rlh|vi|vb|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx|svw|lvw|dvw|svh|lvh|dvh|svi|lvi|dvi|svb|lvb|dvb|svmin|lvmin|dvmin|svmax|lvmax|dvmax)?$/;
function parseCSSUnitValue(toParse) {
const value = toParse.trim();
const matched = value.match(UNITED_VALUE_REGEX);
if (!matched) {
return [void 0, void 0];
}
const [, num, unit] = matched;
let numParsed = parseFloat(num);
numParsed = Number.isNaN(numParsed) ? void 0 : numParsed;
return [numParsed, unit];
}
function createCSSUnitValue(value, unit) {
return `${value}${unit}`;
}
;// ./node_modules/@wordpress/components/build-module/border-box-control/utils.js
const utils_sides = ["top", "right", "bottom", "left"];
const borderProps = ["color", "style", "width"];
const isEmptyBorder = (border) => {
if (!border) {
return true;
}
return !borderProps.some((prop) => border[prop] !== void 0);
};
const isDefinedBorder = (border) => {
if (!border) {
return false;
}
if (hasSplitBorders(border)) {
const allSidesEmpty = utils_sides.every((side) => isEmptyBorder(border[side]));
return !allSidesEmpty;
}
return !isEmptyBorder(border);
};
const isCompleteBorder = (border) => {
if (!border) {
return false;
}
return borderProps.every((prop) => border[prop] !== void 0);
};
const hasSplitBorders = (border = {}) => {
return Object.keys(border).some((side) => utils_sides.indexOf(side) !== -1);
};
const hasMixedBorders = (borders) => {
if (!hasSplitBorders(borders)) {
return false;
}
const shorthandBorders = utils_sides.map((side) => getShorthandBorderStyle(borders?.[side]));
return !shorthandBorders.every((border) => border === shorthandBorders[0]);
};
const getSplitBorders = (border) => {
if (!border || isEmptyBorder(border)) {
return void 0;
}
return {
top: border,
right: border,
bottom: border,
left: border
};
};
const getBorderDiff = (original, updated) => {
const diff = {};
if (original.color !== updated.color) {
diff.color = updated.color;
}
if (original.style !== updated.style) {
diff.style = updated.style;
}
if (original.width !== updated.width) {
diff.width = updated.width;
}
return diff;
};
const getCommonBorder = (borders) => {
if (!borders) {
return void 0;
}
const colors = [];
const styles = [];
const widths = [];
utils_sides.forEach((side) => {
colors.push(borders[side]?.color);
styles.push(borders[side]?.style);
widths.push(borders[side]?.width);
});
const allColorsMatch = colors.every((value) => value === colors[0]);
const allStylesMatch = styles.every((value) => value === styles[0]);
const allWidthsMatch = widths.every((value) => value === widths[0]);
return {
color: allColorsMatch ? colors[0] : void 0,
style: allStylesMatch ? styles[0] : void 0,
width: allWidthsMatch ? widths[0] : getMostCommonUnit(widths)
};
};
const getShorthandBorderStyle = (border, fallbackBorder) => {
if (isEmptyBorder(border)) {
return fallbackBorder;
}
const {
color: fallbackColor,
style: fallbackStyle,
width: fallbackWidth
} = fallbackBorder || {};
const {
color = fallbackColor,
style = fallbackStyle,
width = fallbackWidth
} = border;
const hasVisibleBorder = !!width && width !== "0" || !!color;
const borderStyle = hasVisibleBorder ? style || "solid" : style;
return [width, borderStyle, color].filter(Boolean).join(" ");
};
const getMostCommonUnit = (values) => {
const units = values.map((value) => value === void 0 ? void 0 : parseCSSUnitValue(`${value}`)[1]);
const filteredUnits = units.filter((value) => value !== void 0);
return mode(filteredUnits);
};
function mode(values) {
if (values.length === 0) {
return void 0;
}
const map = {};
let maxCount = 0;
let currentMode;
values.forEach((value) => {
map[value] = map[value] === void 0 ? 1 : map[value] + 1;
if (map[value] > maxCount) {
currentMode = value;
maxCount = map[value];
}
});
return currentMode;
}
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control/hook.js
function useBorderBoxControl(props) {
const {
className,
colors = [],
onChange,
enableAlpha = false,
enableStyle = true,
size = "default",
value,
__experimentalIsRenderedInSidebar = false,
__next40pxDefaultSize,
...otherProps
} = useContextSystem(props, "BorderBoxControl");
maybeWarnDeprecated36pxSize({
componentName: "BorderBoxControl",
__next40pxDefaultSize,
size
});
const computedSize = size === "default" && __next40pxDefaultSize ? "__unstable-large" : size;
const mixedBorders = hasMixedBorders(value);
const splitBorders = hasSplitBorders(value);
const linkedValue = splitBorders ? getCommonBorder(value) : value;
const splitValue = splitBorders ? value : getSplitBorders(value);
const hasWidthValue = !isNaN(parseFloat(`${linkedValue?.width}`));
const [isLinked, setIsLinked] = (0,external_wp_element_namespaceObject.useState)(!mixedBorders);
const toggleLinked = () => setIsLinked(!isLinked);
const onLinkedChange = (newBorder) => {
if (!newBorder) {
return onChange(void 0);
}
if (!mixedBorders || isCompleteBorder(newBorder)) {
return onChange(isEmptyBorder(newBorder) ? void 0 : newBorder);
}
const changes = getBorderDiff(linkedValue, newBorder);
const updatedBorders = {
top: {
...value?.top,
...changes
},
right: {
...value?.right,
...changes
},
bottom: {
...value?.bottom,
...changes
},
left: {
...value?.left,
...changes
}
};
if (hasMixedBorders(updatedBorders)) {
return onChange(updatedBorders);
}
const filteredResult = isEmptyBorder(updatedBorders.top) ? void 0 : updatedBorders.top;
onChange(filteredResult);
};
const onSplitChange = (newBorder, side) => {
const updatedBorders = {
...splitValue,
[side]: newBorder
};
if (hasMixedBorders(updatedBorders)) {
onChange(updatedBorders);
} else {
onChange(newBorder);
}
};
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(borderBoxControl, className);
}, [cx, className]);
const linkedControlClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(linkedBorderControl());
}, [cx]);
const wrapperClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(wrapper);
}, [cx]);
return {
...otherProps,
className: classes,
colors,
disableUnits: mixedBorders && !hasWidthValue,
enableAlpha,
enableStyle,
hasMixedBorders: mixedBorders,
isLinked,
linkedControlClassName,
onLinkedChange,
onSplitChange,
toggleLinked,
linkedValue,
size: computedSize,
splitValue,
wrapperClassName,
__experimentalIsRenderedInSidebar
};
}
;// ./node_modules/@wordpress/components/build-module/border-box-control/border-box-control/component.js
const component_BorderLabel = (props) => {
const {
label,
hideLabelFromVision
} = props;
if (!label) {
return null;
}
return hideLabelFromVision ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "label",
children: label
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledLabel, {
children: label
});
};
const UnconnectedBorderBoxControl = (props, forwardedRef) => {
const {
className,
colors,
disableCustomColors,
disableUnits,
enableAlpha,
enableStyle,
hasMixedBorders,
hideLabelFromVision,
isLinked,
label,
linkedControlClassName,
linkedValue,
onLinkedChange,
onSplitChange,
popoverPlacement,
popoverOffset,
size,
splitValue,
toggleLinked,
wrapperClassName,
__experimentalIsRenderedInSidebar,
...otherProps
} = useBorderBoxControl(props);
const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
const popoverProps = (0,external_wp_element_namespaceObject.useMemo)(() => popoverPlacement ? {
placement: popoverPlacement,
offset: popoverOffset,
anchor: popoverAnchor,
shift: true
} : void 0, [popoverPlacement, popoverOffset, popoverAnchor]);
const mergedRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([setPopoverAnchor, forwardedRef]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(component_default, {
className,
...otherProps,
ref: mergedRef,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_BorderLabel, {
label,
hideLabelFromVision
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(component_default, {
className: wrapperClassName,
children: [isLinked ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_control_component_component_default, {
className: linkedControlClassName,
colors,
disableUnits,
disableCustomColors,
enableAlpha,
enableStyle,
onChange: onLinkedChange,
placeholder: hasMixedBorders ? (0,external_wp_i18n_namespaceObject.__)("Mixed") : void 0,
__unstablePopoverProps: popoverProps,
shouldSanitizeBorder: false,
value: linkedValue,
withSlider: true,
width: size === "__unstable-large" ? "116px" : "110px",
__experimentalIsRenderedInSidebar,
__shouldNotWarnDeprecated36pxSize: true,
size
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_box_control_split_controls_component_component_default, {
colors,
disableCustomColors,
enableAlpha,
enableStyle,
onChange: onSplitChange,
popoverPlacement,
popoverOffset,
value: splitValue,
__experimentalIsRenderedInSidebar,
size
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(border_box_control_linked_button_component_component_default, {
onClick: toggleLinked,
isLinked,
size
})]
})]
});
};
const BorderBoxControl = contextConnect(UnconnectedBorderBoxControl, "BorderBoxControl");
var border_box_control_component_component_default = BorderBoxControl;
;// ./node_modules/@wordpress/icons/build-module/library/settings.js
var settings_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: [
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "m19 7.5h-7.628c-.3089-.87389-1.1423-1.5-2.122-1.5-.97966 0-1.81309.62611-2.12197 1.5h-2.12803v1.5h2.12803c.30888.87389 1.14231 1.5 2.12197 1.5.9797 0 1.8131-.62611 2.122-1.5h7.628z" }),
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "m19 15h-2.128c-.3089-.8739-1.1423-1.5-2.122-1.5s-1.8131.6261-2.122 1.5h-7.628v1.5h7.628c.3089.8739 1.1423 1.5 2.122 1.5s1.8131-.6261 2.122-1.5h2.128z" })
] });
;// ./node_modules/@wordpress/components/build-module/box-control/utils.js
const CUSTOM_VALUE_SETTINGS = {
px: {
max: 300,
step: 1
},
"%": {
max: 100,
step: 1
},
vw: {
max: 100,
step: 1
},
vh: {
max: 100,
step: 1
},
em: {
max: 10,
step: 0.1
},
rm: {
max: 10,
step: 0.1
},
svw: {
max: 100,
step: 1
},
lvw: {
max: 100,
step: 1
},
dvw: {
max: 100,
step: 1
},
svh: {
max: 100,
step: 1
},
lvh: {
max: 100,
step: 1
},
dvh: {
max: 100,
step: 1
},
vi: {
max: 100,
step: 1
},
svi: {
max: 100,
step: 1
},
lvi: {
max: 100,
step: 1
},
dvi: {
max: 100,
step: 1
},
vb: {
max: 100,
step: 1
},
svb: {
max: 100,
step: 1
},
lvb: {
max: 100,
step: 1
},
dvb: {
max: 100,
step: 1
},
vmin: {
max: 100,
step: 1
},
svmin: {
max: 100,
step: 1
},
lvmin: {
max: 100,
step: 1
},
dvmin: {
max: 100,
step: 1
},
vmax: {
max: 100,
step: 1
},
svmax: {
max: 100,
step: 1
},
lvmax: {
max: 100,
step: 1
},
dvmax: {
max: 100,
step: 1
}
};
const LABELS = {
all: (0,external_wp_i18n_namespaceObject.__)("All sides"),
top: (0,external_wp_i18n_namespaceObject.__)("Top side"),
bottom: (0,external_wp_i18n_namespaceObject.__)("Bottom side"),
left: (0,external_wp_i18n_namespaceObject.__)("Left side"),
right: (0,external_wp_i18n_namespaceObject.__)("Right side"),
vertical: (0,external_wp_i18n_namespaceObject.__)("Top and bottom sides"),
horizontal: (0,external_wp_i18n_namespaceObject.__)("Left and right sides")
};
const DEFAULT_VALUES = {
top: void 0,
right: void 0,
bottom: void 0,
left: void 0
};
const ALL_SIDES = ["top", "right", "bottom", "left"];
function utils_mode(arr) {
return arr.sort((a, b) => arr.filter((v) => v === a).length - arr.filter((v) => v === b).length).pop();
}
function getMergedValue(values = {}, availableSides = ALL_SIDES) {
const sides = normalizeSides(availableSides);
if (sides.every((side) => values[side] === values[sides[0]])) {
return values[sides[0]];
}
return void 0;
}
function isValueMixed(values = {}, availableSides = ALL_SIDES) {
const sides = normalizeSides(availableSides);
return sides.some((side) => values[side] !== values[sides[0]]);
}
function getAllUnitFallback(selectedUnits) {
if (!selectedUnits || typeof selectedUnits !== "object") {
return void 0;
}
const filteredUnits = Object.values(selectedUnits).filter(Boolean);
return utils_mode(filteredUnits);
}
function isValuesDefined(values) {
return values && Object.values(values).filter(
// Switching units when input is empty causes values only
// containing units. This gives false positive on mixed values
// unless filtered.
(value) => !!value && /\d/.test(value)
).length > 0;
}
function getInitialSide(isLinked, splitOnAxis) {
let initialSide = "all";
if (!isLinked) {
initialSide = splitOnAxis ? "vertical" : "top";
}
return initialSide;
}
function normalizeSides(sides) {
const filteredSides = [];
if (!sides?.length) {
return ALL_SIDES;
}
if (sides.includes("vertical")) {
filteredSides.push(...["top", "bottom"]);
} else if (sides.includes("horizontal")) {
filteredSides.push(...["left", "right"]);
} else {
const newSides = ALL_SIDES.filter((side) => sides.includes(side));
filteredSides.push(...newSides);
}
return filteredSides;
}
function applyValueToSides(currentValues, newValue, sides) {
external_wp_deprecated_default()("applyValueToSides", {
since: "6.8",
version: "7.0"
});
const newValues = {
...currentValues
};
if (sides?.length) {
sides.forEach((side) => {
if (side === "vertical") {
newValues.top = newValue;
newValues.bottom = newValue;
} else if (side === "horizontal") {
newValues.left = newValue;
newValues.right = newValue;
} else {
newValues[side] = newValue;
}
});
} else {
ALL_SIDES.forEach((side) => newValues[side] = newValue);
}
return newValues;
}
function getAllowedSides(sides) {
const allowedSides = new Set(!sides ? ALL_SIDES : []);
sides?.forEach((allowedSide) => {
if (allowedSide === "vertical") {
allowedSides.add("top");
allowedSides.add("bottom");
} else if (allowedSide === "horizontal") {
allowedSides.add("right");
allowedSides.add("left");
} else {
allowedSides.add(allowedSide);
}
});
return allowedSides;
}
function isValuePreset(value, presetKey) {
return value.startsWith(`var:preset|${presetKey}|`);
}
function getPresetIndexFromValue(value, presetKey, presets) {
if (!isValuePreset(value, presetKey)) {
return void 0;
}
const match = value.match(new RegExp(`^var:preset\\|${presetKey}\\|(.+)$`));
if (!match) {
return void 0;
}
const slug = match[1];
const index = presets.findIndex((preset) => {
return preset.slug === slug;
});
return index !== -1 ? index : void 0;
}
function getPresetValueFromIndex(index, presetKey, presets) {
const preset = presets[index];
return `var:preset|${presetKey}|${preset.slug}`;
}
;// ./node_modules/@wordpress/components/build-module/box-control/styles/box-control-icon-styles.js
function box_control_icon_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const box_control_icon_styles_Root = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1j5nr4z8"
} : 0)( true ? {
name: "1w884gc",
styles: "box-sizing:border-box;display:block;width:24px;height:24px;position:relative;padding:4px"
} : 0);
const Viewbox = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1j5nr4z7"
} : 0)( true ? {
name: "i6vjox",
styles: "box-sizing:border-box;display:block;position:relative;width:100%;height:100%"
} : 0);
const strokeFocus = ({
isFocused
}) => {
return /* @__PURE__ */ emotion_react_browser_esm_css({
backgroundColor: "currentColor",
opacity: isFocused ? 1 : 0.3
}, true ? "" : 0, true ? "" : 0);
};
const Stroke = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1j5nr4z6"
} : 0)("box-sizing:border-box;display:block;pointer-events:none;position:absolute;", strokeFocus, ";" + ( true ? "" : 0));
const VerticalStroke = /* @__PURE__ */ emotion_styled_base_browser_esm(Stroke, true ? {
target: "e1j5nr4z5"
} : 0)( true ? {
name: "1k2w39q",
styles: "bottom:3px;top:3px;width:2px"
} : 0);
const HorizontalStroke = /* @__PURE__ */ emotion_styled_base_browser_esm(Stroke, true ? {
target: "e1j5nr4z4"
} : 0)( true ? {
name: "1q9b07k",
styles: "height:2px;left:3px;right:3px"
} : 0);
const TopStroke = /* @__PURE__ */ emotion_styled_base_browser_esm(HorizontalStroke, true ? {
target: "e1j5nr4z3"
} : 0)( true ? {
name: "abcix4",
styles: "top:0"
} : 0);
const RightStroke = /* @__PURE__ */ emotion_styled_base_browser_esm(VerticalStroke, true ? {
target: "e1j5nr4z2"
} : 0)( true ? {
name: "1wf8jf",
styles: "right:0"
} : 0);
const BottomStroke = /* @__PURE__ */ emotion_styled_base_browser_esm(HorizontalStroke, true ? {
target: "e1j5nr4z1"
} : 0)( true ? {
name: "8tapst",
styles: "bottom:0"
} : 0);
const LeftStroke = /* @__PURE__ */ emotion_styled_base_browser_esm(VerticalStroke, true ? {
target: "e1j5nr4z0"
} : 0)( true ? {
name: "1ode3cm",
styles: "left:0"
} : 0);
;// ./node_modules/@wordpress/components/build-module/box-control/icon.js
const BASE_ICON_SIZE = 24;
function BoxControlIcon({
size = 24,
side = "all",
sides,
...props
}) {
const isSideDisabled = (value) => sides?.length && !sides.includes(value);
const hasSide = (value) => {
if (isSideDisabled(value)) {
return false;
}
return side === "all" || side === value;
};
const top = hasSide("top") || hasSide("vertical");
const right = hasSide("right") || hasSide("horizontal");
const bottom = hasSide("bottom") || hasSide("vertical");
const left = hasSide("left") || hasSide("horizontal");
const scale = size / BASE_ICON_SIZE;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(box_control_icon_styles_Root, {
style: {
transform: `scale(${scale})`
},
...props,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Viewbox, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TopStroke, {
isFocused: top
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RightStroke, {
isFocused: right
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BottomStroke, {
isFocused: bottom
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LeftStroke, {
isFocused: left
})]
})
});
}
;// ./node_modules/@wordpress/components/build-module/box-control/styles/box-control-styles.js
function box_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const StyledUnitControl = /* @__PURE__ */ emotion_styled_base_browser_esm(unit_control_default, true ? {
target: "e1jovhle5"
} : 0)( true ? {
name: "1ejyr19",
styles: "max-width:90px"
} : 0);
const InputWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(h_stack_component_component_default, true ? {
target: "e1jovhle4"
} : 0)( true ? {
name: "1j1lmoi",
styles: "grid-column:1/span 3"
} : 0);
const ResetButton = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "e1jovhle3"
} : 0)( true ? {
name: "tkya7b",
styles: "grid-area:1/2;justify-self:end"
} : 0);
const LinkedButtonWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1jovhle2"
} : 0)( true ? {
name: "1dfa8al",
styles: "grid-area:1/3;justify-self:end"
} : 0);
const FlexedBoxControlIcon = /* @__PURE__ */ emotion_styled_base_browser_esm(BoxControlIcon, true ? {
target: "e1jovhle1"
} : 0)( true ? {
name: "ou8xsw",
styles: "flex:0 0 auto"
} : 0);
const FlexedRangeControl = /* @__PURE__ */ emotion_styled_base_browser_esm(range_control_default, true ? {
target: "e1jovhle0"
} : 0)("width:100%;margin-inline-end:", space(2), ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/box-control/input-control.js
const box_control_input_control_noop = () => {
};
function getSidesToModify(side, sides, isAlt) {
const allowedSides = getAllowedSides(sides);
let modifiedSides = [];
switch (side) {
case "all":
modifiedSides = ["top", "bottom", "left", "right"];
break;
case "horizontal":
modifiedSides = ["left", "right"];
break;
case "vertical":
modifiedSides = ["top", "bottom"];
break;
default:
modifiedSides = [side];
}
if (isAlt) {
switch (side) {
case "top":
modifiedSides.push("bottom");
break;
case "bottom":
modifiedSides.push("top");
break;
case "left":
modifiedSides.push("left");
break;
case "right":
modifiedSides.push("right");
break;
}
}
return modifiedSides.filter((s) => allowedSides.has(s));
}
function BoxInputControl({
__next40pxDefaultSize,
onChange = box_control_input_control_noop,
onFocus = box_control_input_control_noop,
values,
selectedUnits,
setSelectedUnits,
sides,
side,
min = 0,
presets,
presetKey,
...props
}) {
var _CUSTOM_VALUE_SETTING, _CUSTOM_VALUE_SETTING2;
const defaultValuesToModify = getSidesToModify(side, sides);
const handleOnFocus = (event) => {
onFocus(event, {
side
});
};
const handleOnChange = (nextValues) => {
onChange(nextValues);
};
const handleRawOnValueChange = (next) => {
const nextValues = {
...values
};
defaultValuesToModify.forEach((modifiedSide) => {
nextValues[modifiedSide] = next;
});
handleOnChange(nextValues);
};
const handleOnValueChange = (next, extra) => {
const nextValues = {
...values
};
const isNumeric = next !== void 0 && !isNaN(parseFloat(next));
const nextValue = isNumeric ? next : void 0;
const modifiedSides = getSidesToModify(
side,
sides,
/**
* Supports changing pair sides. For example, holding the ALT key
* when changing the TOP will also update BOTTOM.
*/
// @ts-expect-error - TODO: event.altKey is only present when the change event was
// triggered by a keyboard event. Should this feature be implemented differently so
// it also works with drag events?
!!extra?.event.altKey
);
modifiedSides.forEach((modifiedSide) => {
nextValues[modifiedSide] = nextValue;
});
handleOnChange(nextValues);
};
const handleOnUnitChange = (next) => {
const newUnits = {
...selectedUnits
};
defaultValuesToModify.forEach((modifiedSide) => {
newUnits[modifiedSide] = next;
});
setSelectedUnits(newUnits);
};
const mergedValue = getMergedValue(values, defaultValuesToModify);
const hasValues = isValuesDefined(values);
const isMixed = hasValues && defaultValuesToModify.length > 1 && isValueMixed(values, defaultValuesToModify);
const [parsedQuantity, parsedUnit] = parseQuantityAndUnitFromRawValue(mergedValue);
const computedUnit = hasValues ? parsedUnit : selectedUnits[defaultValuesToModify[0]];
const generatedId = (0,external_wp_compose_namespaceObject.useInstanceId)(BoxInputControl, "box-control-input");
const inputId = [generatedId, side].join("-");
const isMixedUnit = defaultValuesToModify.length > 1 && mergedValue === void 0 && defaultValuesToModify.some((s) => selectedUnits[s] !== computedUnit);
const usedValue = mergedValue === void 0 && computedUnit ? computedUnit : mergedValue;
const mixedPlaceholder = isMixed || isMixedUnit ? (0,external_wp_i18n_namespaceObject.__)("Mixed") : void 0;
const hasPresets = presets && presets.length > 0 && presetKey;
const hasPresetValue = hasPresets && mergedValue !== void 0 && !isMixed && isValuePreset(mergedValue, presetKey);
const [showCustomValueControl, setShowCustomValueControl] = (0,external_wp_element_namespaceObject.useState)(!hasPresets || !hasPresetValue && !isMixed && mergedValue !== void 0);
const presetIndex = hasPresetValue ? getPresetIndexFromValue(mergedValue, presetKey, presets) : void 0;
const marks = hasPresets ? [{
value: 0,
label: "",
tooltip: (0,external_wp_i18n_namespaceObject.__)("None")
}, ...presets.map((preset, index) => {
var _preset$name;
return {
value: index + 1,
label: "",
tooltip: (_preset$name = preset.name) !== null && _preset$name !== void 0 ? _preset$name : preset.slug
};
})] : [];
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(InputWrapper, {
expanded: true,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexedBoxControlIcon, {
side,
sides
}), showCustomValueControl && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tooltip_default, {
placement: "top-end",
text: LABELS[side],
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledUnitControl, {
...props,
min,
__shouldNotWarnDeprecated36pxSize: true,
__next40pxDefaultSize,
className: "component-box-control__unit-control",
id: inputId,
isPressEnterToChange: true,
disableUnits: isMixed || isMixedUnit,
value: usedValue,
onChange: handleOnValueChange,
onUnitChange: handleOnUnitChange,
onFocus: handleOnFocus,
label: LABELS[side],
placeholder: mixedPlaceholder,
hideLabelFromVision: true
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexedRangeControl, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true,
"aria-controls": inputId,
label: LABELS[side],
hideLabelFromVision: true,
onChange: (newValue) => {
handleOnValueChange(newValue !== void 0 ? [newValue, computedUnit].join("") : void 0);
},
min: isFinite(min) ? min : 0,
max: (_CUSTOM_VALUE_SETTING = CUSTOM_VALUE_SETTINGS[computedUnit !== null && computedUnit !== void 0 ? computedUnit : "px"]?.max) !== null && _CUSTOM_VALUE_SETTING !== void 0 ? _CUSTOM_VALUE_SETTING : 10,
step: (_CUSTOM_VALUE_SETTING2 = CUSTOM_VALUE_SETTINGS[computedUnit !== null && computedUnit !== void 0 ? computedUnit : "px"]?.step) !== null && _CUSTOM_VALUE_SETTING2 !== void 0 ? _CUSTOM_VALUE_SETTING2 : 0.1,
value: parsedQuantity !== null && parsedQuantity !== void 0 ? parsedQuantity : 0,
withInputField: false
})]
}), hasPresets && !showCustomValueControl && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FlexedRangeControl, {
__next40pxDefaultSize: true,
className: "spacing-sizes-control__range-control",
value: presetIndex !== void 0 ? presetIndex + 1 : 0,
onChange: (newIndex) => {
const newValue = newIndex === 0 || newIndex === void 0 ? void 0 : getPresetValueFromIndex(newIndex - 1, presetKey, presets);
handleRawOnValueChange(newValue);
},
withInputField: false,
"aria-valuenow": presetIndex !== void 0 ? presetIndex + 1 : 0,
"aria-valuetext": marks[presetIndex !== void 0 ? presetIndex + 1 : 0].tooltip,
renderTooltipContent: (index) => marks[!index ? 0 : index].tooltip,
min: 0,
max: marks.length - 1,
marks,
label: LABELS[side],
hideLabelFromVision: true,
__nextHasNoMarginBottom: true
}), hasPresets && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
label: showCustomValueControl ? (0,external_wp_i18n_namespaceObject.__)("Use size preset") : (0,external_wp_i18n_namespaceObject.__)("Set custom size"),
icon: settings_default,
onClick: () => {
setShowCustomValueControl(!showCustomValueControl);
},
isPressed: showCustomValueControl,
size: "small",
iconSize: 24
})]
}, `box-control-${side}`);
}
;// ./node_modules/@wordpress/components/build-module/box-control/linked-button.js
function LinkedButton({
isLinked,
...props
}) {
const label = isLinked ? (0,external_wp_i18n_namespaceObject.__)("Unlink sides") : (0,external_wp_i18n_namespaceObject.__)("Link sides");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
...props,
className: "component-box-control__linked-button",
size: "small",
icon: isLinked ? link_default : link_off_default,
iconSize: 24,
label
});
}
;// ./node_modules/@wordpress/components/build-module/box-control/index.js
const defaultInputProps = {
min: 0
};
const box_control_noop = () => {
};
function box_control_useUniqueId(idProp) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(BoxControl, "inspector-box-control");
return idProp || instanceId;
}
function BoxControl({
__next40pxDefaultSize = false,
id: idProp,
inputProps = defaultInputProps,
onChange = box_control_noop,
label = (0,external_wp_i18n_namespaceObject.__)("Box Control"),
values: valuesProp,
units,
sides,
splitOnAxis = false,
allowReset = true,
resetValues = DEFAULT_VALUES,
presets,
presetKey,
onMouseOver,
onMouseOut
}) {
const [values, setValues] = use_controlled_state_default(valuesProp, {
fallback: DEFAULT_VALUES
});
const inputValues = values || DEFAULT_VALUES;
const hasInitialValue = isValuesDefined(valuesProp);
const hasOneSide = sides?.length === 1;
const [isDirty, setIsDirty] = (0,external_wp_element_namespaceObject.useState)(hasInitialValue);
const [isLinked, setIsLinked] = (0,external_wp_element_namespaceObject.useState)(!hasInitialValue || !isValueMixed(inputValues) || hasOneSide);
const [side, setSide] = (0,external_wp_element_namespaceObject.useState)(getInitialSide(isLinked, splitOnAxis));
const [selectedUnits, setSelectedUnits] = (0,external_wp_element_namespaceObject.useState)({
top: parseQuantityAndUnitFromRawValue(valuesProp?.top)[1],
right: parseQuantityAndUnitFromRawValue(valuesProp?.right)[1],
bottom: parseQuantityAndUnitFromRawValue(valuesProp?.bottom)[1],
left: parseQuantityAndUnitFromRawValue(valuesProp?.left)[1]
});
const id = box_control_useUniqueId(idProp);
const headingId = `${id}-heading`;
const toggleLinked = () => {
setIsLinked(!isLinked);
setSide(getInitialSide(!isLinked, splitOnAxis));
};
const handleOnFocus = (_event, {
side: nextSide
}) => {
setSide(nextSide);
};
const handleOnChange = (nextValues) => {
onChange(nextValues);
setValues(nextValues);
setIsDirty(true);
};
const handleOnReset = () => {
onChange(resetValues);
setValues(resetValues);
setSelectedUnits(resetValues);
setIsDirty(false);
};
const inputControlProps = {
onMouseOver,
onMouseOut,
...inputProps,
onChange: handleOnChange,
onFocus: handleOnFocus,
isLinked,
units,
selectedUnits,
setSelectedUnits,
sides,
values: inputValues,
__next40pxDefaultSize,
presets,
presetKey
};
maybeWarnDeprecated36pxSize({
componentName: "BoxControl",
__next40pxDefaultSize,
size: void 0
});
const sidesToRender = getAllowedSides(sides);
if (presets && !presetKey || !presets && presetKey) {
const definedProp = presets ? "presets" : "presetKey";
const missingProp = presets ? "presetKey" : "presets";
true ? external_wp_warning_default()(`wp.components.BoxControl: the '${missingProp}' prop is required when the '${definedProp}' prop is defined.`) : 0;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(grid_component_component_default, {
id,
columns: 3,
templateColumns: "1fr min-content min-content",
role: "group",
"aria-labelledby": headingId,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BaseControl.VisualLabel, {
id: headingId,
children: label
}), isLinked && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BoxInputControl, {
side: "all",
...inputControlProps
})
}), !hasOneSide && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkedButtonWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LinkedButton, {
onClick: toggleLinked,
isLinked
})
}), !isLinked && splitOnAxis && ["vertical", "horizontal"].map((axis) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BoxInputControl, {
side: axis,
...inputControlProps
}, axis)), !isLinked && !splitOnAxis && Array.from(sidesToRender).map((axis) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(BoxInputControl, {
side: axis,
...inputControlProps
}, axis)), allowReset && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ResetButton, {
className: "component-box-control__reset-button",
variant: "secondary",
size: "small",
onClick: handleOnReset,
disabled: !isDirty,
children: (0,external_wp_i18n_namespaceObject.__)("Reset")
})]
});
}
var box_control_default = BoxControl;
;// ./node_modules/@wordpress/components/build-module/button-group/index.js
function UnforwardedButtonGroup(props, ref) {
const {
className,
__shouldNotWarnDeprecated,
...restProps
} = props;
const classes = dist_clsx("components-button-group", className);
if (!__shouldNotWarnDeprecated) {
external_wp_deprecated_default()("wp.components.ButtonGroup", {
since: "6.8",
alternative: "wp.components.__experimentalToggleGroupControl"
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref,
role: "group",
className: classes,
...restProps
});
}
const ButtonGroup = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedButtonGroup);
var button_group_default = ButtonGroup;
;// ./node_modules/@wordpress/components/build-module/elevation/styles.js
function elevation_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const Elevation = true ? {
name: "12ip69d",
styles: "background:transparent;display:block;margin:0!important;pointer-events:none;position:absolute;will-change:box-shadow"
} : 0;
;// ./node_modules/@wordpress/components/build-module/elevation/hook.js
function getBoxShadow(value) {
const boxShadowColor = `rgba(0, 0, 0, ${value / 20})`;
const boxShadow = `0 ${value}px ${value * 2}px 0
${boxShadowColor}`;
return boxShadow;
}
function useElevation(props) {
const {
active,
borderRadius = "inherit",
className,
focus,
hover,
isInteractive = false,
offset = 0,
value = 0,
...otherProps
} = useContextSystem(props, "Elevation");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
let hoverValue = isValueDefined(hover) ? hover : value * 2;
let activeValue = isValueDefined(active) ? active : value / 2;
if (!isInteractive) {
hoverValue = isValueDefined(hover) ? hover : void 0;
activeValue = isValueDefined(active) ? active : void 0;
}
const transition = `box-shadow ${config_values_default.transitionDuration} ${config_values_default.transitionTimingFunction}`;
const sx = {};
sx.Base = /* @__PURE__ */ emotion_react_browser_esm_css({
borderRadius,
bottom: offset,
boxShadow: getBoxShadow(value),
opacity: config_values_default.elevationIntensity,
left: offset,
right: offset,
top: offset
}, /* @__PURE__ */ emotion_react_browser_esm_css("@media not ( prefers-reduced-motion ){transition:", transition, ";}" + ( true ? "" : 0), true ? "" : 0), true ? "" : 0, true ? "" : 0);
if (isValueDefined(hoverValue)) {
sx.hover = /* @__PURE__ */ emotion_react_browser_esm_css("*:hover>&{box-shadow:", getBoxShadow(hoverValue), ";}" + ( true ? "" : 0), true ? "" : 0);
}
if (isValueDefined(activeValue)) {
sx.active = /* @__PURE__ */ emotion_react_browser_esm_css("*:active>&{box-shadow:", getBoxShadow(activeValue), ";}" + ( true ? "" : 0), true ? "" : 0);
}
if (isValueDefined(focus)) {
sx.focus = /* @__PURE__ */ emotion_react_browser_esm_css("*:focus>&{box-shadow:", getBoxShadow(focus), ";}" + ( true ? "" : 0), true ? "" : 0);
}
return cx(Elevation, sx.Base, sx.hover, sx.focus, sx.active, className);
}, [active, borderRadius, className, cx, focus, hover, isInteractive, offset, value]);
return {
...otherProps,
className: classes,
"aria-hidden": true
};
}
;// ./node_modules/@wordpress/components/build-module/elevation/component.js
function UnconnectedElevation(props, forwardedRef) {
const elevationProps = useElevation(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...elevationProps,
ref: forwardedRef
});
}
const component_Elevation = contextConnect(UnconnectedElevation, "Elevation");
var elevation_component_component_default = component_Elevation;
;// ./node_modules/@wordpress/components/build-module/card/styles.js
function card_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const adjustedBorderRadius = `calc(${config_values_default.radiusLarge} - 1px)`;
const Card = /* @__PURE__ */ emotion_react_browser_esm_css("box-shadow:0 0 0 1px ", config_values_default.surfaceBorderColor, ";outline:none;" + ( true ? "" : 0), true ? "" : 0);
const Header = true ? {
name: "1showjb",
styles: "border-bottom:1px solid;box-sizing:border-box;&:last-child{border-bottom:none;}"
} : 0;
const Footer = true ? {
name: "14n5oej",
styles: "border-top:1px solid;box-sizing:border-box;&:first-of-type{border-top:none;}"
} : 0;
const Content = true ? {
name: "13udsys",
styles: "height:100%"
} : 0;
const Body = true ? {
name: "6ywzd",
styles: "box-sizing:border-box;height:auto;max-height:100%"
} : 0;
const Media = true ? {
name: "dq805e",
styles: "box-sizing:border-box;overflow:hidden;&>img,&>iframe{display:block;height:auto;max-width:100%;width:100%;}"
} : 0;
const Divider = true ? {
name: "c990dr",
styles: "box-sizing:border-box;display:block;width:100%"
} : 0;
const borderRadius = /* @__PURE__ */ emotion_react_browser_esm_css("&:first-of-type{border-top-left-radius:", adjustedBorderRadius, ";border-top-right-radius:", adjustedBorderRadius, ";}&:last-of-type{border-bottom-left-radius:", adjustedBorderRadius, ";border-bottom-right-radius:", adjustedBorderRadius, ";}" + ( true ? "" : 0), true ? "" : 0);
const borderColor = /* @__PURE__ */ emotion_react_browser_esm_css("border-color:", config_values_default.colorDivider, ";" + ( true ? "" : 0), true ? "" : 0);
const boxShadowless = true ? {
name: "1t90u8d",
styles: "box-shadow:none"
} : 0;
const borderless = true ? {
name: "1e1ncky",
styles: "border:none"
} : 0;
const rounded = /* @__PURE__ */ emotion_react_browser_esm_css("border-radius:", adjustedBorderRadius, ";" + ( true ? "" : 0), true ? "" : 0);
const xSmallCardPadding = /* @__PURE__ */ emotion_react_browser_esm_css("padding:", config_values_default.cardPaddingXSmall, ";" + ( true ? "" : 0), true ? "" : 0);
const cardPaddings = {
large: /* @__PURE__ */ emotion_react_browser_esm_css("padding:", config_values_default.cardPaddingLarge, ";" + ( true ? "" : 0), true ? "" : 0),
medium: /* @__PURE__ */ emotion_react_browser_esm_css("padding:", config_values_default.cardPaddingMedium, ";" + ( true ? "" : 0), true ? "" : 0),
small: /* @__PURE__ */ emotion_react_browser_esm_css("padding:", config_values_default.cardPaddingSmall, ";" + ( true ? "" : 0), true ? "" : 0),
xSmall: xSmallCardPadding,
// The `extraSmall` size is not officially documented, but the following styles
// are kept for legacy reasons to support older values of the `size` prop.
extraSmall: xSmallCardPadding
};
const shady = /* @__PURE__ */ emotion_react_browser_esm_css("background-color:", COLORS.ui.backgroundDisabled, ";" + ( true ? "" : 0), true ? "" : 0);
;// ./node_modules/@wordpress/components/build-module/surface/styles.js
const Surface = /* @__PURE__ */ emotion_react_browser_esm_css("background-color:", config_values_default.surfaceColor, ";color:", COLORS.gray[900], ";position:relative;" + ( true ? "" : 0), true ? "" : 0);
const background = /* @__PURE__ */ emotion_react_browser_esm_css("background-color:", config_values_default.surfaceBackgroundColor, ";" + ( true ? "" : 0), true ? "" : 0);
function getBorders({
borderBottom,
borderLeft,
borderRight,
borderTop
}) {
const borderStyle = `1px solid ${config_values_default.surfaceBorderColor}`;
return /* @__PURE__ */ emotion_react_browser_esm_css({
borderBottom: borderBottom ? borderStyle : void 0,
borderLeft: borderLeft ? borderStyle : void 0,
borderRight: borderRight ? borderStyle : void 0,
borderTop: borderTop ? borderStyle : void 0
}, true ? "" : 0, true ? "" : 0);
}
const primary = /* @__PURE__ */ emotion_react_browser_esm_css( true ? "" : 0, true ? "" : 0);
const secondary = /* @__PURE__ */ emotion_react_browser_esm_css("background:", config_values_default.surfaceBackgroundTintColor, ";" + ( true ? "" : 0), true ? "" : 0);
const tertiary = /* @__PURE__ */ emotion_react_browser_esm_css("background:", config_values_default.surfaceBackgroundTertiaryColor, ";" + ( true ? "" : 0), true ? "" : 0);
const customBackgroundSize = (surfaceBackgroundSize) => [surfaceBackgroundSize, surfaceBackgroundSize].join(" ");
const dottedBackground1 = (surfaceBackgroundSizeDotted) => ["90deg", [config_values_default.surfaceBackgroundColor, surfaceBackgroundSizeDotted].join(" "), "transparent 1%"].join(",");
const dottedBackground2 = (surfaceBackgroundSizeDotted) => [[config_values_default.surfaceBackgroundColor, surfaceBackgroundSizeDotted].join(" "), "transparent 1%"].join(",");
const dottedBackgroundCombined = (surfaceBackgroundSizeDotted) => [`linear-gradient( ${dottedBackground1(surfaceBackgroundSizeDotted)} ) center`, `linear-gradient( ${dottedBackground2(surfaceBackgroundSizeDotted)} ) center`, config_values_default.surfaceBorderBoldColor].join(",");
const getDotted = (surfaceBackgroundSize, surfaceBackgroundSizeDotted) => /* @__PURE__ */ emotion_react_browser_esm_css("background:", dottedBackgroundCombined(surfaceBackgroundSizeDotted), ";background-size:", customBackgroundSize(surfaceBackgroundSize), ";" + ( true ? "" : 0), true ? "" : 0);
const gridBackground1 = [`${config_values_default.surfaceBorderSubtleColor} 1px`, "transparent 1px"].join(",");
const gridBackground2 = ["90deg", `${config_values_default.surfaceBorderSubtleColor} 1px`, "transparent 1px"].join(",");
const gridBackgroundCombined = [`linear-gradient( ${gridBackground1} )`, `linear-gradient( ${gridBackground2} )`].join(",");
const getGrid = (surfaceBackgroundSize) => {
return /* @__PURE__ */ emotion_react_browser_esm_css("background:", config_values_default.surfaceBackgroundColor, ";background-image:", gridBackgroundCombined, ";background-size:", customBackgroundSize(surfaceBackgroundSize), ";" + ( true ? "" : 0), true ? "" : 0);
};
const getVariant = (variant, surfaceBackgroundSize, surfaceBackgroundSizeDotted) => {
switch (variant) {
case "dotted": {
return getDotted(surfaceBackgroundSize, surfaceBackgroundSizeDotted);
}
case "grid": {
return getGrid(surfaceBackgroundSize);
}
case "primary": {
return primary;
}
case "secondary": {
return secondary;
}
case "tertiary": {
return tertiary;
}
}
};
;// ./node_modules/@wordpress/components/build-module/surface/hook.js
function useSurface(props) {
const {
backgroundSize = 12,
borderBottom = false,
borderLeft = false,
borderRight = false,
borderTop = false,
className,
variant = "primary",
...otherProps
} = useContextSystem(props, "Surface");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
const sx = {
borders: getBorders({
borderBottom,
borderLeft,
borderRight,
borderTop
})
};
return cx(Surface, sx.borders, getVariant(variant, `${backgroundSize}px`, `${backgroundSize - 1}px`), className);
}, [backgroundSize, borderBottom, borderLeft, borderRight, borderTop, className, cx, variant]);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/card/card/hook.js
function hook_useDeprecatedProps({
elevation,
isElevated,
...otherProps
}) {
const propsToReturn = {
...otherProps
};
let computedElevation = elevation;
if (isElevated) {
var _computedElevation;
external_wp_deprecated_default()("Card isElevated prop", {
since: "5.9",
alternative: "elevation"
});
(_computedElevation = computedElevation) !== null && _computedElevation !== void 0 ? _computedElevation : computedElevation = 2;
}
if (typeof computedElevation !== "undefined") {
propsToReturn.elevation = computedElevation;
}
return propsToReturn;
}
function useCard(props) {
const {
className,
elevation = 0,
isBorderless = false,
isRounded = true,
size = "medium",
...otherProps
} = useContextSystem(hook_useDeprecatedProps(props), "Card");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(Card, isBorderless && boxShadowless, isRounded && rounded, className);
}, [className, cx, isBorderless, isRounded]);
const surfaceProps = useSurface({
...otherProps,
className: classes
});
return {
...surfaceProps,
elevation,
isBorderless,
isRounded,
size
};
}
;// ./node_modules/@wordpress/components/build-module/card/card/component.js
function UnconnectedCard(props, forwardedRef) {
const {
children,
elevation,
isBorderless,
isRounded,
size,
...otherProps
} = useCard(props);
const elevationBorderRadius = isRounded ? config_values_default.radiusLarge : 0;
const cx = useCx();
const elevationClassName = (0,external_wp_element_namespaceObject.useMemo)(() => cx(/* @__PURE__ */ emotion_react_browser_esm_css({
borderRadius: elevationBorderRadius
}, true ? "" : 0, true ? "" : 0)), [cx, elevationBorderRadius]);
const contextProviderValue = (0,external_wp_element_namespaceObject.useMemo)(() => {
const contextProps = {
size,
isBorderless
};
return {
CardBody: contextProps,
CardHeader: contextProps,
CardFooter: contextProps
};
}, [isBorderless, size]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ContextSystemProvider, {
value: contextProviderValue,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(component_default, {
...otherProps,
ref: forwardedRef,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
className: cx(Content),
children
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(elevation_component_component_default, {
className: elevationClassName,
isInteractive: false,
value: elevation ? 1 : 0
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(elevation_component_component_default, {
className: elevationClassName,
isInteractive: false,
value: elevation
})]
})
});
}
const component_Card = contextConnect(UnconnectedCard, "Card");
var card_component_component_default = component_Card;
;// ./node_modules/@wordpress/components/build-module/scrollable/styles.js
function scrollable_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const scrollableScrollbar = /* @__PURE__ */ emotion_react_browser_esm_css("@media only screen and ( min-device-width: 40em ){&::-webkit-scrollbar{height:12px;width:12px;}&::-webkit-scrollbar-track{background-color:transparent;}&::-webkit-scrollbar-track{background:", config_values_default.colorScrollbarTrack, ";border-radius:8px;}&::-webkit-scrollbar-thumb{background-clip:padding-box;background-color:", config_values_default.colorScrollbarThumb, ";border:2px solid rgba( 0, 0, 0, 0 );border-radius:7px;}&:hover::-webkit-scrollbar-thumb{background-color:", config_values_default.colorScrollbarThumbHover, ";}}" + ( true ? "" : 0), true ? "" : 0);
const Scrollable = true ? {
name: "13udsys",
styles: "height:100%"
} : 0;
const styles_Content = true ? {
name: "bjn8wh",
styles: "position:relative"
} : 0;
const styles_smoothScroll = true ? {
name: "7zq9w",
styles: "scroll-behavior:smooth"
} : 0;
const scrollX = true ? {
name: "q33xhg",
styles: "overflow-x:auto;overflow-y:hidden"
} : 0;
const scrollY = true ? {
name: "103x71s",
styles: "overflow-x:hidden;overflow-y:auto"
} : 0;
const scrollAuto = true ? {
name: "umwchj",
styles: "overflow-y:auto"
} : 0;
;// ./node_modules/@wordpress/components/build-module/scrollable/hook.js
function useScrollable(props) {
const {
className,
scrollDirection = "y",
smoothScroll = false,
...otherProps
} = useContextSystem(props, "Scrollable");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(Scrollable, scrollableScrollbar, smoothScroll && styles_smoothScroll, scrollDirection === "x" && scrollX, scrollDirection === "y" && scrollY, scrollDirection === "auto" && scrollAuto, className), [className, cx, scrollDirection, smoothScroll]);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/scrollable/component.js
function UnconnectedScrollable(props, forwardedRef) {
const scrollableProps = useScrollable(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...scrollableProps,
ref: forwardedRef
});
}
const component_Scrollable = contextConnect(UnconnectedScrollable, "Scrollable");
var scrollable_component_component_default = component_Scrollable;
;// ./node_modules/@wordpress/components/build-module/card/card-body/hook.js
function useCardBody(props) {
const {
className,
isScrollable = false,
isShady = false,
size = "medium",
...otherProps
} = useContextSystem(props, "CardBody");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(
Body,
borderRadius,
cardPaddings[size],
isShady && shady,
// This classname is added for legacy compatibility reasons.
"components-card__body",
className
), [className, cx, isShady, size]);
return {
...otherProps,
className: classes,
isScrollable
};
}
;// ./node_modules/@wordpress/components/build-module/card/card-body/component.js
function UnconnectedCardBody(props, forwardedRef) {
const {
isScrollable,
...otherProps
} = useCardBody(props);
if (isScrollable) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(scrollable_component_component_default, {
...otherProps,
ref: forwardedRef
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...otherProps,
ref: forwardedRef
});
}
const CardBody = contextConnect(UnconnectedCardBody, "CardBody");
var card_body_component_component_default = CardBody;
;// ./node_modules/@ariakit/react-core/esm/__chunks/A3CZKICO.js
"use client";
// src/separator/separator.tsx
var A3CZKICO_TagName = "hr";
var useSeparator = createHook(
function useSeparator2(_a) {
var _b = _a, { orientation = "horizontal" } = _b, props = __objRest(_b, ["orientation"]);
props = _3YLGPPWQ_spreadValues({
role: "separator",
"aria-orientation": orientation
}, props);
return props;
}
);
var Separator = forwardRef2(function Separator2(props) {
const htmlProps = useSeparator(props);
return LMDWO4NN_createElement(A3CZKICO_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/divider/styles.js
function divider_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const MARGIN_DIRECTIONS = {
vertical: {
start: "marginLeft",
end: "marginRight"
},
horizontal: {
start: "marginTop",
end: "marginBottom"
}
};
const renderMargin = ({
"aria-orientation": orientation = "horizontal",
margin,
marginStart,
marginEnd
}) => /* @__PURE__ */ emotion_react_browser_esm_css(rtl({
[MARGIN_DIRECTIONS[orientation].start]: space(marginStart !== null && marginStart !== void 0 ? marginStart : margin),
[MARGIN_DIRECTIONS[orientation].end]: space(marginEnd !== null && marginEnd !== void 0 ? marginEnd : margin)
})(), true ? "" : 0, true ? "" : 0);
var divider_styles_ref = true ? {
name: "1u4hpl4",
styles: "display:inline"
} : 0;
const renderDisplay = ({
"aria-orientation": orientation = "horizontal"
}) => {
return orientation === "vertical" ? divider_styles_ref : void 0;
};
const renderBorder = ({
"aria-orientation": orientation = "horizontal"
}) => {
return /* @__PURE__ */ emotion_react_browser_esm_css({
[orientation === "vertical" ? "borderRight" : "borderBottom"]: "1px solid currentColor"
}, true ? "" : 0, true ? "" : 0);
};
const renderSize = ({
"aria-orientation": orientation = "horizontal"
}) => /* @__PURE__ */ emotion_react_browser_esm_css({
height: orientation === "vertical" ? "auto" : 0,
width: orientation === "vertical" ? 0 : "auto"
}, true ? "" : 0, true ? "" : 0);
const DividerView = /* @__PURE__ */ emotion_styled_base_browser_esm("hr", true ? {
target: "e19on6iw0"
} : 0)("border:0;margin:0;", renderDisplay, " ", renderBorder, " ", renderSize, " ", renderMargin, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/divider/component.js
function UnconnectedDivider(props, forwardedRef) {
const contextProps = useContextSystem(props, "Divider");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Separator, {
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DividerView, {}),
...contextProps,
ref: forwardedRef
});
}
const component_Divider = contextConnect(UnconnectedDivider, "Divider");
var divider_component_component_default = component_Divider;
;// ./node_modules/@wordpress/components/build-module/card/card-divider/hook.js
function useCardDivider(props) {
const {
className,
...otherProps
} = useContextSystem(props, "CardDivider");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(
Divider,
borderColor,
// This classname is added for legacy compatibility reasons.
"components-card__divider",
className
), [className, cx]);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/card/card-divider/component.js
function UnconnectedCardDivider(props, forwardedRef) {
const dividerProps = useCardDivider(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(divider_component_component_default, {
...dividerProps,
ref: forwardedRef
});
}
const CardDivider = contextConnect(UnconnectedCardDivider, "CardDivider");
var card_divider_component_component_default = CardDivider;
;// ./node_modules/@wordpress/components/build-module/card/card-footer/hook.js
function useCardFooter(props) {
const {
className,
justify,
isBorderless = false,
isShady = false,
size = "medium",
...otherProps
} = useContextSystem(props, "CardFooter");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(
Footer,
borderRadius,
borderColor,
cardPaddings[size],
isBorderless && borderless,
isShady && shady,
// This classname is added for legacy compatibility reasons.
"components-card__footer",
className
), [className, cx, isBorderless, isShady, size]);
return {
...otherProps,
className: classes,
justify
};
}
;// ./node_modules/@wordpress/components/build-module/card/card-footer/component.js
function UnconnectedCardFooter(props, forwardedRef) {
const footerProps = useCardFooter(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_component_component_default, {
...footerProps,
ref: forwardedRef
});
}
const CardFooter = contextConnect(UnconnectedCardFooter, "CardFooter");
var card_footer_component_component_default = CardFooter;
;// ./node_modules/@wordpress/components/build-module/card/card-header/hook.js
function useCardHeader(props) {
const {
className,
isBorderless = false,
isShady = false,
size = "medium",
...otherProps
} = useContextSystem(props, "CardHeader");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(
Header,
borderRadius,
borderColor,
cardPaddings[size],
isBorderless && borderless,
isShady && shady,
// This classname is added for legacy compatibility reasons.
"components-card__header",
className
), [className, cx, isBorderless, isShady, size]);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/card/card-header/component.js
function UnconnectedCardHeader(props, forwardedRef) {
const headerProps = useCardHeader(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_component_component_default, {
...headerProps,
ref: forwardedRef
});
}
const CardHeader = contextConnect(UnconnectedCardHeader, "CardHeader");
var card_header_component_component_default = CardHeader;
;// ./node_modules/@wordpress/components/build-module/card/card-media/hook.js
function useCardMedia(props) {
const {
className,
...otherProps
} = useContextSystem(props, "CardMedia");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(
Media,
borderRadius,
// This classname is added for legacy compatibility reasons.
"components-card__media",
className
), [className, cx]);
return {
...otherProps,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/card/card-media/component.js
function UnconnectedCardMedia(props, forwardedRef) {
const cardMediaProps = useCardMedia(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...cardMediaProps,
ref: forwardedRef
});
}
const CardMedia = contextConnect(UnconnectedCardMedia, "CardMedia");
var card_media_component_component_default = CardMedia;
;// ./node_modules/@wordpress/components/build-module/checkbox-control/index.js
function CheckboxControl(props) {
const {
__nextHasNoMarginBottom,
label,
className,
heading,
checked,
indeterminate,
help,
id: idProp,
onChange,
onClick,
...additionalProps
} = props;
if (heading) {
external_wp_deprecated_default()("`heading` prop in `CheckboxControl`", {
alternative: "a separate element to implement a heading",
since: "5.8"
});
}
const [showCheckedIcon, setShowCheckedIcon] = (0,external_wp_element_namespaceObject.useState)(false);
const [showIndeterminateIcon, setShowIndeterminateIcon] = (0,external_wp_element_namespaceObject.useState)(false);
const ref = (0,external_wp_compose_namespaceObject.useRefEffect)((node) => {
if (!node) {
return;
}
node.indeterminate = !!indeterminate;
setShowCheckedIcon(node.matches(":checked"));
setShowIndeterminateIcon(node.matches(":indeterminate"));
}, [checked, indeterminate]);
const id = (0,external_wp_compose_namespaceObject.useInstanceId)(CheckboxControl, "inspector-checkbox-control", idProp);
const onChangeValue = (event) => onChange(event.target.checked);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
__nextHasNoMarginBottom,
__associatedWPComponentName: "CheckboxControl",
label: heading,
id,
help: help && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-checkbox-control__help",
children: help
}),
className: dist_clsx("components-checkbox-control", className),
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
spacing: 0,
justify: "start",
alignment: "top",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
className: "components-checkbox-control__input-container",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
ref,
id,
className: "components-checkbox-control__input",
type: "checkbox",
value: "1",
onChange: onChangeValue,
checked,
"aria-describedby": !!help ? id + "__help" : void 0,
onClick: (event) => {
event.currentTarget.focus();
onClick?.(event);
},
...additionalProps
}), showIndeterminateIcon ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: reset_default,
className: "components-checkbox-control__indeterminate",
role: "presentation"
}) : null, showCheckedIcon ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: check_default,
className: "components-checkbox-control__checked",
role: "presentation"
}) : null]
}), label && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("label", {
className: "components-checkbox-control__label",
htmlFor: id,
children: label
})]
})
});
}
var checkbox_control_default = CheckboxControl;
;// ./node_modules/@wordpress/components/build-module/clipboard-button/index.js
const TIMEOUT = 4e3;
function ClipboardButton({
className,
children,
onCopy,
onFinishCopy,
text,
...buttonProps
}) {
external_wp_deprecated_default()("wp.components.ClipboardButton", {
since: "5.8",
alternative: "wp.compose.useCopyToClipboard"
});
const timeoutIdRef = (0,external_wp_element_namespaceObject.useRef)();
const ref = (0,external_wp_compose_namespaceObject.useCopyToClipboard)(text, () => {
onCopy();
if (timeoutIdRef.current) {
clearTimeout(timeoutIdRef.current);
}
if (onFinishCopy) {
timeoutIdRef.current = setTimeout(() => onFinishCopy(), TIMEOUT);
}
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
return () => {
if (timeoutIdRef.current) {
clearTimeout(timeoutIdRef.current);
}
};
}, []);
const classes = dist_clsx("components-clipboard-button", className);
const focusOnCopyEventTarget = (event) => {
event.target.focus();
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
...buttonProps,
className: classes,
ref,
onCopy: focusOnCopyEventTarget,
children
});
}
;// ./node_modules/@wordpress/icons/build-module/library/more-vertical.js
var more_vertical_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M13 19h-2v-2h2v2zm0-6h-2v-2h2v2zm0-6h-2V5h2v2z" }) });
;// ./node_modules/@wordpress/components/build-module/item-group/styles.js
function item_group_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const unstyledButton = (as) => {
return /* @__PURE__ */ emotion_react_browser_esm_css("font-size:", font("default.fontSize"), ";font-family:inherit;appearance:none;border:1px solid transparent;cursor:pointer;background:none;text-align:start;text-decoration:", as === "a" ? "none" : void 0, ";svg,path{fill:currentColor;}&:hover{color:", COLORS.theme.accent, ";}&:focus{box-shadow:none;outline:none;}&:focus-visible{box-shadow:0 0 0 var( --wp-admin-border-width-focus ) ", COLORS.theme.accent, ";outline:2px solid transparent;outline-offset:0;}" + ( true ? "" : 0), true ? "" : 0);
};
const itemWrapper = true ? {
name: "1bcj5ek",
styles: "width:100%;display:block"
} : 0;
const item = true ? {
name: "150ruhm",
styles: "box-sizing:border-box;width:100%;display:block;margin:0;color:inherit"
} : 0;
const bordered = /* @__PURE__ */ emotion_react_browser_esm_css("border:1px solid ", config_values_default.surfaceBorderColor, ";" + ( true ? "" : 0), true ? "" : 0);
const separated = /* @__PURE__ */ emotion_react_browser_esm_css(">*:not( marquee )>*{border-bottom:1px solid ", config_values_default.surfaceBorderColor, ";}>*:last-of-type>*{border-bottom-color:transparent;}" + ( true ? "" : 0), true ? "" : 0);
const styles_borderRadius = config_values_default.radiusSmall;
const styles_spacedAround = /* @__PURE__ */ emotion_react_browser_esm_css("border-radius:", styles_borderRadius, ";" + ( true ? "" : 0), true ? "" : 0);
const styles_rounded = /* @__PURE__ */ emotion_react_browser_esm_css("border-radius:", styles_borderRadius, ";>*:first-of-type>*{border-top-left-radius:", styles_borderRadius, ";border-top-right-radius:", styles_borderRadius, ";}>*:last-of-type>*{border-bottom-left-radius:", styles_borderRadius, ";border-bottom-right-radius:", styles_borderRadius, ";}" + ( true ? "" : 0), true ? "" : 0);
const baseFontHeight = `calc(${config_values_default.fontSize} * ${config_values_default.fontLineHeightBase})`;
const paddingY = `calc((${config_values_default.controlHeight} - ${baseFontHeight} - 2px) / 2)`;
const paddingYSmall = `calc((${config_values_default.controlHeightSmall} - ${baseFontHeight} - 2px) / 2)`;
const paddingYLarge = `calc((${config_values_default.controlHeightLarge} - ${baseFontHeight} - 2px) / 2)`;
const itemSizes = {
small: /* @__PURE__ */ emotion_react_browser_esm_css("padding:", paddingYSmall, " ", config_values_default.controlPaddingXSmall, "px;" + ( true ? "" : 0), true ? "" : 0),
medium: /* @__PURE__ */ emotion_react_browser_esm_css("padding:", paddingY, " ", config_values_default.controlPaddingX, "px;" + ( true ? "" : 0), true ? "" : 0),
large: /* @__PURE__ */ emotion_react_browser_esm_css("padding:", paddingYLarge, " ", config_values_default.controlPaddingXLarge, "px;" + ( true ? "" : 0), true ? "" : 0)
};
;// ./node_modules/@wordpress/components/build-module/item-group/context.js
const ItemGroupContext = (0,external_wp_element_namespaceObject.createContext)({
size: "medium"
});
ItemGroupContext.displayName = "ItemGroupContext";
const useItemGroupContext = () => (0,external_wp_element_namespaceObject.useContext)(ItemGroupContext);
;// ./node_modules/@wordpress/components/build-module/item-group/item/hook.js
function useItem(props) {
const {
as: asProp,
className,
onClick,
role = "listitem",
size: sizeProp,
...otherProps
} = useContextSystem(props, "Item");
const {
spacedAround,
size: contextSize
} = useItemGroupContext();
const size = sizeProp || contextSize;
const as = asProp || (typeof onClick !== "undefined" ? "button" : "div");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx((as === "button" || as === "a") && unstyledButton(as), itemSizes[size] || itemSizes.medium, item, spacedAround && styles_spacedAround, className), [as, className, cx, size, spacedAround]);
const wrapperClassName = cx(itemWrapper);
return {
as,
className: classes,
onClick,
wrapperClassName,
role,
...otherProps
};
}
;// ./node_modules/@wordpress/components/build-module/item-group/item/component.js
function UnconnectedItem(props, forwardedRef) {
const {
role,
wrapperClassName,
...otherProps
} = useItem(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
role,
className: wrapperClassName,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...otherProps,
ref: forwardedRef
})
});
}
const component_Item = contextConnect(UnconnectedItem, "Item");
var item_component_component_default = component_Item;
;// ./node_modules/@wordpress/components/build-module/item-group/item-group/hook.js
function useItemGroup(props) {
const {
className,
isBordered = false,
isRounded = true,
isSeparated = false,
role = "list",
...otherProps
} = useContextSystem(props, "ItemGroup");
const cx = useCx();
const classes = cx(isBordered && bordered, isSeparated && separated, isRounded && styles_rounded, className);
return {
isBordered,
className: classes,
role,
isSeparated,
...otherProps
};
}
;// ./node_modules/@wordpress/components/build-module/item-group/item-group/component.js
function UnconnectedItemGroup(props, forwardedRef) {
const {
isBordered,
isSeparated,
size: sizeProp,
...otherProps
} = useItemGroup(props);
const {
size: contextSize
} = useItemGroupContext();
const spacedAround = !isBordered && !isSeparated;
const size = sizeProp || contextSize;
const contextValue = {
spacedAround,
size
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemGroupContext.Provider, {
value: contextValue,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...otherProps,
ref: forwardedRef
})
});
}
const ItemGroup = contextConnect(UnconnectedItemGroup, "ItemGroup");
var item_group_component_component_default = ItemGroup;
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/gradient-bar/constants.js
const GRADIENT_MARKERS_WIDTH = 16;
const INSERT_POINT_WIDTH = 16;
const MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_POINT = 10;
const MINIMUM_DISTANCE_BETWEEN_POINTS = 0;
const MINIMUM_SIGNIFICANT_MOVE = 5;
const KEYBOARD_CONTROL_POINT_VARIATION = MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_POINT;
const MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_MARKER = (INSERT_POINT_WIDTH + GRADIENT_MARKERS_WIDTH) / 2;
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/gradient-bar/utils.js
function clampPercent(value) {
return Math.max(0, Math.min(100, value));
}
function isOverlapping(value, initialIndex, newPosition, minDistance = MINIMUM_DISTANCE_BETWEEN_POINTS) {
const initialPosition = value[initialIndex].position;
const minPosition = Math.min(initialPosition, newPosition);
const maxPosition = Math.max(initialPosition, newPosition);
return value.some(({
position
}, index) => {
return index !== initialIndex && (Math.abs(position - newPosition) < minDistance || minPosition < position && position < maxPosition);
});
}
function addControlPoint(points, position, color) {
const nextIndex = points.findIndex((point) => point.position > position);
const newPoint = {
color,
position
};
const newPoints = points.slice();
newPoints.splice(nextIndex - 1, 0, newPoint);
return newPoints;
}
function removeControlPoint(points, index) {
return points.filter((_point, pointIndex) => {
return pointIndex !== index;
});
}
function updateControlPoint(points, index, newPoint) {
const newValue = points.slice();
newValue[index] = newPoint;
return newValue;
}
function updateControlPointPosition(points, index, newPosition) {
if (isOverlapping(points, index, newPosition)) {
return points;
}
const newPoint = {
...points[index],
position: newPosition
};
return updateControlPoint(points, index, newPoint);
}
function updateControlPointColor(points, index, newColor) {
const newPoint = {
...points[index],
color: newColor
};
return updateControlPoint(points, index, newPoint);
}
function updateControlPointColorByPosition(points, position, newColor) {
const index = points.findIndex((point) => point.position === position);
return updateControlPointColor(points, index, newColor);
}
function getHorizontalRelativeGradientPosition(mouseXCoordinate, containerElement) {
if (!containerElement) {
return;
}
const {
x,
width
} = containerElement.getBoundingClientRect();
const absolutePositionValue = mouseXCoordinate - x;
return Math.round(clampPercent(absolutePositionValue * 100 / width));
}
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/gradient-bar/control-points.js
function ControlPointButton({
isOpen,
position,
color,
...additionalProps
}) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ControlPointButton);
const descriptionId = `components-custom-gradient-picker__control-point-button-description-${instanceId}`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
"aria-label": (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: gradient position e.g: 70. 2: gradient color code e.g: rgb(52,121,151).
(0,external_wp_i18n_namespaceObject.__)("Gradient control point at position %1$d%% with color code %2$s."),
position,
color
),
"aria-describedby": descriptionId,
"aria-haspopup": "true",
"aria-expanded": isOpen,
__next40pxDefaultSize: true,
className: dist_clsx("components-custom-gradient-picker__control-point-button", {
"is-active": isOpen
}),
...additionalProps
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
id: descriptionId,
children: (0,external_wp_i18n_namespaceObject.__)("Use your left or right arrow keys or drag and drop with the mouse to change the gradient position. Press the button to change the color or remove the control point.")
})]
});
}
function GradientColorPickerDropdown({
isRenderedInSidebar,
className,
...props
}) {
const popoverProps = (0,external_wp_element_namespaceObject.useMemo)(() => ({
placement: "bottom",
offset: 8,
// Disabling resize as it would otherwise cause the popover to show
// scrollbars while dragging the color picker's handle close to the
// popover edge.
resize: false
}), []);
const mergedClassName = dist_clsx("components-custom-gradient-picker__control-point-dropdown", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomColorPickerDropdown, {
isRenderedInSidebar,
popoverProps,
className: mergedClassName,
...props
});
}
function ControlPoints({
disableRemove,
disableAlpha,
gradientPickerDomRef,
ignoreMarkerPosition,
value: controlPoints,
onChange,
onStartControlPointChange,
onStopControlPointChange,
__experimentalIsRenderedInSidebar
}) {
const controlPointMoveStateRef = (0,external_wp_element_namespaceObject.useRef)();
const onMouseMove = (event) => {
if (controlPointMoveStateRef.current === void 0 || gradientPickerDomRef.current === null) {
return;
}
const relativePosition = getHorizontalRelativeGradientPosition(event.clientX, gradientPickerDomRef.current);
const {
initialPosition,
index,
significantMoveHappened
} = controlPointMoveStateRef.current;
if (!significantMoveHappened && Math.abs(initialPosition - relativePosition) >= MINIMUM_SIGNIFICANT_MOVE) {
controlPointMoveStateRef.current.significantMoveHappened = true;
}
onChange(updateControlPointPosition(controlPoints, index, relativePosition));
};
const cleanEventListeners = () => {
if (window && window.removeEventListener && controlPointMoveStateRef.current && controlPointMoveStateRef.current.listenersActivated) {
window.removeEventListener("mousemove", onMouseMove);
window.removeEventListener("mouseup", cleanEventListeners);
onStopControlPointChange();
controlPointMoveStateRef.current.listenersActivated = false;
}
};
const cleanEventListenersRef = (0,external_wp_element_namespaceObject.useRef)();
cleanEventListenersRef.current = cleanEventListeners;
(0,external_wp_element_namespaceObject.useEffect)(() => {
return () => {
cleanEventListenersRef.current?.();
};
}, []);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: controlPoints.map((point, index) => {
const initialPosition = point?.position;
return ignoreMarkerPosition !== initialPosition && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GradientColorPickerDropdown, {
isRenderedInSidebar: __experimentalIsRenderedInSidebar,
onClose: onStopControlPointChange,
renderToggle: ({
isOpen,
onToggle
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlPointButton, {
onClick: () => {
if (controlPointMoveStateRef.current && controlPointMoveStateRef.current.significantMoveHappened) {
return;
}
if (isOpen) {
onStopControlPointChange();
} else {
onStartControlPointChange();
}
onToggle();
},
onMouseDown: () => {
if (window && window.addEventListener) {
controlPointMoveStateRef.current = {
initialPosition,
index,
significantMoveHappened: false,
listenersActivated: true
};
onStartControlPointChange();
window.addEventListener("mousemove", onMouseMove);
window.addEventListener("mouseup", cleanEventListeners);
}
},
onKeyDown: (event) => {
if (event.code === "ArrowLeft") {
event.stopPropagation();
onChange(updateControlPointPosition(controlPoints, index, clampPercent(point.position - KEYBOARD_CONTROL_POINT_VARIATION)));
} else if (event.code === "ArrowRight") {
event.stopPropagation();
onChange(updateControlPointPosition(controlPoints, index, clampPercent(point.position + KEYBOARD_CONTROL_POINT_VARIATION)));
}
},
isOpen,
position: point.position,
color: point.color
}, index),
renderContent: ({
onClose
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(dropdown_content_wrapper_default, {
paddingSize: "none",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LegacyAdapter, {
enableAlpha: !disableAlpha,
color: point.color,
onChange: (color) => {
onChange(updateControlPointColor(controlPoints, index, w(color).toRgbString()));
}
}), !disableRemove && controlPoints.length > 2 && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(h_stack_component_component_default, {
className: "components-custom-gradient-picker__remove-control-point-wrapper",
alignment: "center",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
onClick: () => {
onChange(removeControlPoint(controlPoints, index));
onClose();
},
variant: "link",
children: (0,external_wp_i18n_namespaceObject.__)("Remove Control Point")
})
})]
}),
style: {
left: `${point.position}%`,
transform: "translateX( -50% )"
}
}, index);
})
});
}
function InsertPoint({
value: controlPoints,
onChange,
onOpenInserter,
onCloseInserter,
insertPosition,
disableAlpha,
__experimentalIsRenderedInSidebar
}) {
const [alreadyInsertedPoint, setAlreadyInsertedPoint] = (0,external_wp_element_namespaceObject.useState)(false);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GradientColorPickerDropdown, {
isRenderedInSidebar: __experimentalIsRenderedInSidebar,
className: "components-custom-gradient-picker__inserter",
onClose: () => {
onCloseInserter();
},
renderToggle: ({
isOpen,
onToggle
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
"aria-expanded": isOpen,
"aria-haspopup": "true",
onClick: () => {
if (isOpen) {
onCloseInserter();
} else {
setAlreadyInsertedPoint(false);
onOpenInserter();
}
onToggle();
},
className: "components-custom-gradient-picker__insert-point-dropdown",
icon: plus_default
}),
renderContent: () => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_content_wrapper_default, {
paddingSize: "none",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LegacyAdapter, {
enableAlpha: !disableAlpha,
onChange: (color) => {
if (!alreadyInsertedPoint) {
onChange(addControlPoint(controlPoints, insertPosition, w(color).toRgbString()));
setAlreadyInsertedPoint(true);
} else {
onChange(updateControlPointColorByPosition(controlPoints, insertPosition, w(color).toRgbString()));
}
}
})
}),
style: insertPosition !== null ? {
left: `${insertPosition}%`,
transform: "translateX( -50% )"
} : void 0
});
}
ControlPoints.InsertPoint = InsertPoint;
var control_points_default = ControlPoints;
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/gradient-bar/index.js
const customGradientBarReducer = (state, action) => {
switch (action.type) {
case "MOVE_INSERTER":
if (state.id === "IDLE" || state.id === "MOVING_INSERTER") {
return {
id: "MOVING_INSERTER",
insertPosition: action.insertPosition
};
}
break;
case "STOP_INSERTER_MOVE":
if (state.id === "MOVING_INSERTER") {
return {
id: "IDLE"
};
}
break;
case "OPEN_INSERTER":
if (state.id === "MOVING_INSERTER") {
return {
id: "INSERTING_CONTROL_POINT",
insertPosition: state.insertPosition
};
}
break;
case "CLOSE_INSERTER":
if (state.id === "INSERTING_CONTROL_POINT") {
return {
id: "IDLE"
};
}
break;
case "START_CONTROL_CHANGE":
if (state.id === "IDLE") {
return {
id: "MOVING_CONTROL_POINT"
};
}
break;
case "STOP_CONTROL_CHANGE":
if (state.id === "MOVING_CONTROL_POINT") {
return {
id: "IDLE"
};
}
break;
}
return state;
};
const customGradientBarReducerInitialState = {
id: "IDLE"
};
function CustomGradientBar({
background,
hasGradient,
value: controlPoints,
onChange,
disableInserter = false,
disableAlpha = false,
__experimentalIsRenderedInSidebar = false
}) {
const gradientMarkersContainerDomRef = (0,external_wp_element_namespaceObject.useRef)(null);
const [gradientBarState, gradientBarStateDispatch] = (0,external_wp_element_namespaceObject.useReducer)(customGradientBarReducer, customGradientBarReducerInitialState);
const onMouseEnterAndMove = (event) => {
if (!gradientMarkersContainerDomRef.current) {
return;
}
const insertPosition = getHorizontalRelativeGradientPosition(event.clientX, gradientMarkersContainerDomRef.current);
if (controlPoints.some(({
position
}) => {
return Math.abs(insertPosition - position) < MINIMUM_DISTANCE_BETWEEN_INSERTER_AND_POINT;
})) {
if (gradientBarState.id === "MOVING_INSERTER") {
gradientBarStateDispatch({
type: "STOP_INSERTER_MOVE"
});
}
return;
}
gradientBarStateDispatch({
type: "MOVE_INSERTER",
insertPosition
});
};
const onMouseLeave = () => {
gradientBarStateDispatch({
type: "STOP_INSERTER_MOVE"
});
};
const isMovingInserter = gradientBarState.id === "MOVING_INSERTER";
const isInsertingControlPoint = gradientBarState.id === "INSERTING_CONTROL_POINT";
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: dist_clsx("components-custom-gradient-picker__gradient-bar", {
"has-gradient": hasGradient
}),
onMouseEnter: onMouseEnterAndMove,
onMouseMove: onMouseEnterAndMove,
onMouseLeave,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-custom-gradient-picker__gradient-bar-background",
style: {
background,
opacity: hasGradient ? 1 : 0.4
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
ref: gradientMarkersContainerDomRef,
className: "components-custom-gradient-picker__markers-container",
children: [!disableInserter && (isMovingInserter || isInsertingControlPoint) && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(control_points_default.InsertPoint, {
__experimentalIsRenderedInSidebar,
disableAlpha,
insertPosition: gradientBarState.insertPosition,
value: controlPoints,
onChange,
onOpenInserter: () => {
gradientBarStateDispatch({
type: "OPEN_INSERTER"
});
},
onCloseInserter: () => {
gradientBarStateDispatch({
type: "CLOSE_INSERTER"
});
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(control_points_default, {
__experimentalIsRenderedInSidebar,
disableAlpha,
disableRemove: disableInserter,
gradientPickerDomRef: gradientMarkersContainerDomRef,
ignoreMarkerPosition: isInsertingControlPoint ? gradientBarState.insertPosition : void 0,
value: controlPoints,
onChange,
onStartControlPointChange: () => {
gradientBarStateDispatch({
type: "START_CONTROL_CHANGE"
});
},
onStopControlPointChange: () => {
gradientBarStateDispatch({
type: "STOP_CONTROL_CHANGE"
});
}
})]
})]
});
}
// EXTERNAL MODULE: ./node_modules/gradient-parser/build/node.js
var build_node = __webpack_require__(8924);
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/constants.js
const DEFAULT_GRADIENT = "linear-gradient(135deg, rgba(6, 147, 227, 1) 0%, rgb(155, 81, 224) 100%)";
const DEFAULT_LINEAR_GRADIENT_ANGLE = 180;
const HORIZONTAL_GRADIENT_ORIENTATION = {
type: "angular",
value: "90"
};
const GRADIENT_OPTIONS = [{
value: "linear-gradient",
label: (0,external_wp_i18n_namespaceObject.__)("Linear")
}, {
value: "radial-gradient",
label: (0,external_wp_i18n_namespaceObject.__)("Radial")
}];
const DIRECTIONAL_ORIENTATION_ANGLE_MAP = {
top: 0,
"top right": 45,
"right top": 45,
right: 90,
"right bottom": 135,
"bottom right": 135,
bottom: 180,
"bottom left": 225,
"left bottom": 225,
left: 270,
"top left": 315,
"left top": 315
};
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/serializer.js
function serializeGradientColor({
type,
value
}) {
if (type === "literal") {
return value;
}
if (type === "hex") {
return `#${value}`;
}
if (type === "var") {
return `var(${value})`;
}
if (type === "hsl") {
const [hue, saturation, lightness] = value;
return `hsl(${hue},${saturation}%,${lightness}%)`;
}
if (type === "hsla") {
const [hue, saturation, lightness, alpha] = value;
return `hsla(${hue},${saturation}%,${lightness}%,${alpha})`;
}
return `${type}(${value.join(",")})`;
}
function serializeGradientPosition(position) {
if (!position) {
return "";
}
const {
value,
type
} = position;
if (type === "calc") {
return `calc(${value})`;
}
return `${value}${type}`;
}
function serializeGradientColorStop({
type,
value,
length
}) {
return `${serializeGradientColor({
type,
value
})} ${serializeGradientPosition(length)}`;
}
function serializeGradientOrientation(orientation) {
if (Array.isArray(orientation) || !orientation || orientation.type !== "angular") {
return;
}
return `${orientation.value}deg`;
}
function serializeGradient({
type,
orientation,
colorStops
}) {
const serializedOrientation = serializeGradientOrientation(orientation);
const serializedColorStops = colorStops.sort((colorStop1, colorStop2) => {
const getNumericStopValue = (colorStop) => {
return colorStop?.length?.value === void 0 ? 0 : parseInt(colorStop.length.value);
};
return getNumericStopValue(colorStop1) - getNumericStopValue(colorStop2);
}).map(serializeGradientColorStop);
return `${type}(${[serializedOrientation, ...serializedColorStops].filter(Boolean).join(",")})`;
}
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/utils.js
k([names]);
function getLinearGradientRepresentation(gradientAST) {
return serializeGradient({
type: "linear-gradient",
orientation: HORIZONTAL_GRADIENT_ORIENTATION,
colorStops: gradientAST.colorStops
});
}
function hasUnsupportedLength(item) {
return item.length === void 0 || item.length.type !== "%";
}
function getGradientAstWithDefault(value) {
let gradientAST;
let hasGradient = !!value;
const valueToParse = value !== null && value !== void 0 ? value : DEFAULT_GRADIENT;
try {
gradientAST = build_node.parse(valueToParse)[0];
} catch (error) {
console.warn("wp.components.CustomGradientPicker failed to parse the gradient with error", error);
gradientAST = build_node.parse(DEFAULT_GRADIENT)[0];
hasGradient = false;
}
if (!Array.isArray(gradientAST.orientation) && gradientAST.orientation?.type === "directional") {
gradientAST.orientation = {
type: "angular",
value: DIRECTIONAL_ORIENTATION_ANGLE_MAP[gradientAST.orientation.value].toString()
};
}
if (gradientAST.colorStops.some(hasUnsupportedLength)) {
const {
colorStops
} = gradientAST;
const step = 100 / (colorStops.length - 1);
colorStops.forEach((stop, index) => {
stop.length = {
value: `${step * index}`,
type: "%"
};
});
}
return {
gradientAST,
hasGradient
};
}
function getGradientAstWithControlPoints(gradientAST, newControlPoints) {
return {
...gradientAST,
colorStops: newControlPoints.map(({
position,
color
}) => {
const {
r,
g,
b,
a
} = w(color).toRgb();
return {
length: {
type: "%",
value: position?.toString()
},
type: a < 1 ? "rgba" : "rgb",
value: a < 1 ? [`${r}`, `${g}`, `${b}`, `${a}`] : [`${r}`, `${g}`, `${b}`]
};
})
};
}
function getStopCssColor(colorStop) {
switch (colorStop.type) {
case "hex":
return `#${colorStop.value}`;
case "literal":
return colorStop.value;
case "var":
return `${colorStop.type}(${colorStop.value})`;
case "rgb":
case "rgba":
return `${colorStop.type}(${colorStop.value.join(",")})`;
case "hsl": {
const [hue, saturation, lightness] = colorStop.value;
return `hsl(${hue},${saturation}%,${lightness}%)`;
}
case "hsla": {
const [hue, saturation, lightness, alpha] = colorStop.value;
return `hsla(${hue},${saturation}%,${lightness}%,${alpha})`;
}
default:
return "transparent";
}
}
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/styles/custom-gradient-picker-styles.js
function custom_gradient_picker_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const SelectWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_block_component_component_default, true ? {
target: "e10bzpgi1"
} : 0)( true ? {
name: "1gvx10y",
styles: "flex-grow:5"
} : 0);
const AccessoryWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_block_component_component_default, true ? {
target: "e10bzpgi0"
} : 0)( true ? {
name: "1gvx10y",
styles: "flex-grow:5"
} : 0);
;// ./node_modules/@wordpress/components/build-module/custom-gradient-picker/index.js
const GradientAnglePicker = ({
gradientAST,
hasGradient,
onChange
}) => {
var _gradientAST$orientat;
const angle = (_gradientAST$orientat = gradientAST?.orientation?.value) !== null && _gradientAST$orientat !== void 0 ? _gradientAST$orientat : DEFAULT_LINEAR_GRADIENT_ANGLE;
const onAngleChange = (newAngle) => {
onChange(serializeGradient({
...gradientAST,
orientation: {
type: "angular",
value: `${newAngle}`
}
}));
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(angle_picker_control_default, {
onChange: onAngleChange,
value: hasGradient ? angle : ""
});
};
const GradientTypePicker = ({
gradientAST,
hasGradient,
onChange
}) => {
const {
type
} = gradientAST;
const onSetLinearGradient = () => {
onChange(serializeGradient({
...gradientAST,
orientation: gradientAST.orientation ? void 0 : HORIZONTAL_GRADIENT_ORIENTATION,
type: "linear-gradient"
}));
};
const onSetRadialGradient = () => {
const {
orientation,
...restGradientAST
} = gradientAST;
onChange(serializeGradient({
...restGradientAST,
type: "radial-gradient"
}));
};
const handleOnChange = (next) => {
if (next === "linear-gradient") {
onSetLinearGradient();
}
if (next === "radial-gradient") {
onSetRadialGradient();
}
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(select_control_default, {
__nextHasNoMarginBottom: true,
className: "components-custom-gradient-picker__type-picker",
label: (0,external_wp_i18n_namespaceObject.__)("Type"),
labelPosition: "top",
onChange: handleOnChange,
options: GRADIENT_OPTIONS,
size: "__unstable-large",
value: hasGradient ? type : void 0
});
};
function CustomGradientPicker({
value,
onChange,
enableAlpha = true,
__experimentalIsRenderedInSidebar = false
}) {
const {
gradientAST,
hasGradient
} = getGradientAstWithDefault(value);
const background = getLinearGradientRepresentation(gradientAST);
const controlPoints = gradientAST.colorStops.map((colorStop) => {
return {
color: getStopCssColor(colorStop),
// Although it's already been checked by `hasUnsupportedLength` in `getGradientAstWithDefault`,
// TypeScript doesn't know that `colorStop.length` is not undefined here.
// @ts-expect-error
position: parseInt(colorStop.length.value)
};
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
spacing: 4,
className: "components-custom-gradient-picker",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomGradientBar, {
__experimentalIsRenderedInSidebar,
disableAlpha: !enableAlpha,
background,
hasGradient,
value: controlPoints,
onChange: (newControlPoints) => {
onChange(serializeGradient(getGradientAstWithControlPoints(gradientAST, newControlPoints)));
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(flex_component_component_default, {
gap: 3,
className: "components-custom-gradient-picker__ui-line",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GradientTypePicker, {
gradientAST,
hasGradient,
onChange
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(AccessoryWrapper, {
children: gradientAST.type === "linear-gradient" && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GradientAnglePicker, {
gradientAST,
hasGradient,
onChange
})
})]
})]
});
}
var custom_gradient_picker_default = CustomGradientPicker;
;// ./node_modules/@wordpress/components/build-module/gradient-picker/index.js
const isMultipleOriginObject = (obj) => Array.isArray(obj.gradients) && !("gradient" in obj);
const isMultipleOriginArray = (arr) => {
return arr.length > 0 && arr.every((gradientObj) => isMultipleOriginObject(gradientObj));
};
function SingleOrigin({
className,
clearGradient,
gradients,
onChange,
value,
...additionalProps
}) {
const gradientOptions = (0,external_wp_element_namespaceObject.useMemo)(() => {
return gradients.map(({
gradient,
name,
slug
}, index) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.Option, {
value: gradient,
isSelected: value === gradient,
tooltipText: name || // translators: %s: gradient code e.g: "linear-gradient(90deg, rgba(98,16,153,1) 0%, rgba(172,110,22,1) 100%);".
(0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("Gradient code: %s"), gradient),
style: {
color: "rgba( 0,0,0,0 )",
background: gradient
},
onClick: value === gradient ? clearGradient : () => onChange(gradient, index),
"aria-label": name ? (
// translators: %s: The name of the gradient e.g: "Angular red to blue".
(0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("Gradient: %s"), name)
) : (
// translators: %s: gradient code e.g: "linear-gradient(90deg, rgba(98,16,153,1) 0%, rgba(172,110,22,1) 100%);".
(0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("Gradient code: %s"), gradient)
)
}, slug));
}, [gradients, value, onChange, clearGradient]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.OptionGroup, {
className,
options: gradientOptions,
...additionalProps
});
}
function MultipleOrigin({
className,
clearGradient,
gradients,
onChange,
value,
headingLevel
}) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(MultipleOrigin);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(v_stack_component_component_default, {
spacing: 3,
className,
children: gradients.map(({
name,
gradients: gradientSet
}, index) => {
const id = `color-palette-${instanceId}-${index}`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
spacing: 2,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorHeading, {
level: headingLevel,
id,
children: name
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleOrigin, {
clearGradient,
gradients: gradientSet,
onChange: (gradient) => onChange(gradient, index),
value,
"aria-labelledby": id
})]
}, index);
})
});
}
function Component(props) {
const {
asButtons,
loop,
actions,
headingLevel,
"aria-label": ariaLabel,
"aria-labelledby": ariaLabelledby,
...additionalProps
} = props;
const options = isMultipleOriginArray(props.gradients) ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MultipleOrigin, {
headingLevel,
...additionalProps
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SingleOrigin, {
...additionalProps
});
const {
metaProps,
labelProps
} = getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default, {
...metaProps,
...labelProps,
actions,
options
});
}
function GradientPicker({
className,
gradients = [],
onChange,
value,
clearable = true,
enableAlpha = true,
disableCustomGradients = false,
__experimentalIsRenderedInSidebar,
headingLevel = 2,
...additionalProps
}) {
const clearGradient = (0,external_wp_element_namespaceObject.useCallback)(() => onChange(void 0), [onChange]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
spacing: gradients.length ? 4 : 0,
children: [!disableCustomGradients && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(custom_gradient_picker_default, {
__experimentalIsRenderedInSidebar,
enableAlpha,
value,
onChange
}), (gradients.length > 0 || clearable) && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
...additionalProps,
className,
clearGradient,
gradients,
onChange,
value,
actions: clearable && !disableCustomGradients && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.ButtonAction, {
onClick: clearGradient,
accessibleWhenDisabled: true,
disabled: !value,
children: (0,external_wp_i18n_namespaceObject.__)("Clear")
}),
headingLevel
})]
});
}
var gradient_picker_default = GradientPicker;
;// ./node_modules/@wordpress/icons/build-module/library/menu.js
var menu_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M5 5v1.5h14V5H5zm0 7.8h14v-1.5H5v1.5zM5 19h14v-1.5H5V19z" }) });
;// external ["wp","dom"]
const external_wp_dom_namespaceObject = window["wp"]["dom"];
;// ./node_modules/@wordpress/components/build-module/navigable-container/container.js
const container_noop = () => {
};
const MENU_ITEM_ROLES = ["menuitem", "menuitemradio", "menuitemcheckbox"];
function cycleValue(value, total, offset) {
const nextValue = value + offset;
if (nextValue < 0) {
return total + nextValue;
} else if (nextValue >= total) {
return nextValue - total;
}
return nextValue;
}
class NavigableContainer extends external_wp_element_namespaceObject.Component {
constructor(args) {
super(args);
this.onKeyDown = this.onKeyDown.bind(this);
this.bindContainer = this.bindContainer.bind(this);
this.getFocusableContext = this.getFocusableContext.bind(this);
this.getFocusableIndex = this.getFocusableIndex.bind(this);
}
componentDidMount() {
if (!this.container) {
return;
}
this.container.addEventListener("keydown", this.onKeyDown);
}
componentWillUnmount() {
if (!this.container) {
return;
}
this.container.removeEventListener("keydown", this.onKeyDown);
}
bindContainer(ref) {
const {
forwardedRef
} = this.props;
this.container = ref;
if (typeof forwardedRef === "function") {
forwardedRef(ref);
} else if (forwardedRef && "current" in forwardedRef) {
forwardedRef.current = ref;
}
}
getFocusableContext(target) {
if (!this.container) {
return null;
}
const {
onlyBrowserTabstops
} = this.props;
const finder = onlyBrowserTabstops ? external_wp_dom_namespaceObject.focus.tabbable : external_wp_dom_namespaceObject.focus.focusable;
const focusables = finder.find(this.container);
const index = this.getFocusableIndex(focusables, target);
if (index > -1 && target) {
return {
index,
target,
focusables
};
}
return null;
}
getFocusableIndex(focusables, target) {
return focusables.indexOf(target);
}
onKeyDown(event) {
if (this.props.onKeyDown) {
this.props.onKeyDown(event);
}
const {
getFocusableContext
} = this;
const {
cycle = true,
eventToOffset,
onNavigate = container_noop,
stopNavigationEvents
} = this.props;
const offset = eventToOffset(event);
if (offset !== void 0 && stopNavigationEvents) {
event.stopImmediatePropagation();
const targetRole = event.target?.getAttribute("role");
const targetHasMenuItemRole = !!targetRole && MENU_ITEM_ROLES.includes(targetRole);
if (targetHasMenuItemRole) {
event.preventDefault();
}
}
if (!offset) {
return;
}
const activeElement = event.target?.ownerDocument?.activeElement;
if (!activeElement) {
return;
}
const context = getFocusableContext(activeElement);
if (!context) {
return;
}
const {
index,
focusables
} = context;
const nextIndex = cycle ? cycleValue(index, focusables.length, offset) : index + offset;
if (nextIndex >= 0 && nextIndex < focusables.length) {
focusables[nextIndex].focus();
onNavigate(nextIndex, focusables[nextIndex]);
if (event.code === "Tab") {
event.preventDefault();
}
}
}
render() {
const {
children,
stopNavigationEvents,
eventToOffset,
onNavigate,
onKeyDown,
cycle,
onlyBrowserTabstops,
forwardedRef,
...restProps
} = this.props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref: this.bindContainer,
...restProps,
children
});
}
}
const forwardedNavigableContainer = (props, ref) => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigableContainer, {
...props,
forwardedRef: ref
});
};
forwardedNavigableContainer.displayName = "NavigableContainer";
var container_default = (0,external_wp_element_namespaceObject.forwardRef)(forwardedNavigableContainer);
;// ./node_modules/@wordpress/components/build-module/navigable-container/menu.js
function UnforwardedNavigableMenu({
role = "menu",
orientation = "vertical",
...rest
}, ref) {
const eventToOffset = (evt) => {
const {
code
} = evt;
let next = ["ArrowDown"];
let previous = ["ArrowUp"];
if (orientation === "horizontal") {
next = ["ArrowRight"];
previous = ["ArrowLeft"];
}
if (orientation === "both") {
next = ["ArrowRight", "ArrowDown"];
previous = ["ArrowLeft", "ArrowUp"];
}
if (next.includes(code)) {
return 1;
} else if (previous.includes(code)) {
return -1;
} else if (["ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight"].includes(code)) {
return 0;
}
return void 0;
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(container_default, {
ref,
stopNavigationEvents: true,
onlyBrowserTabstops: false,
role,
"aria-orientation": role !== "presentation" && (orientation === "vertical" || orientation === "horizontal") ? orientation : void 0,
eventToOffset,
...rest
});
}
const NavigableMenu = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedNavigableMenu);
var menu_menu_default = NavigableMenu;
;// ./node_modules/@wordpress/components/build-module/dropdown-menu/index.js
function dropdown_menu_mergeProps(defaultProps = {}, props = {}) {
const mergedProps = {
...defaultProps,
...props
};
if (props.className && defaultProps.className) {
mergedProps.className = dist_clsx(props.className, defaultProps.className);
}
return mergedProps;
}
function dropdown_menu_isFunction(maybeFunc) {
return typeof maybeFunc === "function";
}
function UnconnectedDropdownMenu(dropdownMenuProps) {
const {
children,
className,
controls,
icon = menu_default,
label,
popoverProps,
toggleProps,
menuProps,
disableOpenOnArrowDown = false,
text,
noIcons,
open,
defaultOpen,
onToggle: onToggleProp,
// Context
variant
} = useContextSystem(dropdownMenuProps, "DropdownMenu");
if (!controls?.length && !dropdown_menu_isFunction(children)) {
return null;
}
let controlSets;
if (controls?.length) {
controlSets = controls;
if (!Array.isArray(controlSets[0])) {
controlSets = [controls];
}
}
const mergedPopoverProps = dropdown_menu_mergeProps({
className: "components-dropdown-menu__popover",
variant
}, popoverProps);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_default, {
className,
popoverProps: mergedPopoverProps,
renderToggle: ({
isOpen,
onToggle
}) => {
var _toggleProps$showTool;
const openOnArrowDown = (event) => {
if (disableOpenOnArrowDown) {
return;
}
if (!isOpen && event.code === "ArrowDown") {
event.preventDefault();
onToggle();
}
};
const {
as: Toggle = button_default,
...restToggleProps
} = toggleProps !== null && toggleProps !== void 0 ? toggleProps : {};
const mergedToggleProps = dropdown_menu_mergeProps({
className: dist_clsx("components-dropdown-menu__toggle", {
"is-opened": isOpen
})
}, restToggleProps);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Toggle, {
...mergedToggleProps,
icon,
onClick: (event) => {
onToggle();
if (mergedToggleProps.onClick) {
mergedToggleProps.onClick(event);
}
},
onKeyDown: (event) => {
openOnArrowDown(event);
if (mergedToggleProps.onKeyDown) {
mergedToggleProps.onKeyDown(event);
}
},
"aria-haspopup": "true",
"aria-expanded": isOpen,
label,
text,
showTooltip: (_toggleProps$showTool = toggleProps?.showTooltip) !== null && _toggleProps$showTool !== void 0 ? _toggleProps$showTool : true,
children: mergedToggleProps.children
});
},
renderContent: (props) => {
const mergedMenuProps = dropdown_menu_mergeProps({
"aria-label": label,
className: dist_clsx("components-dropdown-menu__menu", {
"no-icons": noIcons
})
}, menuProps);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(menu_menu_default, {
...mergedMenuProps,
role: "menu",
children: [dropdown_menu_isFunction(children) ? children(props) : null, controlSets?.flatMap((controlSet, indexOfSet) => controlSet.map((control, indexOfControl) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
onClick: (event) => {
event.stopPropagation();
props.onClose();
if (control.onClick) {
control.onClick();
}
},
className: dist_clsx("components-dropdown-menu__menu-item", {
"has-separator": indexOfSet > 0 && indexOfControl === 0,
"is-active": control.isActive,
"is-icon-only": !control.title
}),
icon: control.icon,
label: control.label,
"aria-checked": control.role === "menuitemcheckbox" || control.role === "menuitemradio" ? control.isActive : void 0,
role: control.role === "menuitemcheckbox" || control.role === "menuitemradio" ? control.role : "menuitem",
accessibleWhenDisabled: true,
disabled: control.isDisabled,
children: control.title
}, [indexOfSet, indexOfControl].join())))]
});
},
open,
defaultOpen,
onToggle: onToggleProp
});
}
const DropdownMenu = contextConnectWithoutRef(UnconnectedDropdownMenu, "DropdownMenu");
var dropdown_menu_default = DropdownMenu;
;// ./node_modules/@wordpress/components/build-module/palette-edit/styles.js
function palette_edit_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const IndicatorStyled = /* @__PURE__ */ emotion_styled_base_browser_esm(color_indicator_default, true ? {
target: "e1lpqc908"
} : 0)("&&{flex-shrink:0;width:", space(6), ";height:", space(6), ";}" + ( true ? "" : 0));
const NameInputControl = /* @__PURE__ */ emotion_styled_base_browser_esm(input_control_default, true ? {
target: "e1lpqc907"
} : 0)(Container, "{background:", COLORS.gray[100], ";border-radius:", config_values_default.radiusXSmall, ";", Input, Input, Input, Input, "{height:", space(8), ";}", BackdropUI, BackdropUI, BackdropUI, "{border-color:transparent;box-shadow:none;}}" + ( true ? "" : 0));
const NameContainer = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1lpqc906"
} : 0)("line-height:", space(8), ";margin-left:", space(2), ";margin-right:", space(2), ";white-space:nowrap;overflow:hidden;" + ( true ? "" : 0));
const PaletteHeading = /* @__PURE__ */ emotion_styled_base_browser_esm(heading_component_component_default, true ? {
target: "e1lpqc905"
} : 0)("text-transform:uppercase;line-height:", space(6), ";font-weight:500;&&&{font-size:11px;margin-bottom:0;}" + ( true ? "" : 0));
const PaletteActionsContainer = /* @__PURE__ */ emotion_styled_base_browser_esm(component_default, true ? {
target: "e1lpqc904"
} : 0)("height:", space(6), ";display:flex;" + ( true ? "" : 0));
const PaletteEditContents = /* @__PURE__ */ emotion_styled_base_browser_esm(component_default, true ? {
target: "e1lpqc903"
} : 0)("margin-top:", space(2), ";" + ( true ? "" : 0));
const PaletteEditStyles = /* @__PURE__ */ emotion_styled_base_browser_esm(component_default, true ? {
target: "e1lpqc902"
} : 0)( true ? {
name: "u6wnko",
styles: "&&&{.components-button.has-icon{min-width:0;padding:0;}}"
} : 0);
const DoneButton = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "e1lpqc901"
} : 0)("&&{color:", COLORS.theme.accent, ";}" + ( true ? "" : 0));
const RemoveButton = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "e1lpqc900"
} : 0)("&&{margin-top:", space(1), ";}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/palette-edit/index.js
const DEFAULT_COLOR = "#000";
function NameInput({
value,
onChange,
label
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NameInputControl, {
size: "compact",
label,
hideLabelFromVision: true,
value,
onChange
});
}
function deduplicateElementSlugs(elements) {
const slugCounts = {};
return elements.map((element) => {
var _newSlug;
let newSlug;
const {
slug
} = element;
slugCounts[slug] = (slugCounts[slug] || 0) + 1;
if (slugCounts[slug] > 1) {
newSlug = `${slug}-${slugCounts[slug] - 1}`;
}
return {
...element,
slug: (_newSlug = newSlug) !== null && _newSlug !== void 0 ? _newSlug : slug
};
});
}
function getNameAndSlugForPosition(elements, slugPrefix) {
const nameRegex = new RegExp(`^${slugPrefix}color-([\\d]+)$`);
const position = elements.reduce((previousValue, currentValue) => {
if (typeof currentValue?.slug === "string") {
const matches = currentValue?.slug.match(nameRegex);
if (matches) {
const id = parseInt(matches[1], 10);
if (id >= previousValue) {
return id + 1;
}
}
}
return previousValue;
}, 1);
return {
name: (0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: %d: is an id for a custom color */
(0,external_wp_i18n_namespaceObject.__)("Color %d"),
position
),
slug: `${slugPrefix}color-${position}`
};
}
function ColorPickerPopover({
isGradient,
element,
onChange,
popoverProps: receivedPopoverProps,
onClose = () => {
}
}) {
const popoverProps = (0,external_wp_element_namespaceObject.useMemo)(() => ({
shift: true,
offset: 20,
// Disabling resize as it would otherwise cause the popover to show
// scrollbars while dragging the color picker's handle close to the
// popover edge.
resize: false,
placement: "left-start",
...receivedPopoverProps,
className: dist_clsx("components-palette-edit__popover", receivedPopoverProps?.className)
}), [receivedPopoverProps]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(popover_default, {
...popoverProps,
onClose,
children: [!isGradient && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LegacyAdapter, {
color: element.color,
enableAlpha: true,
onChange: (newColor) => {
onChange({
...element,
color: newColor
});
}
}), isGradient && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-palette-edit__popover-gradient-picker",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(custom_gradient_picker_default, {
__experimentalIsRenderedInSidebar: true,
value: element.gradient,
onChange: (newGradient) => {
onChange({
...element,
gradient: newGradient
});
}
})
})]
});
}
function palette_edit_Option({
canOnlyChangeValues,
element,
onChange,
onRemove,
popoverProps: receivedPopoverProps,
slugPrefix,
isGradient
}) {
const value = isGradient ? element.gradient : element.color;
const [isEditingColor, setIsEditingColor] = (0,external_wp_element_namespaceObject.useState)(false);
const [popoverAnchor, setPopoverAnchor] = (0,external_wp_element_namespaceObject.useState)(null);
const popoverProps = (0,external_wp_element_namespaceObject.useMemo)(() => ({
...receivedPopoverProps,
// Use the custom palette color item as the popover anchor.
anchor: popoverAnchor
}), [popoverAnchor, receivedPopoverProps]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(item_component_component_default, {
ref: setPopoverAnchor,
size: "small",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
justify: "flex-start",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "small",
onClick: () => {
setIsEditingColor(true);
},
"aria-label": (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s is a color or gradient name, e.g. "Red".
(0,external_wp_i18n_namespaceObject.__)("Edit: %s"),
element.name.trim().length ? element.name : value || ""
),
style: {
padding: 0
},
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(IndicatorStyled, {
colorValue: value
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_block_component_component_default, {
children: !canOnlyChangeValues ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NameInput, {
label: isGradient ? (0,external_wp_i18n_namespaceObject.__)("Gradient name") : (0,external_wp_i18n_namespaceObject.__)("Color name"),
value: element.name,
onChange: (nextName) => onChange({
...element,
name: nextName,
slug: slugPrefix + kebabCase(nextName !== null && nextName !== void 0 ? nextName : "")
})
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NameContainer, {
children: element.name.trim().length ? element.name : (
/* Fall back to non-breaking space to maintain height */
"\xA0"
)
})
}), !canOnlyChangeValues && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_item_component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RemoveButton, {
size: "small",
icon: line_solid_default,
label: (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s is a color or gradient name, e.g. "Red".
(0,external_wp_i18n_namespaceObject.__)("Remove color: %s"),
element.name.trim().length ? element.name : value || ""
),
onClick: onRemove
})
})]
}), isEditingColor && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPickerPopover, {
isGradient,
onChange,
element,
popoverProps,
onClose: () => setIsEditingColor(false)
})]
});
}
function PaletteEditListView({
elements,
onChange,
canOnlyChangeValues,
slugPrefix,
isGradient,
popoverProps,
addColorRef
}) {
const elementsReferenceRef = (0,external_wp_element_namespaceObject.useRef)();
(0,external_wp_element_namespaceObject.useEffect)(() => {
elementsReferenceRef.current = elements;
}, [elements]);
const debounceOnChange = (0,external_wp_compose_namespaceObject.useDebounce)((updatedElements) => onChange(deduplicateElementSlugs(updatedElements)), 100);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(v_stack_component_component_default, {
spacing: 3,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(item_group_component_component_default, {
isRounded: true,
isBordered: true,
isSeparated: true,
children: elements.map((element, index) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(palette_edit_Option, {
isGradient,
canOnlyChangeValues,
element,
onChange: (newElement) => {
debounceOnChange(elements.map((currentElement, currentIndex) => {
if (currentIndex === index) {
return newElement;
}
return currentElement;
}));
},
onRemove: () => {
const newElements = elements.filter((_currentElement, currentIndex) => {
if (currentIndex === index) {
return false;
}
return true;
});
onChange(newElements.length ? newElements : void 0);
addColorRef.current?.focus();
},
slugPrefix,
popoverProps
}, index))
})
});
}
const EMPTY_ARRAY = [];
function PaletteEdit({
gradients,
colors = EMPTY_ARRAY,
onChange,
paletteLabel,
paletteLabelHeadingLevel = 2,
emptyMessage,
canOnlyChangeValues,
canReset,
slugPrefix = "",
popoverProps
}) {
const isGradient = !!gradients;
const elements = isGradient ? gradients : colors;
const [isEditing, setIsEditing] = (0,external_wp_element_namespaceObject.useState)(false);
const [editingElement, setEditingElement] = (0,external_wp_element_namespaceObject.useState)(null);
const isAdding = isEditing && !!editingElement && elements[editingElement] && !elements[editingElement].slug;
const elementsLength = elements.length;
const hasElements = elementsLength > 0;
const debounceOnChange = (0,external_wp_compose_namespaceObject.useDebounce)(onChange, 100);
const onSelectPaletteItem = (0,external_wp_element_namespaceObject.useCallback)((value, newEditingElementIndex) => {
const selectedElement = newEditingElementIndex === void 0 ? void 0 : elements[newEditingElementIndex];
const key = isGradient ? "gradient" : "color";
if (!!selectedElement && selectedElement[key] === value) {
setEditingElement(newEditingElementIndex);
} else {
setIsEditing(true);
}
}, [isGradient, elements]);
const addColorRef = (0,external_wp_element_namespaceObject.useRef)(null);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(PaletteEditStyles, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PaletteHeading, {
level: paletteLabelHeadingLevel,
children: paletteLabel
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(PaletteActionsContainer, {
children: [hasElements && isEditing && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DoneButton, {
size: "small",
onClick: () => {
setIsEditing(false);
setEditingElement(null);
},
children: (0,external_wp_i18n_namespaceObject.__)("Done")
}), !canOnlyChangeValues && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
ref: addColorRef,
size: "small",
isPressed: isAdding,
icon: plus_default,
label: isGradient ? (0,external_wp_i18n_namespaceObject.__)("Add gradient") : (0,external_wp_i18n_namespaceObject.__)("Add color"),
onClick: () => {
const {
name,
slug
} = getNameAndSlugForPosition(elements, slugPrefix);
if (!!gradients) {
onChange([...gradients, {
gradient: DEFAULT_GRADIENT,
name,
slug
}]);
} else {
onChange([...colors, {
color: DEFAULT_COLOR,
name,
slug
}]);
}
setIsEditing(true);
setEditingElement(elements.length);
}
}), hasElements && (!isEditing || !canOnlyChangeValues || canReset) && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_menu_default, {
icon: more_vertical_default,
label: isGradient ? (0,external_wp_i18n_namespaceObject.__)("Gradient options") : (0,external_wp_i18n_namespaceObject.__)("Color options"),
toggleProps: {
size: "small"
},
children: ({
onClose
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(menu_menu_default, {
role: "menu",
children: [!isEditing && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
variant: "tertiary",
onClick: () => {
setIsEditing(true);
onClose();
},
className: "components-palette-edit__menu-button",
children: (0,external_wp_i18n_namespaceObject.__)("Show details")
}), !canOnlyChangeValues && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
variant: "tertiary",
onClick: () => {
setEditingElement(null);
setIsEditing(false);
onChange();
onClose();
},
className: "components-palette-edit__menu-button",
children: isGradient ? (0,external_wp_i18n_namespaceObject.__)("Remove all gradients") : (0,external_wp_i18n_namespaceObject.__)("Remove all colors")
}), canReset && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
className: "components-palette-edit__menu-button",
variant: "tertiary",
onClick: () => {
setEditingElement(null);
onChange();
onClose();
},
children: isGradient ? (0,external_wp_i18n_namespaceObject.__)("Reset gradient") : (0,external_wp_i18n_namespaceObject.__)("Reset colors")
})]
})
})
})]
})]
}), hasElements && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(PaletteEditContents, {
children: [isEditing && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PaletteEditListView, {
canOnlyChangeValues,
elements,
onChange,
slugPrefix,
isGradient,
popoverProps,
addColorRef
}), !isEditing && editingElement !== null && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorPickerPopover, {
isGradient,
onClose: () => setEditingElement(null),
onChange: (newElement) => {
debounceOnChange(
// @ts-expect-error TODO: Don't know how to resolve
elements.map((currentElement, currentIndex) => {
if (currentIndex === editingElement) {
return newElement;
}
return currentElement;
})
);
},
element: elements[editingElement !== null && editingElement !== void 0 ? editingElement : -1],
popoverProps
}), !isEditing && (isGradient ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(gradient_picker_default, {
gradients,
onChange: onSelectPaletteItem,
clearable: false,
disableCustomGradients: true
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_palette_default, {
colors,
onChange: onSelectPaletteItem,
clearable: false,
disableCustomColors: true
}))]
}), !hasElements && emptyMessage && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PaletteEditContents, {
children: emptyMessage
})]
});
}
var palette_edit_default = PaletteEdit;
;// ./node_modules/@wordpress/icons/build-module/library/close-small.js
var close_small_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M12 13.06l3.712 3.713 1.061-1.06L13.061 12l3.712-3.712-1.06-1.06L12 10.938 8.288 7.227l-1.061 1.06L10.939 12l-3.712 3.712 1.06 1.061L12 13.061z" }) });
;// ./node_modules/@wordpress/components/build-module/combobox-control/styles.js
const deprecatedDefaultSize = ({
__next40pxDefaultSize
}) => !__next40pxDefaultSize && /* @__PURE__ */ emotion_react_browser_esm_css("height:28px;padding-left:", space(1), ";padding-right:", space(1), ";" + ( true ? "" : 0), true ? "" : 0);
const InputWrapperFlex = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_component_component_default, true ? {
target: "evuatpg0"
} : 0)("height:38px;padding-left:", space(2), ";padding-right:", space(2), ";", deprecatedDefaultSize, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/form-token-field/token-input.js
function UnForwardedTokenInput(props, ref) {
const {
value,
isExpanded,
instanceId,
selectedSuggestionIndex,
className,
onChange,
onFocus,
onBlur,
...restProps
} = props;
const [hasFocus, setHasFocus] = (0,external_wp_element_namespaceObject.useState)(false);
const size = value ? value.length + 1 : 0;
const onChangeHandler = (event) => {
if (onChange) {
onChange({
value: event.target.value
});
}
};
const onFocusHandler = (e) => {
setHasFocus(true);
onFocus?.(e);
};
const onBlurHandler = (e) => {
setHasFocus(false);
onBlur?.(e);
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
ref,
id: `components-form-token-input-${instanceId}`,
type: "text",
...restProps,
value: value || "",
onChange: onChangeHandler,
onFocus: onFocusHandler,
onBlur: onBlurHandler,
size,
className: dist_clsx(className, "components-form-token-field__input"),
autoComplete: "off",
role: "combobox",
"aria-expanded": isExpanded,
"aria-autocomplete": "list",
"aria-owns": isExpanded ? `components-form-token-suggestions-${instanceId}` : void 0,
"aria-activedescendant": (
// Only add the `aria-activedescendant` attribute when:
// - the user is actively interacting with the input (`hasFocus`)
// - there is a selected suggestion (`selectedSuggestionIndex !== -1`)
// - the list of suggestions are rendered in the DOM (`isExpanded`)
hasFocus && selectedSuggestionIndex !== -1 && isExpanded ? `components-form-token-suggestions-${instanceId}-${selectedSuggestionIndex}` : void 0
),
"aria-describedby": `components-form-token-suggestions-howto-${instanceId}`
});
}
const TokenInput = (0,external_wp_element_namespaceObject.forwardRef)(UnForwardedTokenInput);
var token_input_default = TokenInput;
;// ./node_modules/@wordpress/components/build-module/form-token-field/suggestions-list.js
const handleMouseDown = (e) => {
e.preventDefault();
};
function SuggestionsList({
selectedIndex,
scrollIntoView,
match,
onHover,
onSelect,
suggestions = [],
displayTransform,
instanceId,
__experimentalRenderItem
}) {
const listRef = (0,external_wp_compose_namespaceObject.useRefEffect)((listNode) => {
if (selectedIndex > -1 && scrollIntoView && listNode.children[selectedIndex]) {
listNode.children[selectedIndex].scrollIntoView({
behavior: "instant",
block: "nearest",
inline: "nearest"
});
}
}, [selectedIndex, scrollIntoView]);
const handleHover = (suggestion) => {
return () => {
onHover?.(suggestion);
};
};
const handleClick = (suggestion) => {
return () => {
onSelect?.(suggestion);
};
};
const computeSuggestionMatch = (suggestion) => {
const matchText = displayTransform(match).normalize("NFKC").toLocaleLowerCase();
if (matchText.length === 0) {
return null;
}
const transformedSuggestion = displayTransform(suggestion);
const indexOfMatch = transformedSuggestion.normalize("NFKC").toLocaleLowerCase().indexOf(matchText);
return {
suggestionBeforeMatch: transformedSuggestion.substring(0, indexOfMatch),
suggestionMatch: transformedSuggestion.substring(indexOfMatch, indexOfMatch + matchText.length),
suggestionAfterMatch: transformedSuggestion.substring(indexOfMatch + matchText.length)
};
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("ul", {
ref: listRef,
className: "components-form-token-field__suggestions-list",
id: `components-form-token-suggestions-${instanceId}`,
role: "listbox",
children: [suggestions.map((suggestion, index) => {
const matchText = computeSuggestionMatch(suggestion);
const isSelected = index === selectedIndex;
const isDisabled = typeof suggestion === "object" && suggestion?.disabled;
const key = typeof suggestion === "object" && "value" in suggestion ? suggestion?.value : displayTransform(suggestion);
const className = dist_clsx("components-form-token-field__suggestion", {
"is-selected": isSelected
});
let output;
if (typeof __experimentalRenderItem === "function") {
output = __experimentalRenderItem({
item: suggestion
});
} else if (matchText) {
output = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
"aria-label": displayTransform(suggestion),
children: [matchText.suggestionBeforeMatch, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("strong", {
className: "components-form-token-field__suggestion-match",
children: matchText.suggestionMatch
}), matchText.suggestionAfterMatch]
});
} else {
output = displayTransform(suggestion);
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("li", {
id: `components-form-token-suggestions-${instanceId}-${index}`,
role: "option",
className,
onMouseDown: handleMouseDown,
onClick: handleClick(suggestion),
onMouseEnter: handleHover(suggestion),
"aria-selected": index === selectedIndex,
"aria-disabled": isDisabled,
children: output
}, key);
}), suggestions.length === 0 && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("li", {
className: "components-form-token-field__suggestion is-empty",
children: (0,external_wp_i18n_namespaceObject.__)("No items found")
})]
});
}
var suggestions_list_default = SuggestionsList;
;// ./node_modules/@wordpress/components/build-module/higher-order/with-focus-outside/index.js
var with_focus_outside_default = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((WrappedComponent) => (props) => {
const [handleFocusOutside, setHandleFocusOutside] = (0,external_wp_element_namespaceObject.useState)(void 0);
const bindFocusOutsideHandler = (0,external_wp_element_namespaceObject.useCallback)((node) => setHandleFocusOutside(() => node?.handleFocusOutside ? node.handleFocusOutside.bind(node) : void 0), []);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...(0,external_wp_compose_namespaceObject.__experimentalUseFocusOutside)(handleFocusOutside),
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
ref: bindFocusOutsideHandler,
...props
})
});
}, "withFocusOutside");
;// ./node_modules/@wordpress/components/build-module/spinner/styles.js
function spinner_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const spinAnimation = emotion_react_browser_esm_keyframes`
from {
transform: rotate(0deg);
}
to {
transform: rotate(360deg);
}
`;
const StyledSpinner = /* @__PURE__ */ emotion_styled_base_browser_esm("svg", true ? {
target: "ea4tfvq2"
} : 0)("width:", config_values_default.spinnerSize, "px;height:", config_values_default.spinnerSize, "px;display:inline-block;margin:5px 11px 0;position:relative;color:", COLORS.theme.accent, ";overflow:visible;opacity:1;background-color:transparent;" + ( true ? "" : 0));
const commonPathProps = true ? {
name: "9s4963",
styles: "fill:transparent;stroke-width:1.5px"
} : 0;
const SpinnerTrack = /* @__PURE__ */ emotion_styled_base_browser_esm("circle", true ? {
target: "ea4tfvq1"
} : 0)(commonPathProps, ";stroke:", COLORS.gray[300], ";" + ( true ? "" : 0));
const SpinnerIndicator = /* @__PURE__ */ emotion_styled_base_browser_esm("path", true ? {
target: "ea4tfvq0"
} : 0)(commonPathProps, ";stroke:currentColor;stroke-linecap:round;transform-origin:50% 50%;animation:1.4s linear infinite both ", spinAnimation, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/spinner/index.js
function UnforwardedSpinner({
className,
...props
}, forwardedRef) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(StyledSpinner, {
className: dist_clsx("components-spinner", className),
viewBox: "0 0 100 100",
width: "16",
height: "16",
xmlns: "http://www.w3.org/2000/svg",
role: "presentation",
focusable: "false",
...props,
ref: forwardedRef,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SpinnerTrack, {
cx: "50",
cy: "50",
r: "50",
vectorEffect: "non-scaling-stroke"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SpinnerIndicator, {
d: "m 50 0 a 50 50 0 0 1 50 50",
vectorEffect: "non-scaling-stroke"
})]
});
}
const Spinner = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedSpinner);
var spinner_default = Spinner;
;// ./node_modules/@wordpress/components/build-module/combobox-control/index.js
const combobox_control_noop = () => {
};
const DetectOutside = with_focus_outside_default(class extends external_wp_element_namespaceObject.Component {
handleFocusOutside(event) {
this.props.onFocusOutside(event);
}
render() {
return this.props.children;
}
});
const getIndexOfMatchingSuggestion = (selectedSuggestion, matchingSuggestions) => selectedSuggestion === null ? -1 : matchingSuggestions.indexOf(selectedSuggestion);
function ComboboxControl(props) {
var _currentOption$label;
const {
__nextHasNoMarginBottom = false,
__next40pxDefaultSize = false,
value: valueProp,
label,
options,
onChange: onChangeProp,
onFilterValueChange = combobox_control_noop,
hideLabelFromVision,
help,
allowReset = true,
className,
isLoading = false,
messages = {
selected: (0,external_wp_i18n_namespaceObject.__)("Item selected.")
},
__experimentalRenderItem,
expandOnFocus = true,
placeholder
} = useDeprecated36pxDefaultSizeProp(props);
const [value, setValue] = useControlledValue({
value: valueProp,
onChange: onChangeProp
});
const currentOption = options.find((option) => option.value === value);
const currentLabel = (_currentOption$label = currentOption?.label) !== null && _currentOption$label !== void 0 ? _currentOption$label : "";
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ComboboxControl, "combobox-control");
const [selectedSuggestion, setSelectedSuggestion] = (0,external_wp_element_namespaceObject.useState)(currentOption || null);
const [isExpanded, setIsExpanded] = (0,external_wp_element_namespaceObject.useState)(false);
const [inputHasFocus, setInputHasFocus] = (0,external_wp_element_namespaceObject.useState)(false);
const [inputValue, setInputValue] = (0,external_wp_element_namespaceObject.useState)("");
const inputContainer = (0,external_wp_element_namespaceObject.useRef)(null);
const matchingSuggestions = (0,external_wp_element_namespaceObject.useMemo)(() => {
const startsWithMatch = [];
const containsMatch = [];
const match = normalizeTextString(inputValue);
options.forEach((option) => {
const index = normalizeTextString(option.label).indexOf(match);
if (index === 0) {
startsWithMatch.push(option);
} else if (index > 0) {
containsMatch.push(option);
}
});
return startsWithMatch.concat(containsMatch);
}, [inputValue, options]);
const onSuggestionSelected = (newSelectedSuggestion) => {
if (newSelectedSuggestion.disabled) {
return;
}
setValue(newSelectedSuggestion.value);
(0,external_wp_a11y_namespaceObject.speak)(messages.selected, "assertive");
setSelectedSuggestion(newSelectedSuggestion);
setInputValue("");
setIsExpanded(false);
};
const handleArrowNavigation = (offset = 1) => {
const index = getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions);
let nextIndex = index + offset;
if (nextIndex < 0) {
nextIndex = matchingSuggestions.length - 1;
} else if (nextIndex >= matchingSuggestions.length) {
nextIndex = 0;
}
setSelectedSuggestion(matchingSuggestions[nextIndex]);
setIsExpanded(true);
};
const onKeyDown = withIgnoreIMEEvents((event) => {
let preventDefault = false;
if (event.defaultPrevented) {
return;
}
switch (event.code) {
case "Enter":
if (selectedSuggestion) {
onSuggestionSelected(selectedSuggestion);
preventDefault = true;
}
break;
case "ArrowUp":
handleArrowNavigation(-1);
preventDefault = true;
break;
case "ArrowDown":
handleArrowNavigation(1);
preventDefault = true;
break;
case "Escape":
setIsExpanded(false);
setSelectedSuggestion(null);
preventDefault = true;
break;
default:
break;
}
if (preventDefault) {
event.preventDefault();
}
});
const onBlur = () => {
setInputHasFocus(false);
};
const onFocus = () => {
setInputHasFocus(true);
if (expandOnFocus) {
setIsExpanded(true);
}
onFilterValueChange("");
setInputValue("");
};
const onClick = () => {
setIsExpanded(true);
};
const onFocusOutside = () => {
setIsExpanded(false);
};
const onInputChange = (event) => {
const text = event.value;
setInputValue(text);
onFilterValueChange(text);
if (inputHasFocus) {
setIsExpanded(true);
}
};
const handleOnReset = () => {
setValue(null);
inputContainer.current?.focus();
};
const handleResetStopPropagation = (event) => {
event.stopPropagation();
};
(0,external_wp_element_namespaceObject.useEffect)(() => {
const hasMatchingSuggestions = matchingSuggestions.length > 0;
const hasSelectedMatchingSuggestions = getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions) > 0;
if (hasMatchingSuggestions && !hasSelectedMatchingSuggestions) {
setSelectedSuggestion(matchingSuggestions[0]);
}
}, [matchingSuggestions, selectedSuggestion]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const hasMatchingSuggestions = matchingSuggestions.length > 0;
if (isExpanded) {
const message = hasMatchingSuggestions ? (0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: %d: number of results. */
(0,external_wp_i18n_namespaceObject._n)("%d result found, use up and down arrow keys to navigate.", "%d results found, use up and down arrow keys to navigate.", matchingSuggestions.length),
matchingSuggestions.length
) : (0,external_wp_i18n_namespaceObject.__)("No results.");
(0,external_wp_a11y_namespaceObject.speak)(message, "polite");
}
}, [matchingSuggestions, isExpanded]);
maybeWarnDeprecated36pxSize({
componentName: "ComboboxControl",
__next40pxDefaultSize,
size: void 0
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DetectOutside, {
onFocusOutside,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
__nextHasNoMarginBottom,
__associatedWPComponentName: "ComboboxControl",
className: dist_clsx(className, "components-combobox-control"),
label,
id: `components-form-token-input-${instanceId}`,
hideLabelFromVision,
help,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-combobox-control__suggestions-container",
tabIndex: -1,
onKeyDown,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(InputWrapperFlex, {
__next40pxDefaultSize,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_block_component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(token_input_default, {
className: "components-combobox-control__input",
instanceId,
ref: inputContainer,
placeholder,
value: isExpanded ? inputValue : currentLabel,
onFocus,
onBlur,
onClick,
isExpanded,
selectedSuggestionIndex: getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions),
onChange: onInputChange
})
}), isLoading && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spinner_default, {}), allowReset && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "small",
icon: close_small_default,
disabled: !value,
onClick: handleOnReset,
onKeyDown: handleResetStopPropagation,
label: (0,external_wp_i18n_namespaceObject.__)("Reset")
})]
}), isExpanded && !isLoading && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(suggestions_list_default, {
instanceId,
match: {
label: inputValue,
value: ""
},
displayTransform: (suggestion) => suggestion.label,
suggestions: matchingSuggestions,
selectedIndex: getIndexOfMatchingSuggestion(selectedSuggestion, matchingSuggestions),
onHover: setSelectedSuggestion,
onSelect: onSuggestionSelected,
scrollIntoView: true,
__experimentalRenderItem
})]
})
})
});
}
var combobox_control_default = ComboboxControl;
;// ./node_modules/@wordpress/components/build-module/composite/legacy/index.js
function mapLegacyStatePropsToComponentProps(legacyProps) {
if (legacyProps.state) {
const {
state,
...rest
} = legacyProps;
const {
store,
...props
} = mapLegacyStatePropsToComponentProps(state);
return {
...rest,
...props,
store
};
}
return legacyProps;
}
const LEGACY_TO_NEW_DISPLAY_NAME = {
__unstableComposite: "Composite",
__unstableCompositeGroup: "Composite.Group or Composite.Row",
__unstableCompositeItem: "Composite.Item",
__unstableUseCompositeState: "Composite"
};
function proxyComposite(ProxiedComponent, propMap = {}) {
var _ProxiedComponent$dis;
const displayName = (_ProxiedComponent$dis = ProxiedComponent.displayName) !== null && _ProxiedComponent$dis !== void 0 ? _ProxiedComponent$dis : "";
const Component = (legacyProps) => {
external_wp_deprecated_default()(`wp.components.${displayName}`, {
since: "6.7",
alternative: LEGACY_TO_NEW_DISPLAY_NAME.hasOwnProperty(displayName) ? LEGACY_TO_NEW_DISPLAY_NAME[displayName] : void 0
});
const {
store,
...rest
} = mapLegacyStatePropsToComponentProps(legacyProps);
let props = rest;
props = {
...props,
id: (0,external_wp_compose_namespaceObject.useInstanceId)(store, props.baseId, props.id)
};
Object.entries(propMap).forEach(([from, to]) => {
if (props.hasOwnProperty(from)) {
Object.assign(props, {
[to]: props[from]
});
delete props[from];
}
});
delete props.baseId;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ProxiedComponent, {
...props,
store
});
};
Component.displayName = displayName;
return Component;
}
const UnproxiedCompositeGroup = (0,external_wp_element_namespaceObject.forwardRef)(({
role,
...props
}, ref) => {
const Component = role === "row" ? composite_Composite.Row : composite_Composite.Group;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
ref,
role,
...props
});
});
const legacy_Composite = proxyComposite(Object.assign(composite_Composite, {
displayName: "__unstableComposite"
}), {
baseId: "id"
});
const legacy_CompositeGroup = proxyComposite(Object.assign(UnproxiedCompositeGroup, {
displayName: "__unstableCompositeGroup"
}));
const legacy_CompositeItem = proxyComposite(Object.assign(composite_Composite.Item, {
displayName: "__unstableCompositeItem"
}), {
focusable: "accessibleWhenDisabled"
});
function useCompositeState(legacyStateOptions = {}) {
external_wp_deprecated_default()(`wp.components.__unstableUseCompositeState`, {
since: "6.7",
alternative: LEGACY_TO_NEW_DISPLAY_NAME.__unstableUseCompositeState
});
const {
baseId,
currentId: defaultActiveId,
orientation,
rtl = false,
loop: focusLoop = false,
wrap: focusWrap = false,
shift: focusShift = false,
// eslint-disable-next-line camelcase
unstable_virtual: virtualFocus
} = legacyStateOptions;
return {
baseId: (0,external_wp_compose_namespaceObject.useInstanceId)(legacy_Composite, "composite", baseId),
store: useCompositeStore({
defaultActiveId,
rtl,
orientation,
focusLoop,
focusShift,
focusWrap,
virtualFocus
})
};
}
;// ./node_modules/@wordpress/components/build-module/modal/aria-helper.js
const LIVE_REGION_ARIA_ROLES = /* @__PURE__ */ new Set(["alert", "status", "log", "marquee", "timer"]);
const hiddenElementsByDepth = [];
function modalize(modalElement) {
const elements = Array.from(document.body.children);
const hiddenElements = [];
hiddenElementsByDepth.push(hiddenElements);
for (const element of elements) {
if (element === modalElement) {
continue;
}
if (elementShouldBeHidden(element)) {
element.setAttribute("aria-hidden", "true");
hiddenElements.push(element);
}
}
}
function elementShouldBeHidden(element) {
const role = element.getAttribute("role");
return !(element.tagName === "SCRIPT" || element.hasAttribute("hidden") || element.hasAttribute("aria-hidden") || element.hasAttribute("aria-live") || role && LIVE_REGION_ARIA_ROLES.has(role));
}
function unmodalize() {
const hiddenElements = hiddenElementsByDepth.pop();
if (!hiddenElements) {
return;
}
for (const element of hiddenElements) {
element.removeAttribute("aria-hidden");
}
}
;// ./node_modules/@wordpress/components/build-module/modal/use-modal-exit-animation.js
const FRAME_ANIMATION_DURATION = config_values_default.transitionDuration;
const FRAME_ANIMATION_DURATION_NUMBER = Number.parseInt(config_values_default.transitionDuration);
const EXIT_ANIMATION_NAME = "components-modal__disappear-animation";
function useModalExitAnimation() {
const frameRef = (0,external_wp_element_namespaceObject.useRef)();
const [isAnimatingOut, setIsAnimatingOut] = (0,external_wp_element_namespaceObject.useState)(false);
const isReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
const closeModal = (0,external_wp_element_namespaceObject.useCallback)(() => new Promise((closeModalResolve) => {
const frameEl = frameRef.current;
if (isReducedMotion) {
closeModalResolve();
return;
}
if (!frameEl) {
true ? external_wp_warning_default()("wp.components.Modal: the Modal component can't be closed with an exit animation because of a missing reference to the modal frame element.") : 0;
closeModalResolve();
return;
}
let handleAnimationEnd;
const startAnimation = () => new Promise((animationResolve) => {
handleAnimationEnd = (e) => {
if (e.animationName === EXIT_ANIMATION_NAME) {
animationResolve();
}
};
frameEl.addEventListener("animationend", handleAnimationEnd);
setIsAnimatingOut(true);
});
const animationTimeout = () => new Promise((timeoutResolve) => {
setTimeout(
() => timeoutResolve(),
// Allow an extra 20% of the animation duration for the
// animationend event to fire, in case the animation frame is
// slightly delayes by some other events in the event loop.
FRAME_ANIMATION_DURATION_NUMBER * 1.2
);
});
Promise.race([startAnimation(), animationTimeout()]).then(() => {
if (handleAnimationEnd) {
frameEl.removeEventListener("animationend", handleAnimationEnd);
}
setIsAnimatingOut(false);
closeModalResolve();
});
}), [isReducedMotion]);
return {
overlayClassname: isAnimatingOut ? "is-animating-out" : void 0,
frameRef,
frameStyle: {
"--modal-frame-animation-duration": `${FRAME_ANIMATION_DURATION}`
},
closeModal
};
}
;// ./node_modules/@wordpress/components/build-module/modal/index.js
const ModalContext = (0,external_wp_element_namespaceObject.createContext)(/* @__PURE__ */ new Set());
ModalContext.displayName = "ModalContext";
const bodyOpenClasses = /* @__PURE__ */ new Map();
function UnforwardedModal(props, forwardedRef) {
const {
bodyOpenClassName = "modal-open",
role = "dialog",
title = null,
focusOnMount = true,
shouldCloseOnEsc = true,
shouldCloseOnClickOutside = true,
isDismissible = true,
/* Accessibility. */
aria = {
labelledby: void 0,
describedby: void 0
},
onRequestClose,
icon,
closeButtonLabel,
children,
style,
overlayClassName: overlayClassnameProp,
className,
contentLabel,
onKeyDown,
isFullScreen = false,
size,
headerActions = null,
__experimentalHideHeader = false
} = props;
const ref = (0,external_wp_element_namespaceObject.useRef)();
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(Modal);
const headingId = title ? `components-modal-header-${instanceId}` : aria.labelledby;
const focusOnMountRef = (0,external_wp_compose_namespaceObject.useFocusOnMount)(focusOnMount === "firstContentElement" ? "firstElement" : focusOnMount);
const constrainedTabbingRef = (0,external_wp_compose_namespaceObject.useConstrainedTabbing)();
const focusReturnRef = (0,external_wp_compose_namespaceObject.useFocusReturn)();
const contentRef = (0,external_wp_element_namespaceObject.useRef)(null);
const childrenContainerRef = (0,external_wp_element_namespaceObject.useRef)(null);
const [hasScrolledContent, setHasScrolledContent] = (0,external_wp_element_namespaceObject.useState)(false);
const [hasScrollableContent, setHasScrollableContent] = (0,external_wp_element_namespaceObject.useState)(false);
let sizeClass;
if (isFullScreen || size === "fill") {
sizeClass = "is-full-screen";
} else if (size) {
sizeClass = `has-size-${size}`;
}
const isContentScrollable = (0,external_wp_element_namespaceObject.useCallback)(() => {
if (!contentRef.current) {
return;
}
const closestScrollContainer = (0,external_wp_dom_namespaceObject.getScrollContainer)(contentRef.current);
if (contentRef.current === closestScrollContainer) {
setHasScrollableContent(true);
} else {
setHasScrollableContent(false);
}
}, [contentRef]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
modalize(ref.current);
return () => unmodalize();
}, []);
const onRequestCloseRef = (0,external_wp_element_namespaceObject.useRef)();
(0,external_wp_element_namespaceObject.useEffect)(() => {
onRequestCloseRef.current = onRequestClose;
}, [onRequestClose]);
const dismissers = (0,external_wp_element_namespaceObject.useContext)(ModalContext);
const [nestedDismissers] = (0,external_wp_element_namespaceObject.useState)(() => /* @__PURE__ */ new Set());
(0,external_wp_element_namespaceObject.useEffect)(() => {
dismissers.add(onRequestCloseRef);
for (const dismisser of dismissers) {
if (dismisser !== onRequestCloseRef) {
dismisser.current?.();
}
}
return () => {
for (const dismisser of nestedDismissers) {
dismisser.current?.();
}
dismissers.delete(onRequestCloseRef);
};
}, [dismissers, nestedDismissers]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
var _bodyOpenClasses$get;
const theClass = bodyOpenClassName;
const oneMore = 1 + ((_bodyOpenClasses$get = bodyOpenClasses.get(theClass)) !== null && _bodyOpenClasses$get !== void 0 ? _bodyOpenClasses$get : 0);
bodyOpenClasses.set(theClass, oneMore);
document.body.classList.add(bodyOpenClassName);
return () => {
const oneLess = bodyOpenClasses.get(theClass) - 1;
if (oneLess === 0) {
document.body.classList.remove(theClass);
bodyOpenClasses.delete(theClass);
} else {
bodyOpenClasses.set(theClass, oneLess);
}
};
}, [bodyOpenClassName]);
const {
closeModal,
frameRef,
frameStyle,
overlayClassname
} = useModalExitAnimation();
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (!window.ResizeObserver || !childrenContainerRef.current) {
return;
}
const resizeObserver = new ResizeObserver(isContentScrollable);
resizeObserver.observe(childrenContainerRef.current);
isContentScrollable();
return () => {
resizeObserver.disconnect();
};
}, [isContentScrollable, childrenContainerRef]);
function handleEscapeKeyDown(event) {
if (shouldCloseOnEsc && (event.code === "Escape" || event.key === "Escape") && !event.defaultPrevented) {
event.preventDefault();
closeModal().then(() => onRequestClose(event));
}
}
const onContentContainerScroll = (0,external_wp_element_namespaceObject.useCallback)((e) => {
var _e$currentTarget$scro;
const scrollY = (_e$currentTarget$scro = e?.currentTarget?.scrollTop) !== null && _e$currentTarget$scro !== void 0 ? _e$currentTarget$scro : -1;
if (!hasScrolledContent && scrollY > 0) {
setHasScrolledContent(true);
} else if (hasScrolledContent && scrollY <= 0) {
setHasScrolledContent(false);
}
}, [hasScrolledContent]);
let pressTarget = null;
const overlayPressHandlers = {
onPointerDown: (event) => {
if (event.target === event.currentTarget) {
pressTarget = event.target;
event.preventDefault();
}
},
// Closes the modal with two exceptions. 1. Opening the context menu on
// the overlay. 2. Pressing on the overlay then dragging the pointer
// over the modal and releasing. Due to the modal being a child of the
// overlay, such a gesture is a `click` on the overlay and cannot be
// excepted by a `click` handler. Thus the tactic of handling
// `pointerup` and comparing its target to that of the `pointerdown`.
onPointerUp: ({
target,
button
}) => {
const isSameTarget = target === pressTarget;
pressTarget = null;
if (button === 0 && isSameTarget) {
closeModal().then(() => onRequestClose());
}
}
};
const modal = (
// eslint-disable-next-line jsx-a11y/no-static-element-interactions
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, forwardedRef]),
className: dist_clsx("components-modal__screen-overlay", overlayClassname, overlayClassnameProp),
onKeyDown: withIgnoreIMEEvents(handleEscapeKeyDown),
...shouldCloseOnClickOutside ? overlayPressHandlers : {},
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(style_provider_default, {
document,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: dist_clsx("components-modal__frame", sizeClass, className),
style: {
...frameStyle,
...style
},
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([frameRef, constrainedTabbingRef, focusReturnRef, focusOnMount !== "firstContentElement" ? focusOnMountRef : null]),
role,
"aria-label": contentLabel,
"aria-labelledby": contentLabel ? void 0 : headingId,
"aria-describedby": aria.describedby,
tabIndex: -1,
onKeyDown,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: dist_clsx("components-modal__content", {
"hide-header": __experimentalHideHeader,
"is-scrollable": hasScrollableContent,
"has-scrolled-content": hasScrolledContent
}),
role: "document",
onScroll: onContentContainerScroll,
ref: contentRef,
"aria-label": hasScrollableContent ? (0,external_wp_i18n_namespaceObject.__)("Scrollable section") : void 0,
tabIndex: hasScrollableContent ? 0 : void 0,
children: [!__experimentalHideHeader && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-modal__header",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-modal__header-heading-container",
children: [icon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-modal__icon-container",
"aria-hidden": true,
children: icon
}), title && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("h1", {
id: headingId,
className: "components-modal__header-heading",
children: title
})]
}), headerActions, isDismissible && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
marginBottom: 0,
marginLeft: 2
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "compact",
onClick: (event) => closeModal().then(() => onRequestClose(event)),
icon: close_default,
label: closeButtonLabel || (0,external_wp_i18n_namespaceObject.__)("Close")
})]
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([childrenContainerRef, focusOnMount === "firstContentElement" ? focusOnMountRef : null]),
children
})]
})
})
})
})
);
return (0,external_wp_element_namespaceObject.createPortal)(/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ModalContext.Provider, {
value: nestedDismissers,
children: modal
}), document.body);
}
const Modal = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedModal);
var modal_default = Modal;
;// ./node_modules/@wordpress/components/build-module/confirm-dialog/styles.js
function confirm_dialog_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const styles_wrapper = true ? {
name: "7g5ii0",
styles: "&&{z-index:1000001;}"
} : 0;
;// ./node_modules/@wordpress/components/build-module/confirm-dialog/component.js
const UnconnectedConfirmDialog = (props, forwardedRef) => {
const {
isOpen: isOpenProp,
onConfirm,
onCancel,
children,
confirmButtonText,
cancelButtonText,
...otherProps
} = useContextSystem(props, "ConfirmDialog");
const cx = useCx();
const wrapperClassName = cx(styles_wrapper);
const cancelButtonRef = (0,external_wp_element_namespaceObject.useRef)();
const confirmButtonRef = (0,external_wp_element_namespaceObject.useRef)();
const [isOpen, setIsOpen] = (0,external_wp_element_namespaceObject.useState)();
const [shouldSelfClose, setShouldSelfClose] = (0,external_wp_element_namespaceObject.useState)();
(0,external_wp_element_namespaceObject.useEffect)(() => {
const isIsOpenSet = typeof isOpenProp !== "undefined";
setIsOpen(isIsOpenSet ? isOpenProp : true);
setShouldSelfClose(!isIsOpenSet);
}, [isOpenProp]);
const handleEvent = (0,external_wp_element_namespaceObject.useCallback)((callback) => (event) => {
callback?.(event);
if (shouldSelfClose) {
setIsOpen(false);
}
}, [shouldSelfClose, setIsOpen]);
const handleEnter = (0,external_wp_element_namespaceObject.useCallback)((event) => {
const isConfirmOrCancelButton = event.target === cancelButtonRef.current || event.target === confirmButtonRef.current;
if (!isConfirmOrCancelButton && event.key === "Enter") {
handleEvent(onConfirm)(event);
}
}, [handleEvent, onConfirm]);
const cancelLabel = cancelButtonText !== null && cancelButtonText !== void 0 ? cancelButtonText : (0,external_wp_i18n_namespaceObject.__)("Cancel");
const confirmLabel = confirmButtonText !== null && confirmButtonText !== void 0 ? confirmButtonText : (0,external_wp_i18n_namespaceObject.__)("OK");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: isOpen && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(modal_default, {
onRequestClose: handleEvent(onCancel),
onKeyDown: handleEnter,
closeButtonLabel: cancelLabel,
isDismissible: true,
ref: forwardedRef,
overlayClassName: wrapperClassName,
__experimentalHideHeader: true,
...otherProps,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
spacing: 8,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(text_component_component_default, {
children
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(flex_component_component_default, {
direction: "row",
justify: "flex-end",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
ref: cancelButtonRef,
variant: "tertiary",
onClick: handleEvent(onCancel),
children: cancelLabel
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
ref: confirmButtonRef,
variant: "primary",
onClick: handleEvent(onConfirm),
children: confirmLabel
})]
})]
})
})
});
};
const ConfirmDialog = contextConnect(UnconnectedConfirmDialog, "ConfirmDialog");
var confirm_dialog_component_component_default = ConfirmDialog;
;// ./node_modules/@ariakit/react-core/esm/__chunks/VEVQD5MH.js
"use client";
// src/combobox/combobox-context.tsx
var ComboboxListRoleContext = (0,external_React_.createContext)(
void 0
);
var VEVQD5MH_ctx = createStoreContext(
[PopoverContextProvider, CompositeContextProvider],
[PopoverScopedContextProvider, CompositeScopedContextProvider]
);
var useComboboxContext = VEVQD5MH_ctx.useContext;
var useComboboxScopedContext = VEVQD5MH_ctx.useScopedContext;
var useComboboxProviderContext = VEVQD5MH_ctx.useProviderContext;
var ComboboxContextProvider = VEVQD5MH_ctx.ContextProvider;
var ComboboxScopedContextProvider = VEVQD5MH_ctx.ScopedContextProvider;
var ComboboxItemValueContext = (0,external_React_.createContext)(
void 0
);
var ComboboxItemCheckedContext = (0,external_React_.createContext)(false);
;// ./node_modules/@ariakit/core/esm/select/select-store.js
"use client";
// src/select/select-store.ts
function createSelectStore(_a = {}) {
var _b = _a, {
combobox
} = _b, props = _3YLGPPWQ_objRest(_b, [
"combobox"
]);
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(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, props), {
store,
placement: defaultValue(
props.placement,
syncState.placement,
"bottom-start"
)
}));
const initialValue = new String("");
const initialState = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, composite.getState()), popover.getState()), {
value: defaultValue(
props.value,
syncState.value,
props.defaultValue,
initialValue
),
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 !== initialValue) return;
if (!state.items.length) return;
const item = state.items.find(
(item2) => !item2.disabled && item2.value != null
);
if ((item == null ? void 0 : item.value) == null) return;
select.setState("value", item.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 item = state.items.find(
(item2) => !item2.disabled && item2.value === lastValue
);
if (!item) return;
select.setState("activeId", item.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 item = composite.item(activeId);
if (!item || item.disabled || item.value == null) return;
select.setState("value", item.value);
})
);
return _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, 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/S5WQ44SQ.js
"use client";
// src/select/select-store.ts
function useSelectStoreOptions(props) {
const combobox = useComboboxProviderContext();
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, 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] = YV4JVR4I_useStore(createSelectStore, props);
return useSelectStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/KPEX55MY.js
"use client";
// src/select/select-context.tsx
var KPEX55MY_ctx = createStoreContext(
[PopoverContextProvider, CompositeContextProvider],
[PopoverScopedContextProvider, CompositeScopedContextProvider]
);
var useSelectContext = KPEX55MY_ctx.useContext;
var useSelectScopedContext = KPEX55MY_ctx.useScopedContext;
var useSelectProviderContext = KPEX55MY_ctx.useProviderContext;
var SelectContextProvider = KPEX55MY_ctx.ContextProvider;
var SelectScopedContextProvider = KPEX55MY_ctx.ScopedContextProvider;
var SelectItemCheckedContext = (0,external_React_.createContext)(false);
var SelectHeadingContext = (0,external_React_.createContext)(null);
;// ./node_modules/@ariakit/react-core/esm/select/select-label.js
"use client";
// src/select/select-label.tsx
var select_label_TagName = "div";
var useSelectLabel = createHook(
function useSelectLabel2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useSelectProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const id = 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 = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id
}, props), {
ref: useMergeRefs(store.setLabelElement, props.ref),
onClick,
style: _3YLGPPWQ_spreadValues({
cursor: "default"
}, props.style)
});
return removeUndefinedValues(props);
}
);
var SelectLabel = memo2(
forwardRef2(function SelectLabel2(props) {
const htmlProps = useSelectLabel(props);
return LMDWO4NN_createElement(select_label_TagName, htmlProps);
})
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/X5NMLKT6.js
"use client";
// src/button/button.tsx
var X5NMLKT6_TagName = "button";
var useButton = createHook(
function useButton2(props) {
const ref = (0,external_React_.useRef)(null);
const tagName = useTagName(ref, X5NMLKT6_TagName);
const [isNativeButton, setIsNativeButton] = (0,external_React_.useState)(
() => !!tagName && isButton({ tagName, type: props.type })
);
(0,external_React_.useEffect)(() => {
if (!ref.current) return;
setIsNativeButton(isButton(ref.current));
}, []);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
role: !isNativeButton && tagName !== "a" ? "button" : void 0
}, props), {
ref: useMergeRefs(ref, props.ref)
});
props = useCommand(props);
return props;
}
);
var X5NMLKT6_Button = forwardRef2(function Button2(props) {
const htmlProps = useButton(props);
return LMDWO4NN_createElement(X5NMLKT6_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/P4IRICAX.js
"use client";
// src/disclosure/disclosure.tsx
var P4IRICAX_TagName = "button";
var P4IRICAX_symbol = Symbol("disclosure");
var useDisclosure = createHook(
function useDisclosure2(_a) {
var _b = _a, { store, toggleOnClick = true } = _b, props = __objRest(_b, ["store", "toggleOnClick"]);
const context = useDisclosureProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const ref = (0,external_React_.useRef)(null);
const [expanded, setExpanded] = (0,external_React_.useState)(false);
const disclosureElement = store.useState("disclosureElement");
const open = store.useState("open");
(0,external_React_.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, P4IRICAX_symbol, 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 = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues(_3YLGPPWQ_spreadValues({
"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 LMDWO4NN_createElement(P4IRICAX_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/AXB53BZF.js
"use client";
// src/dialog/dialog-disclosure.tsx
var AXB53BZF_TagName = "button";
var useDialogDisclosure = createHook(
function useDialogDisclosure2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useDialogProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const contentElement = store.useState("contentElement");
props = _3YLGPPWQ_spreadValues({
"aria-haspopup": getPopupRole(contentElement, "dialog")
}, props);
props = useDisclosure(_3YLGPPWQ_spreadValues({ store }, props));
return props;
}
);
var DialogDisclosure = forwardRef2(function DialogDisclosure2(props) {
const htmlProps = useDialogDisclosure(props);
return LMDWO4NN_createElement(AXB53BZF_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/OMU7RWRV.js
"use client";
// src/popover/popover-anchor.tsx
var OMU7RWRV_TagName = "div";
var usePopoverAnchor = createHook(
function usePopoverAnchor2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = usePopoverProviderContext();
store = store || context;
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
ref: useMergeRefs(store == null ? void 0 : store.setAnchorElement, props.ref)
});
return props;
}
);
var PopoverAnchor = forwardRef2(function PopoverAnchor2(props) {
const htmlProps = usePopoverAnchor(props);
return LMDWO4NN_createElement(OMU7RWRV_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/QYJ6MIDR.js
"use client";
// src/popover/popover-disclosure.tsx
var QYJ6MIDR_TagName = "button";
var usePopoverDisclosure = createHook(function usePopoverDisclosure2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = usePopoverProviderContext();
store = store || context;
invariant(
store,
false && 0
);
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,external_ReactJSXRuntime_namespaceObject.jsx)(PopoverScopedContextProvider, { value: store, children: element }),
[store]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
onClick
});
props = usePopoverAnchor(_3YLGPPWQ_spreadValues({ store }, props));
props = useDialogDisclosure(_3YLGPPWQ_spreadValues({ store }, props));
return props;
});
var PopoverDisclosure = forwardRef2(function PopoverDisclosure2(props) {
const htmlProps = usePopoverDisclosure(props);
return LMDWO4NN_createElement(QYJ6MIDR_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/DR55NYVS.js
"use client";
// src/popover/popover-disclosure-arrow.tsx
var DR55NYVS_TagName = "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(_a) {
var _b = _a, { store, placement } = _b, props = __objRest(_b, ["store", "placement"]);
const context = usePopoverContext();
store = store || context;
invariant(
store,
false && 0
);
const position = store.useState((state) => placement || state.placement);
const dir = position.split("-")[0];
const points = pointsMap[dir];
const children = (0,external_React_.useMemo)(
() => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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,external_ReactJSXRuntime_namespaceObject.jsx)("polyline", { points })
}
),
[points]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
children,
"aria-hidden": true
}, props), {
style: _3YLGPPWQ_spreadValues({
width: "1em",
height: "1em",
pointerEvents: "none"
}, props.style)
});
return removeUndefinedValues(props);
});
var PopoverDisclosureArrow = forwardRef2(
function PopoverDisclosureArrow2(props) {
const htmlProps = usePopoverDisclosureArrow(props);
return LMDWO4NN_createElement(DR55NYVS_TagName, htmlProps);
}
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/UD53QJDV.js
"use client";
// src/select/select-arrow.tsx
var UD53QJDV_TagName = "span";
var useSelectArrow = createHook(
function useSelectArrow2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useSelectContext();
store = store || context;
props = usePopoverDisclosureArrow(_3YLGPPWQ_spreadValues({ store }, props));
return props;
}
);
var SelectArrow = forwardRef2(function SelectArrow2(props) {
const htmlProps = useSelectArrow(props);
return LMDWO4NN_createElement(UD53QJDV_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/select/select.js
"use client";
// src/select/select.tsx
var select_TagName = "button";
function getSelectedValues(select) {
return Array.from(select.selectedOptions).map((option) => option.value);
}
function nextWithValue(store, next) {
return () => {
const nextId = next();
if (!nextId) return;
let i = 0;
let nextItem = store.item(nextId);
const firstItem = nextItem;
while (nextItem && nextItem.value == null) {
const nextId2 = next(++i);
if (!nextId2) return;
nextItem = store.item(nextId2);
if (nextItem === firstItem) break;
}
return nextItem == null ? void 0 : nextItem.id;
};
}
var useSelect = createHook(function useSelect2(_a) {
var _b = _a, {
store,
name,
form,
required,
showOnKeyDown = true,
moveOnKeyDown = true,
toggleOnPress = true,
toggleOnClick = toggleOnPress
} = _b, props = __objRest(_b, [
"store",
"name",
"form",
"required",
"showOnKeyDown",
"moveOnKeyDown",
"toggleOnPress",
"toggleOnClick"
]);
const context = useSelectProviderContext();
store = store || context;
invariant(
store,
false && 0
);
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 _a2;
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 isGrid = !!((_a2 = items2.find((item) => !item.disabled && item.value != null)) == null ? void 0 : _a2.rowId);
const moveKeyMap = {
ArrowUp: (isGrid || isVertical) && nextWithValue(store, store.up),
ArrowRight: (isGrid || isHorizontal) && nextWithValue(store, store.next),
ArrowDown: (isGrid || isVertical) && nextWithValue(store, store.down),
ArrowLeft: (isGrid || 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,external_ReactJSXRuntime_namespaceObject.jsx)(SelectScopedContextProvider, { value: store, children: element }),
[store]
);
const [autofill, setAutofill] = (0,external_React_.useState)(false);
const nativeSelectChangedRef = (0,external_React_.useRef)(false);
(0,external_React_.useEffect)(() => {
const nativeSelectChanged = nativeSelectChangedRef.current;
nativeSelectChangedRef.current = false;
if (nativeSelectChanged) return;
setAutofill(false);
}, [value]);
const labelId = store.useState((state) => {
var _a2;
return (_a2 = state.labelElement) == null ? void 0 : _a2.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,external_React_.useMemo)(() => {
return [...new Set(items == null ? void 0 : items.map((i) => i.value).filter((v) => v != null))];
}, [items]);
props = useWrapElement(
props,
(element) => {
if (!name) return element;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { children: [
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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,
value,
multiple: multiSelectable,
onFocus: () => {
var _a2;
return (_a2 = store == null ? void 0 : store.getState().selectElement) == null ? void 0 : _a2.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,external_ReactJSXRuntime_namespaceObject.jsx)("option", { value: value2, children: value2 }, value2);
}),
values.map((value2) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("option", { value: value2, children: value2 }, value2))
]
}
),
element
] });
},
[
store,
label,
labelledBy,
name,
form,
required,
value,
multiSelectable,
values
]
);
const children = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, { children: [
value,
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectArrow, {})
] });
const contentElement = store.useState("contentElement");
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
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(_3YLGPPWQ_spreadValues({ store, toggleOnClick }, props));
props = useCompositeTypeahead(_3YLGPPWQ_spreadValues({ store }, props));
return props;
});
var select_Select = forwardRef2(function Select2(props) {
const htmlProps = useSelect(props);
return LMDWO4NN_createElement(select_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/XRBJGF7I.js
"use client";
// src/select/select-list.tsx
var XRBJGF7I_TagName = "div";
var SelectListContext = (0,external_React_.createContext)(null);
var useSelectList = createHook(
function useSelectList2(_a) {
var _b = _a, {
store,
resetOnEscape = true,
hideOnEnter = true,
focusOnMove = true,
composite,
alwaysVisible
} = _b, props = __objRest(_b, [
"store",
"resetOnEscape",
"hideOnEnter",
"focusOnMove",
"composite",
"alwaysVisible"
]);
const context = useSelectContext();
store = store || context;
invariant(
store,
false && 0
);
const id = useId(props.id);
const value = store.useState("value");
const multiSelectable = Array.isArray(value);
const [defaultValue, setDefaultValue] = (0,external_React_.useState)(value);
const mounted = store.useState("mounted");
(0,external_React_.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(defaultValue);
}
if (event.key === " " || event.key === "Enter") {
if (isSelfTarget(event) && hideOnEnterProp(event)) {
event.preventDefault();
store == null ? void 0 : store.hide();
}
}
});
const headingContext = (0,external_React_.useContext)(SelectHeadingContext);
const headingState = (0,external_React_.useState)();
const [headingId, setHeadingId] = headingContext || headingState;
const headingContextValue = (0,external_React_.useMemo)(
() => [headingId, setHeadingId],
[headingId]
);
const [childStore, setChildStore] = (0,external_React_.useState)(null);
const setStore = (0,external_React_.useContext)(SelectListContext);
(0,external_React_.useEffect)(() => {
if (!setStore) return;
setStore(store);
return () => setStore(null);
}, [setStore, store]);
props = useWrapElement(
props,
(element2) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectScopedContextProvider, { value: store, children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectListContext.Provider, { value: setChildStore, children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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 style = hidden ? _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props.style), { display: "none" }) : props.style;
if (composite) {
props = _3YLGPPWQ_spreadValues({
role: "listbox",
"aria-multiselectable": ariaMultiSelectable
}, props);
}
const labelId = store.useState(
(state) => {
var _a2;
return headingId || ((_a2 = state.labelElement) == null ? void 0 : _a2.id);
}
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
"aria-labelledby": labelId,
hidden
}, props), {
ref: useMergeRefs(setElement, props.ref),
style,
onKeyDown
});
props = useComposite(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({ store }, props), { composite }));
props = useCompositeTypeahead(_3YLGPPWQ_spreadValues({ store, typeahead: !hasCombobox }, props));
return props;
}
);
var SelectList = forwardRef2(function SelectList2(props) {
const htmlProps = useSelectList(props);
return LMDWO4NN_createElement(XRBJGF7I_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/select/select-popover.js
"use client";
// src/select/select-popover.tsx
var select_popover_TagName = "div";
var useSelectPopover = createHook(
function useSelectPopover2(_a) {
var _b = _a, { store, alwaysVisible } = _b, props = __objRest(_b, ["store", "alwaysVisible"]);
const context = useSelectProviderContext();
store = store || context;
props = useSelectList(_3YLGPPWQ_spreadValues({ store, alwaysVisible }, props));
props = usePopover(_3YLGPPWQ_spreadValues({ store, alwaysVisible }, props));
return props;
}
);
var SelectPopover = createDialogComponent(
forwardRef2(function SelectPopover2(props) {
const htmlProps = useSelectPopover(props);
return LMDWO4NN_createElement(select_popover_TagName, htmlProps);
}),
useSelectProviderContext
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/YF2ICFG4.js
"use client";
// src/select/select-item.tsx
var YF2ICFG4_TagName = "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(_a) {
var _b = _a, {
store,
value,
getItem: getItemProp,
hideOnClick,
setValueOnClick = value != null,
preventScrollOnKeyDown = true,
focusOnHover = true
} = _b, props = __objRest(_b, [
"store",
"value",
"getItem",
"hideOnClick",
"setValueOnClick",
"preventScrollOnKeyDown",
"focusOnHover"
]);
var _a2;
const context = useSelectScopedContext();
store = store || context;
invariant(
store,
false && 0
);
const id = 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 !== id && (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,external_React_.useCallback)(
(item) => {
const nextItem = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, item), {
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((v) => v !== value);
}
return [...prevValue, value];
});
}
if (hideOnClickProp(event)) {
store == null ? void 0 : store.hide();
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectItemCheckedContext.Provider, { value: selected != null ? selected : false, children: element }),
[selected]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
role: getPopupItemRole(listElement),
"aria-selected": selected,
children: value
}, props), {
autoFocus: (_a2 = props.autoFocus) != null ? _a2 : autoFocus,
onClick
});
props = useCompositeItem(_3YLGPPWQ_spreadValues({
store,
getItem,
preventScrollOnKeyDown
}, props));
const focusOnHoverProp = useBooleanEvent(focusOnHover);
props = useCompositeHover(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
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 LMDWO4NN_createElement(YF2ICFG4_TagName, htmlProps);
})
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/EYKMH5G5.js
"use client";
// src/checkbox/checkbox-checked-context.tsx
var CheckboxCheckedContext = (0,external_React_.createContext)(false);
;// ./node_modules/@ariakit/react-core/esm/__chunks/5JCRYSSV.js
"use client";
// src/checkbox/checkbox-check.tsx
var _5JCRYSSV_TagName = "span";
var checkmark = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.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,external_ReactJSXRuntime_namespaceObject.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(_a) {
var _b = _a, { store, checked } = _b, props = __objRest(_b, ["store", "checked"]);
const context = (0,external_React_.useContext)(CheckboxCheckedContext);
checked = checked != null ? checked : context;
const children = getChildren({ checked, children: props.children });
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
"aria-hidden": true
}, props), {
children,
style: _3YLGPPWQ_spreadValues({
width: "1em",
height: "1em",
pointerEvents: "none"
}, props.style)
});
return removeUndefinedValues(props);
}
);
var CheckboxCheck = forwardRef2(function CheckboxCheck2(props) {
const htmlProps = useCheckboxCheck(props);
return LMDWO4NN_createElement(_5JCRYSSV_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/select/select-item-check.js
"use client";
// src/select/select-item-check.tsx
var select_item_check_TagName = "span";
var useSelectItemCheck = createHook(
function useSelectItemCheck2(_a) {
var _b = _a, { store, checked } = _b, props = __objRest(_b, ["store", "checked"]);
const context = (0,external_React_.useContext)(SelectItemCheckedContext);
checked = checked != null ? checked : context;
props = useCheckboxCheck(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { checked }));
return props;
}
);
var SelectItemCheck = forwardRef2(function SelectItemCheck2(props) {
const htmlProps = useSelectItemCheck(props);
return LMDWO4NN_createElement(select_item_check_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/custom-select-control-v2/styles.js
function custom_select_control_v2_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const ANIMATION_PARAMS = {
SLIDE_AMOUNT: "2px",
DURATION: "400ms",
EASING: "cubic-bezier( 0.16, 1, 0.3, 1 )"
};
const INLINE_PADDING = {
compact: config_values_default.controlPaddingXSmall,
small: config_values_default.controlPaddingXSmall,
default: config_values_default.controlPaddingX
};
const getSelectSize = (size, heightProperty) => {
const sizes = {
compact: {
[heightProperty]: 32,
paddingInlineStart: INLINE_PADDING.compact,
paddingInlineEnd: INLINE_PADDING.compact + chevronIconSize
},
default: {
[heightProperty]: 40,
paddingInlineStart: INLINE_PADDING.default,
paddingInlineEnd: INLINE_PADDING.default + chevronIconSize
},
small: {
[heightProperty]: 24,
paddingInlineStart: INLINE_PADDING.small,
paddingInlineEnd: INLINE_PADDING.small + chevronIconSize
}
};
return sizes[size] || sizes.default;
};
const getSelectItemSize = (size) => {
const checkmarkCorrection = 6;
const sizes = {
compact: {
paddingInlineStart: INLINE_PADDING.compact,
paddingInlineEnd: INLINE_PADDING.compact - checkmarkCorrection
},
default: {
paddingInlineStart: INLINE_PADDING.default,
paddingInlineEnd: INLINE_PADDING.default - checkmarkCorrection
},
small: {
paddingInlineStart: INLINE_PADDING.small,
paddingInlineEnd: INLINE_PADDING.small - checkmarkCorrection
}
};
return sizes[size] || sizes.default;
};
const styles_Select = /* @__PURE__ */ emotion_styled_base_browser_esm(select_Select, true ? {
// Do not forward `hasCustomRenderProp` to the underlying Ariakit.Select component
shouldForwardProp: (prop) => prop !== "hasCustomRenderProp",
target: "e1p3eej77"
} : 0)(({
size,
hasCustomRenderProp
}) => /* @__PURE__ */ emotion_react_browser_esm_css("display:block;background-color:", COLORS.theme.background, ";border:none;color:", COLORS.theme.foreground, ";cursor:pointer;font-family:inherit;text-align:start;user-select:none;width:100%;&[data-focus-visible]{outline:none;}", getSelectSize(size, hasCustomRenderProp ? "minHeight" : "height"), " ", !hasCustomRenderProp && truncateStyles, " ", fontSizeStyles({
inputSize: size
}), ";" + ( true ? "" : 0), true ? "" : 0), true ? "" : 0);
const slideDownAndFade = emotion_react_browser_esm_keyframes({
"0%": {
opacity: 0,
transform: `translateY(-${ANIMATION_PARAMS.SLIDE_AMOUNT})`
},
"100%": {
opacity: 1,
transform: "translateY(0)"
}
});
const styles_SelectPopover = /* @__PURE__ */ emotion_styled_base_browser_esm(SelectPopover, true ? {
target: "e1p3eej76"
} : 0)("display:flex;flex-direction:column;background-color:", COLORS.theme.background, ";border-radius:", config_values_default.radiusSmall, ";border:1px solid ", COLORS.theme.foreground, ";box-shadow:", config_values_default.elevationMedium, ";z-index:1000000;max-height:min( var( --popover-available-height, 400px ), 400px );overflow:auto;overscroll-behavior:contain;min-width:min-content;&[data-open]{@media not ( prefers-reduced-motion ){animation-duration:", ANIMATION_PARAMS.DURATION, ";animation-timing-function:", ANIMATION_PARAMS.EASING, ";animation-name:", slideDownAndFade, ";will-change:transform,opacity;}}&[data-focus-visible]{outline:none;}" + ( true ? "" : 0));
const styles_SelectItem = /* @__PURE__ */ emotion_styled_base_browser_esm(SelectItem, true ? {
target: "e1p3eej75"
} : 0)(({
size
}) => /* @__PURE__ */ emotion_react_browser_esm_css("cursor:default;display:flex;align-items:center;justify-content:space-between;font-size:", config_values_default.fontSize, ";line-height:28px;padding-block:", space(2), ";scroll-margin:", space(1), ";user-select:none;&[aria-disabled='true']{cursor:not-allowed;}&[data-active-item]{background-color:", COLORS.theme.gray[300], ";}", getSelectItemSize(size), ";" + ( true ? "" : 0), true ? "" : 0), true ? "" : 0);
const truncateStyles = true ? {
name: "1h52dri",
styles: "overflow:hidden;text-overflow:ellipsis;white-space:nowrap"
} : 0;
const SelectedExperimentalHintWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1p3eej74"
} : 0)(truncateStyles, ";" + ( true ? "" : 0));
const SelectedExperimentalHintItem = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1p3eej73"
} : 0)("color:", COLORS.theme.gray[600], ";margin-inline-start:", space(2), ";" + ( true ? "" : 0));
const WithHintItemWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1p3eej72"
} : 0)("display:flex;justify-content:space-between;align-items:center;flex-wrap:wrap;flex:1;column-gap:", space(4), ";" + ( true ? "" : 0));
const WithHintItemHint = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1p3eej71"
} : 0)("color:", COLORS.theme.gray[600], ";text-align:initial;line-height:", config_values_default.fontLineHeightBase, ";padding-inline-end:", space(1), ";margin-block:", space(1), ";" + ( true ? "" : 0));
const SelectedItemCheck = /* @__PURE__ */ emotion_styled_base_browser_esm(SelectItemCheck, true ? {
target: "e1p3eej70"
} : 0)("display:flex;align-items:center;margin-inline-start:", space(2), ";fill:currentColor;align-self:start;margin-block-start:2px;font-size:0;", WithHintItemWrapper, "~&,&:not(:empty){font-size:24px;}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/custom-select-control-v2/custom-select.js
const CustomSelectContext = (0,external_wp_element_namespaceObject.createContext)(void 0);
CustomSelectContext.displayName = "CustomSelectContext";
function defaultRenderSelectedValue(value) {
const isValueEmpty = Array.isArray(value) ? value.length === 0 : value === void 0 || value === null;
if (isValueEmpty) {
return (0,external_wp_i18n_namespaceObject.__)("Select an item");
}
if (Array.isArray(value)) {
return value.length === 1 ? value[0] : (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %d: number of items selected (it will always be 2 or more items)
(0,external_wp_i18n_namespaceObject._n)("%d item selected", "%d items selected", value.length),
value.length
);
}
return value;
}
const CustomSelectButton = ({
renderSelectedValue,
size = "default",
store,
...restProps
}) => {
const {
value: currentValue
} = useStoreState(store);
const computedRenderSelectedValue = (0,external_wp_element_namespaceObject.useMemo)(() => renderSelectedValue !== null && renderSelectedValue !== void 0 ? renderSelectedValue : defaultRenderSelectedValue, [renderSelectedValue]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_Select, {
...restProps,
size,
hasCustomRenderProp: !!renderSelectedValue,
store,
children: computedRenderSelectedValue(currentValue)
});
};
function _CustomSelect(props) {
const {
children,
hideLabelFromVision = false,
label,
size,
store,
className,
isLegacy = false,
...restProps
} = props;
const onSelectPopoverKeyDown = (0,external_wp_element_namespaceObject.useCallback)((e) => {
if (isLegacy) {
e.stopPropagation();
}
}, [isLegacy]);
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
store,
size
}), [store, size]);
return (
// Where should `restProps` be forwarded to?
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectLabel, {
store,
render: hideLabelFromVision ? (
// @ts-expect-error `children` are passed via the render prop
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {})
) : (
// @ts-expect-error `children` are passed via the render prop
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default.VisualLabel, {
as: "div"
})
),
children: label
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(input_base_default, {
__next40pxDefaultSize: true,
size,
suffix: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(chevron_down_chevron_down_default, {}),
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomSelectButton, {
...restProps,
size,
store,
showOnKeyDown: !isLegacy
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_SelectPopover, {
gutter: 12,
store,
sameWidth: true,
slide: false,
onKeyDown: onSelectPopoverKeyDown,
flip: !isLegacy,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomSelectContext.Provider, {
value: contextValue,
children
})
})]
})]
})
);
}
var custom_select_default = _CustomSelect;
;// ./node_modules/@wordpress/components/build-module/custom-select-control-v2/item.js
function CustomSelectItem({
children,
...props
}) {
var _customSelectContext$;
const customSelectContext = (0,external_wp_element_namespaceObject.useContext)(CustomSelectContext);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(styles_SelectItem, {
store: customSelectContext?.store,
size: (_customSelectContext$ = customSelectContext?.size) !== null && _customSelectContext$ !== void 0 ? _customSelectContext$ : "default",
...props,
children: [children !== null && children !== void 0 ? children : props.value, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectedItemCheck, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: check_default
})
})]
});
}
CustomSelectItem.displayName = "CustomSelectControlV2.Item";
var item_default = CustomSelectItem;
;// ./node_modules/@wordpress/components/build-module/custom-select-control/index.js
function custom_select_control_useDeprecatedProps({
__experimentalShowSelectedHint,
...otherProps
}) {
return {
showSelectedHint: __experimentalShowSelectedHint,
...otherProps
};
}
function applyOptionDeprecations({
__experimentalHint,
...rest
}) {
return {
hint: __experimentalHint,
...rest
};
}
function getDescribedBy(currentValue, describedBy) {
if (describedBy) {
return describedBy;
}
return (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("Currently selected: %s"), currentValue);
}
function CustomSelectControl(props) {
const {
__next40pxDefaultSize = false,
__shouldNotWarnDeprecated36pxSize,
describedBy,
options,
onChange,
size = "default",
value,
className: classNameProp,
showSelectedHint = false,
...restProps
} = custom_select_control_useDeprecatedProps(props);
maybeWarnDeprecated36pxSize({
componentName: "CustomSelectControl",
__next40pxDefaultSize,
size,
__shouldNotWarnDeprecated36pxSize
});
const descriptionId = (0,external_wp_compose_namespaceObject.useInstanceId)(CustomSelectControl, "custom-select-control__description");
const store = useSelectStore({
async setValue(nextValue) {
const nextOption = options.find((item) => item.name === nextValue);
if (!onChange || !nextOption) {
return;
}
await Promise.resolve();
const state = store.getState();
const changeObject = {
highlightedIndex: state.renderedItems.findIndex((item) => item.value === nextValue),
inputValue: "",
isOpen: state.open,
selectedItem: nextOption,
type: ""
};
onChange(changeObject);
},
value: value?.name,
// Setting the first option as a default value when no value is provided
// is already done natively by the underlying Ariakit component,
// but doing this explicitly avoids the `onChange` callback from firing
// on initial render, thus making this implementation closer to the v1.
defaultValue: options[0]?.name
});
const children = options.map(applyOptionDeprecations).map(({
name,
key,
hint,
style,
className
}) => {
const withHint = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(WithHintItemWrapper, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
children: name
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WithHintItemHint, {
// Keeping the classname for legacy reasons
className: "components-custom-select-control__item-hint",
children: hint
})]
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(item_default, {
value: name,
children: hint ? withHint : name,
style,
className: dist_clsx(
className,
// Keeping the classnames for legacy reasons
"components-custom-select-control__item",
{
"has-hint": hint
}
)
}, key);
});
const currentValue = useStoreState(store, "value");
const renderSelectedValueHint = () => {
const selectedOptionHint = options?.map(applyOptionDeprecations)?.find(({
name
}) => currentValue === name)?.hint;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(SelectedExperimentalHintWrapper, {
children: [currentValue, selectedOptionHint && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectedExperimentalHintItem, {
// Keeping the classname for legacy reasons
className: "components-custom-select-control__hint",
children: selectedOptionHint
})]
});
};
const translatedSize = (() => {
if (__next40pxDefaultSize && size === "default" || size === "__unstable-large") {
return "default";
}
if (!__next40pxDefaultSize && size === "default") {
return "compact";
}
return size;
})();
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(custom_select_default, {
"aria-describedby": descriptionId,
renderSelectedValue: showSelectedHint ? renderSelectedValueHint : void 0,
size: translatedSize,
store,
className: dist_clsx(
// Keeping the classname for legacy reasons
"components-custom-select-control",
classNameProp
),
isLegacy: true,
...restProps,
children
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
id: descriptionId,
children: getDescribedBy(currentValue, describedBy)
})
})]
});
}
var custom_select_control_default = CustomSelectControl;
;// ./node_modules/date-fns/toDate.mjs
/**
* @name toDate
* @category Common Helpers
* @summary Convert the given argument to an instance of Date.
*
* @description
* Convert the given argument to an instance of Date.
*
* If the argument is an instance of Date, the function returns its clone.
*
* If the argument is a number, it is treated as a timestamp.
*
* If the argument is none of the above, the function returns Invalid Date.
*
* **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param argument - The value to convert
*
* @returns The parsed date in the local time zone
*
* @example
* // Clone the date:
* const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
* //=> Tue Feb 11 2014 11:30:30
*
* @example
* // Convert the timestamp to date:
* const result = toDate(1392098430000)
* //=> Tue Feb 11 2014 11:30:30
*/
function toDate(argument) {
const argStr = Object.prototype.toString.call(argument);
// Clone the date
if (
argument instanceof Date ||
(typeof argument === "object" && argStr === "[object Date]")
) {
// Prevent the date to lose the milliseconds when passed to new Date() in IE10
return new argument.constructor(+argument);
} else if (
typeof argument === "number" ||
argStr === "[object Number]" ||
typeof argument === "string" ||
argStr === "[object String]"
) {
// TODO: Can we get rid of as?
return new Date(argument);
} else {
// TODO: Can we get rid of as?
return new Date(NaN);
}
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_toDate = ((/* unused pure expression or super */ null && (toDate)));
;// ./node_modules/date-fns/startOfDay.mjs
/**
* @name startOfDay
* @category Day Helpers
* @summary Return the start of a day for the given date.
*
* @description
* Return the start of a day for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
*
* @returns The start of a day
*
* @example
* // The start of a day for 2 September 2014 11:55:00:
* const result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
* //=> Tue Sep 02 2014 00:00:00
*/
function startOfDay(date) {
const _date = toDate(date);
_date.setHours(0, 0, 0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfDay = ((/* unused pure expression or super */ null && (startOfDay)));
;// ./node_modules/date-fns/constructFrom.mjs
/**
* @name constructFrom
* @category Generic Helpers
* @summary Constructs a date using the reference date and the value
*
* @description
* The function constructs a new date using the constructor from the reference
* date and the given value. It helps to build generic functions that accept
* date extensions.
*
* It defaults to `Date` if the passed reference date is a number or a string.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The reference date to take constructor from
* @param value - The value to create the date
*
* @returns Date initialized using the given date and value
*
* @example
* import { constructFrom } from 'date-fns'
*
* // A function that clones a date preserving the original type
* function cloneDate<DateType extends Date(date: DateType): DateType {
* return constructFrom(
* date, // Use contrustor from the given date
* date.getTime() // Use the date value to create a new date
* )
* }
*/
function constructFrom(date, value) {
if (date instanceof Date) {
return new date.constructor(value);
} else {
return new Date(value);
}
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_constructFrom = ((/* unused pure expression or super */ null && (constructFrom)));
;// ./node_modules/date-fns/addMonths.mjs
/**
* @name addMonths
* @category Month Helpers
* @summary Add the specified number of months to the given date.
*
* @description
* Add the specified number of months to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param amount - The amount of months to be added.
*
* @returns The new date with the months added
*
* @example
* // Add 5 months to 1 September 2014:
* const result = addMonths(new Date(2014, 8, 1), 5)
* //=> Sun Feb 01 2015 00:00:00
*
* // Add one month to 30 January 2023:
* const result = addMonths(new Date(2023, 0, 30), 1)
* //=> Tue Feb 28 2023 00:00:00
*/
function addMonths(date, amount) {
const _date = toDate(date);
if (isNaN(amount)) return constructFrom(date, NaN);
if (!amount) {
// If 0 months, no-op to avoid changing times in the hour before end of DST
return _date;
}
const dayOfMonth = _date.getDate();
// The JS Date object supports date math by accepting out-of-bounds values for
// month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
// new Date(2020, 13, 1) returns 1 Feb 2021. This is *almost* the behavior we
// want except that dates will wrap around the end of a month, meaning that
// new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
// we'll default to the end of the desired month by adding 1 to the desired
// month and using a date of 0 to back up one day to the end of the desired
// month.
const endOfDesiredMonth = constructFrom(date, _date.getTime());
endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
const daysInMonth = endOfDesiredMonth.getDate();
if (dayOfMonth >= daysInMonth) {
// If we're already at the end of the month, then this is the correct date
// and we're done.
return endOfDesiredMonth;
} else {
// Otherwise, we now know that setting the original day-of-month value won't
// cause an overflow, so set the desired day-of-month. Note that we can't
// just set the date of `endOfDesiredMonth` because that object may have had
// its time changed in the unusual case where where a DST transition was on
// the last day of the month and its local time was in the hour skipped or
// repeated next to a DST transition. So we use `date` instead which is
// guaranteed to still have the original time.
_date.setFullYear(
endOfDesiredMonth.getFullYear(),
endOfDesiredMonth.getMonth(),
dayOfMonth,
);
return _date;
}
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_addMonths = ((/* unused pure expression or super */ null && (addMonths)));
;// ./node_modules/date-fns/subMonths.mjs
/**
* @name subMonths
* @category Month Helpers
* @summary Subtract the specified number of months from the given date.
*
* @description
* Subtract the specified number of months from the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param amount - The amount of months to be subtracted.
*
* @returns The new date with the months subtracted
*
* @example
* // Subtract 5 months from 1 February 2015:
* const result = subMonths(new Date(2015, 1, 1), 5)
* //=> Mon Sep 01 2014 00:00:00
*/
function subMonths(date, amount) {
return addMonths(date, -amount);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_subMonths = ((/* unused pure expression or super */ null && (subMonths)));
;// ./node_modules/date-fns/locale/en-US/_lib/formatDistance.mjs
const formatDistanceLocale = {
lessThanXSeconds: {
one: "less than a second",
other: "less than {{count}} seconds",
},
xSeconds: {
one: "1 second",
other: "{{count}} seconds",
},
halfAMinute: "half a minute",
lessThanXMinutes: {
one: "less than a minute",
other: "less than {{count}} minutes",
},
xMinutes: {
one: "1 minute",
other: "{{count}} minutes",
},
aboutXHours: {
one: "about 1 hour",
other: "about {{count}} hours",
},
xHours: {
one: "1 hour",
other: "{{count}} hours",
},
xDays: {
one: "1 day",
other: "{{count}} days",
},
aboutXWeeks: {
one: "about 1 week",
other: "about {{count}} weeks",
},
xWeeks: {
one: "1 week",
other: "{{count}} weeks",
},
aboutXMonths: {
one: "about 1 month",
other: "about {{count}} months",
},
xMonths: {
one: "1 month",
other: "{{count}} months",
},
aboutXYears: {
one: "about 1 year",
other: "about {{count}} years",
},
xYears: {
one: "1 year",
other: "{{count}} years",
},
overXYears: {
one: "over 1 year",
other: "over {{count}} years",
},
almostXYears: {
one: "almost 1 year",
other: "almost {{count}} years",
},
};
const formatDistance = (token, count, options) => {
let result;
const tokenValue = formatDistanceLocale[token];
if (typeof tokenValue === "string") {
result = tokenValue;
} else if (count === 1) {
result = tokenValue.one;
} else {
result = tokenValue.other.replace("{{count}}", count.toString());
}
if (options?.addSuffix) {
if (options.comparison && options.comparison > 0) {
return "in " + result;
} else {
return result + " ago";
}
}
return result;
};
;// ./node_modules/date-fns/locale/_lib/buildFormatLongFn.mjs
function buildFormatLongFn(args) {
return (options = {}) => {
// TODO: Remove String()
const width = options.width ? String(options.width) : args.defaultWidth;
const format = args.formats[width] || args.formats[args.defaultWidth];
return format;
};
}
;// ./node_modules/date-fns/locale/en-US/_lib/formatLong.mjs
const dateFormats = {
full: "EEEE, MMMM do, y",
long: "MMMM do, y",
medium: "MMM d, y",
short: "MM/dd/yyyy",
};
const timeFormats = {
full: "h:mm:ss a zzzz",
long: "h:mm:ss a z",
medium: "h:mm:ss a",
short: "h:mm a",
};
const dateTimeFormats = {
full: "{{date}} 'at' {{time}}",
long: "{{date}} 'at' {{time}}",
medium: "{{date}}, {{time}}",
short: "{{date}}, {{time}}",
};
const formatLong = {
date: buildFormatLongFn({
formats: dateFormats,
defaultWidth: "full",
}),
time: buildFormatLongFn({
formats: timeFormats,
defaultWidth: "full",
}),
dateTime: buildFormatLongFn({
formats: dateTimeFormats,
defaultWidth: "full",
}),
};
;// ./node_modules/date-fns/locale/en-US/_lib/formatRelative.mjs
const formatRelativeLocale = {
lastWeek: "'last' eeee 'at' p",
yesterday: "'yesterday at' p",
today: "'today at' p",
tomorrow: "'tomorrow at' p",
nextWeek: "eeee 'at' p",
other: "P",
};
const formatRelative = (token, _date, _baseDate, _options) =>
formatRelativeLocale[token];
;// ./node_modules/date-fns/locale/_lib/buildLocalizeFn.mjs
/* eslint-disable no-unused-vars */
/**
* The localize function argument callback which allows to convert raw value to
* the actual type.
*
* @param value - The value to convert
*
* @returns The converted value
*/
/**
* The map of localized values for each width.
*/
/**
* The index type of the locale unit value. It types conversion of units of
* values that don't start at 0 (i.e. quarters).
*/
/**
* Converts the unit value to the tuple of values.
*/
/**
* The tuple of localized era values. The first element represents BC,
* the second element represents AD.
*/
/**
* The tuple of localized quarter values. The first element represents Q1.
*/
/**
* The tuple of localized day values. The first element represents Sunday.
*/
/**
* The tuple of localized month values. The first element represents January.
*/
function buildLocalizeFn(args) {
return (value, options) => {
const context = options?.context ? String(options.context) : "standalone";
let valuesArray;
if (context === "formatting" && args.formattingValues) {
const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
const width = options?.width ? String(options.width) : defaultWidth;
valuesArray =
args.formattingValues[width] || args.formattingValues[defaultWidth];
} else {
const defaultWidth = args.defaultWidth;
const width = options?.width ? String(options.width) : args.defaultWidth;
valuesArray = args.values[width] || args.values[defaultWidth];
}
const index = args.argumentCallback ? args.argumentCallback(value) : value;
// @ts-expect-error - For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
return valuesArray[index];
};
}
;// ./node_modules/date-fns/locale/en-US/_lib/localize.mjs
const eraValues = {
narrow: ["B", "A"],
abbreviated: ["BC", "AD"],
wide: ["Before Christ", "Anno Domini"],
};
const quarterValues = {
narrow: ["1", "2", "3", "4"],
abbreviated: ["Q1", "Q2", "Q3", "Q4"],
wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"],
};
// Note: in English, the names of days of the week and months are capitalized.
// If you are making a new locale based on this one, check if the same is true for the language you're working on.
// Generally, formatted dates should look like they are in the middle of a sentence,
// e.g. in Spanish language the weekdays and months should be in the lowercase.
const monthValues = {
narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
abbreviated: [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec",
],
wide: [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
],
};
const dayValues = {
narrow: ["S", "M", "T", "W", "T", "F", "S"],
short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
wide: [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
],
};
const dayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
};
const formattingDayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
};
const ordinalNumber = (dirtyNumber, _options) => {
const number = Number(dirtyNumber);
// If ordinal numbers depend on context, for example,
// if they are different for different grammatical genders,
// use `options.unit`.
//
// `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
// 'day', 'hour', 'minute', 'second'.
const rem100 = number % 100;
if (rem100 > 20 || rem100 < 10) {
switch (rem100 % 10) {
case 1:
return number + "st";
case 2:
return number + "nd";
case 3:
return number + "rd";
}
}
return number + "th";
};
const localize = {
ordinalNumber,
era: buildLocalizeFn({
values: eraValues,
defaultWidth: "wide",
}),
quarter: buildLocalizeFn({
values: quarterValues,
defaultWidth: "wide",
argumentCallback: (quarter) => quarter - 1,
}),
month: buildLocalizeFn({
values: monthValues,
defaultWidth: "wide",
}),
day: buildLocalizeFn({
values: dayValues,
defaultWidth: "wide",
}),
dayPeriod: buildLocalizeFn({
values: dayPeriodValues,
defaultWidth: "wide",
formattingValues: formattingDayPeriodValues,
defaultFormattingWidth: "wide",
}),
};
;// ./node_modules/date-fns/locale/_lib/buildMatchFn.mjs
function buildMatchFn(args) {
return (string, options = {}) => {
const width = options.width;
const matchPattern =
(width && args.matchPatterns[width]) ||
args.matchPatterns[args.defaultMatchWidth];
const matchResult = string.match(matchPattern);
if (!matchResult) {
return null;
}
const matchedString = matchResult[0];
const parsePatterns =
(width && args.parsePatterns[width]) ||
args.parsePatterns[args.defaultParseWidth];
const key = Array.isArray(parsePatterns)
? findIndex(parsePatterns, (pattern) => pattern.test(matchedString))
: // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
findKey(parsePatterns, (pattern) => pattern.test(matchedString));
let value;
value = args.valueCallback ? args.valueCallback(key) : key;
value = options.valueCallback
? // eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
options.valueCallback(value)
: value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
function findKey(object, predicate) {
for (const key in object) {
if (
Object.prototype.hasOwnProperty.call(object, key) &&
predicate(object[key])
) {
return key;
}
}
return undefined;
}
function findIndex(array, predicate) {
for (let key = 0; key < array.length; key++) {
if (predicate(array[key])) {
return key;
}
}
return undefined;
}
;// ./node_modules/date-fns/locale/_lib/buildMatchPatternFn.mjs
function buildMatchPatternFn(args) {
return (string, options = {}) => {
const matchResult = string.match(args.matchPattern);
if (!matchResult) return null;
const matchedString = matchResult[0];
const parseResult = string.match(args.parsePattern);
if (!parseResult) return null;
let value = args.valueCallback
? args.valueCallback(parseResult[0])
: parseResult[0];
// eslint-disable-next-line @typescript-eslint/no-explicit-any -- I challange you to fix the type
value = options.valueCallback ? options.valueCallback(value) : value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
;// ./node_modules/date-fns/locale/en-US/_lib/match.mjs
const matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
const parseOrdinalNumberPattern = /\d+/i;
const matchEraPatterns = {
narrow: /^(b|a)/i,
abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
wide: /^(before christ|before common era|anno domini|common era)/i,
};
const parseEraPatterns = {
any: [/^b/i, /^(a|c)/i],
};
const matchQuarterPatterns = {
narrow: /^[1234]/i,
abbreviated: /^q[1234]/i,
wide: /^[1234](th|st|nd|rd)? quarter/i,
};
const parseQuarterPatterns = {
any: [/1/i, /2/i, /3/i, /4/i],
};
const matchMonthPatterns = {
narrow: /^[jfmasond]/i,
abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i,
};
const parseMonthPatterns = {
narrow: [
/^j/i,
/^f/i,
/^m/i,
/^a/i,
/^m/i,
/^j/i,
/^j/i,
/^a/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i,
],
any: [
/^ja/i,
/^f/i,
/^mar/i,
/^ap/i,
/^may/i,
/^jun/i,
/^jul/i,
/^au/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i,
],
};
const matchDayPatterns = {
narrow: /^[smtwf]/i,
short: /^(su|mo|tu|we|th|fr|sa)/i,
abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i,
};
const parseDayPatterns = {
narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i],
};
const matchDayPeriodPatterns = {
narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i,
};
const parseDayPeriodPatterns = {
any: {
am: /^a/i,
pm: /^p/i,
midnight: /^mi/i,
noon: /^no/i,
morning: /morning/i,
afternoon: /afternoon/i,
evening: /evening/i,
night: /night/i,
},
};
const match_match = {
ordinalNumber: buildMatchPatternFn({
matchPattern: matchOrdinalNumberPattern,
parsePattern: parseOrdinalNumberPattern,
valueCallback: (value) => parseInt(value, 10),
}),
era: buildMatchFn({
matchPatterns: matchEraPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseEraPatterns,
defaultParseWidth: "any",
}),
quarter: buildMatchFn({
matchPatterns: matchQuarterPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseQuarterPatterns,
defaultParseWidth: "any",
valueCallback: (index) => index + 1,
}),
month: buildMatchFn({
matchPatterns: matchMonthPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseMonthPatterns,
defaultParseWidth: "any",
}),
day: buildMatchFn({
matchPatterns: matchDayPatterns,
defaultMatchWidth: "wide",
parsePatterns: parseDayPatterns,
defaultParseWidth: "any",
}),
dayPeriod: buildMatchFn({
matchPatterns: matchDayPeriodPatterns,
defaultMatchWidth: "any",
parsePatterns: parseDayPeriodPatterns,
defaultParseWidth: "any",
}),
};
;// ./node_modules/date-fns/locale/en-US.mjs
/**
* @category Locales
* @summary English locale (United States).
* @language English
* @iso-639-2 eng
* @author Sasha Koss [@kossnocorp](https://github.com/kossnocorp)
* @author Lesha Koss [@leshakoss](https://github.com/leshakoss)
*/
const enUS = {
code: "en-US",
formatDistance: formatDistance,
formatLong: formatLong,
formatRelative: formatRelative,
localize: localize,
match: match_match,
options: {
weekStartsOn: 0 /* Sunday */,
firstWeekContainsDate: 1,
},
};
// Fallback for modularized imports:
/* harmony default export */ const en_US = ((/* unused pure expression or super */ null && (enUS)));
;// ./node_modules/date-fns/_lib/defaultOptions.mjs
let defaultOptions_defaultOptions = {};
function getDefaultOptions() {
return defaultOptions_defaultOptions;
}
function setDefaultOptions(newOptions) {
defaultOptions_defaultOptions = newOptions;
}
;// ./node_modules/date-fns/constants.mjs
/**
* @module constants
* @summary Useful constants
* @description
* Collection of useful date constants.
*
* The constants could be imported from `date-fns/constants`:
*
* ```ts
* import { maxTime, minTime } from "./constants/date-fns/constants";
*
* function isAllowedTime(time) {
* return time <= maxTime && time >= minTime;
* }
* ```
*/
/**
* @constant
* @name daysInWeek
* @summary Days in 1 week.
*/
const daysInWeek = 7;
/**
* @constant
* @name daysInYear
* @summary Days in 1 year.
*
* @description
* How many days in a year.
*
* One years equals 365.2425 days according to the formula:
*
* > Leap year occures every 4 years, except for years that are divisable by 100 and not divisable by 400.
* > 1 mean year = (365+1/4-1/100+1/400) days = 365.2425 days
*/
const daysInYear = 365.2425;
/**
* @constant
* @name maxTime
* @summary Maximum allowed time.
*
* @example
* import { maxTime } from "./constants/date-fns/constants";
*
* const isValid = 8640000000000001 <= maxTime;
* //=> false
*
* new Date(8640000000000001);
* //=> Invalid Date
*/
const maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000;
/**
* @constant
* @name minTime
* @summary Minimum allowed time.
*
* @example
* import { minTime } from "./constants/date-fns/constants";
*
* const isValid = -8640000000000001 >= minTime;
* //=> false
*
* new Date(-8640000000000001)
* //=> Invalid Date
*/
const minTime = -maxTime;
/**
* @constant
* @name millisecondsInWeek
* @summary Milliseconds in 1 week.
*/
const millisecondsInWeek = 604800000;
/**
* @constant
* @name millisecondsInDay
* @summary Milliseconds in 1 day.
*/
const millisecondsInDay = 86400000;
/**
* @constant
* @name millisecondsInMinute
* @summary Milliseconds in 1 minute
*/
const millisecondsInMinute = 60000;
/**
* @constant
* @name millisecondsInHour
* @summary Milliseconds in 1 hour
*/
const millisecondsInHour = 3600000;
/**
* @constant
* @name millisecondsInSecond
* @summary Milliseconds in 1 second
*/
const millisecondsInSecond = 1000;
/**
* @constant
* @name minutesInYear
* @summary Minutes in 1 year.
*/
const minutesInYear = 525600;
/**
* @constant
* @name minutesInMonth
* @summary Minutes in 1 month.
*/
const minutesInMonth = 43200;
/**
* @constant
* @name minutesInDay
* @summary Minutes in 1 day.
*/
const minutesInDay = 1440;
/**
* @constant
* @name minutesInHour
* @summary Minutes in 1 hour.
*/
const minutesInHour = 60;
/**
* @constant
* @name monthsInQuarter
* @summary Months in 1 quarter.
*/
const monthsInQuarter = 3;
/**
* @constant
* @name monthsInYear
* @summary Months in 1 year.
*/
const monthsInYear = 12;
/**
* @constant
* @name quartersInYear
* @summary Quarters in 1 year
*/
const quartersInYear = 4;
/**
* @constant
* @name secondsInHour
* @summary Seconds in 1 hour.
*/
const secondsInHour = 3600;
/**
* @constant
* @name secondsInMinute
* @summary Seconds in 1 minute.
*/
const secondsInMinute = 60;
/**
* @constant
* @name secondsInDay
* @summary Seconds in 1 day.
*/
const secondsInDay = secondsInHour * 24;
/**
* @constant
* @name secondsInWeek
* @summary Seconds in 1 week.
*/
const secondsInWeek = secondsInDay * 7;
/**
* @constant
* @name secondsInYear
* @summary Seconds in 1 year.
*/
const secondsInYear = secondsInDay * daysInYear;
/**
* @constant
* @name secondsInMonth
* @summary Seconds in 1 month
*/
const secondsInMonth = secondsInYear / 12;
/**
* @constant
* @name secondsInQuarter
* @summary Seconds in 1 quarter.
*/
const secondsInQuarter = secondsInMonth * 3;
;// ./node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.mjs
/**
* Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
* They usually appear for dates that denote time before the timezones were introduced
* (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
* and GMT+01:00:00 after that date)
*
* Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
* which would lead to incorrect calculations.
*
* This function returns the timezone offset in milliseconds that takes seconds in account.
*/
function getTimezoneOffsetInMilliseconds(date) {
const _date = toDate(date);
const utcDate = new Date(
Date.UTC(
_date.getFullYear(),
_date.getMonth(),
_date.getDate(),
_date.getHours(),
_date.getMinutes(),
_date.getSeconds(),
_date.getMilliseconds(),
),
);
utcDate.setUTCFullYear(_date.getFullYear());
return +date - +utcDate;
}
;// ./node_modules/date-fns/differenceInCalendarDays.mjs
/**
* @name differenceInCalendarDays
* @category Day Helpers
* @summary Get the number of calendar days between the given dates.
*
* @description
* Get the number of calendar days between the given dates. This means that the times are removed
* from the dates and then the difference in days is calculated.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param dateLeft - The later date
* @param dateRight - The earlier date
*
* @returns The number of calendar days
*
* @example
* // How many calendar days are between
* // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
* const result = differenceInCalendarDays(
* new Date(2012, 6, 2, 0, 0),
* new Date(2011, 6, 2, 23, 0)
* )
* //=> 366
* // How many calendar days are between
* // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
* const result = differenceInCalendarDays(
* new Date(2011, 6, 3, 0, 1),
* new Date(2011, 6, 2, 23, 59)
* )
* //=> 1
*/
function differenceInCalendarDays(dateLeft, dateRight) {
const startOfDayLeft = startOfDay(dateLeft);
const startOfDayRight = startOfDay(dateRight);
const timestampLeft =
+startOfDayLeft - getTimezoneOffsetInMilliseconds(startOfDayLeft);
const timestampRight =
+startOfDayRight - getTimezoneOffsetInMilliseconds(startOfDayRight);
// Round the number of days to the nearest integer because the number of
// milliseconds in a day is not constant (e.g. it's different in the week of
// the daylight saving time clock shift).
return Math.round((timestampLeft - timestampRight) / millisecondsInDay);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_differenceInCalendarDays = ((/* unused pure expression or super */ null && (differenceInCalendarDays)));
;// ./node_modules/date-fns/startOfYear.mjs
/**
* @name startOfYear
* @category Year Helpers
* @summary Return the start of a year for the given date.
*
* @description
* Return the start of a year for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
*
* @returns The start of a year
*
* @example
* // The start of a year for 2 September 2014 11:55:00:
* const result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))
* //=> Wed Jan 01 2014 00:00:00
*/
function startOfYear(date) {
const cleanDate = toDate(date);
const _date = constructFrom(date, 0);
_date.setFullYear(cleanDate.getFullYear(), 0, 1);
_date.setHours(0, 0, 0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfYear = ((/* unused pure expression or super */ null && (startOfYear)));
;// ./node_modules/date-fns/getDayOfYear.mjs
/**
* @name getDayOfYear
* @category Day Helpers
* @summary Get the day of the year of the given date.
*
* @description
* Get the day of the year of the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The given date
*
* @returns The day of year
*
* @example
* // Which day of the year is 2 July 2014?
* const result = getDayOfYear(new Date(2014, 6, 2))
* //=> 183
*/
function getDayOfYear(date) {
const _date = toDate(date);
const diff = differenceInCalendarDays(_date, startOfYear(_date));
const dayOfYear = diff + 1;
return dayOfYear;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getDayOfYear = ((/* unused pure expression or super */ null && (getDayOfYear)));
;// ./node_modules/date-fns/startOfWeek.mjs
/**
* The {@link startOfWeek} function options.
*/
/**
* @name startOfWeek
* @category Week Helpers
* @summary Return the start of a week for the given date.
*
* @description
* Return the start of a week for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
* @param options - An object with options
*
* @returns The start of a week
*
* @example
* // The start of a week for 2 September 2014 11:55:00:
* const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))
* //=> Sun Aug 31 2014 00:00:00
*
* @example
* // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:
* const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
* //=> Mon Sep 01 2014 00:00:00
*/
function startOfWeek(date, options) {
const defaultOptions = getDefaultOptions();
const weekStartsOn =
options?.weekStartsOn ??
options?.locale?.options?.weekStartsOn ??
defaultOptions.weekStartsOn ??
defaultOptions.locale?.options?.weekStartsOn ??
0;
const _date = toDate(date);
const day = _date.getDay();
const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
_date.setDate(_date.getDate() - diff);
_date.setHours(0, 0, 0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfWeek = ((/* unused pure expression or super */ null && (startOfWeek)));
;// ./node_modules/date-fns/startOfISOWeek.mjs
/**
* @name startOfISOWeek
* @category ISO Week Helpers
* @summary Return the start of an ISO week for the given date.
*
* @description
* Return the start of an ISO week for the given date.
* The result will be in the local timezone.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
*
* @returns The start of an ISO week
*
* @example
* // The start of an ISO week for 2 September 2014 11:55:00:
* const result = startOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))
* //=> Mon Sep 01 2014 00:00:00
*/
function startOfISOWeek(date) {
return startOfWeek(date, { weekStartsOn: 1 });
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfISOWeek = ((/* unused pure expression or super */ null && (startOfISOWeek)));
;// ./node_modules/date-fns/getISOWeekYear.mjs
/**
* @name getISOWeekYear
* @category ISO Week-Numbering Year Helpers
* @summary Get the ISO week-numbering year of the given date.
*
* @description
* Get the ISO week-numbering year of the given date,
* which always starts 3 days before the year's first Thursday.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The given date
*
* @returns The ISO week-numbering year
*
* @example
* // Which ISO-week numbering year is 2 January 2005?
* const result = getISOWeekYear(new Date(2005, 0, 2))
* //=> 2004
*/
function getISOWeekYear(date) {
const _date = toDate(date);
const year = _date.getFullYear();
const fourthOfJanuaryOfNextYear = constructFrom(date, 0);
fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
const startOfNextYear = startOfISOWeek(fourthOfJanuaryOfNextYear);
const fourthOfJanuaryOfThisYear = constructFrom(date, 0);
fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
const startOfThisYear = startOfISOWeek(fourthOfJanuaryOfThisYear);
if (_date.getTime() >= startOfNextYear.getTime()) {
return year + 1;
} else if (_date.getTime() >= startOfThisYear.getTime()) {
return year;
} else {
return year - 1;
}
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getISOWeekYear = ((/* unused pure expression or super */ null && (getISOWeekYear)));
;// ./node_modules/date-fns/startOfISOWeekYear.mjs
/**
* @name startOfISOWeekYear
* @category ISO Week-Numbering Year Helpers
* @summary Return the start of an ISO week-numbering year for the given date.
*
* @description
* Return the start of an ISO week-numbering year,
* which always starts 3 days before the year's first Thursday.
* The result will be in the local timezone.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
*
* @returns The start of an ISO week-numbering year
*
* @example
* // The start of an ISO week-numbering year for 2 July 2005:
* const result = startOfISOWeekYear(new Date(2005, 6, 2))
* //=> Mon Jan 03 2005 00:00:00
*/
function startOfISOWeekYear(date) {
const year = getISOWeekYear(date);
const fourthOfJanuary = constructFrom(date, 0);
fourthOfJanuary.setFullYear(year, 0, 4);
fourthOfJanuary.setHours(0, 0, 0, 0);
return startOfISOWeek(fourthOfJanuary);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfISOWeekYear = ((/* unused pure expression or super */ null && (startOfISOWeekYear)));
;// ./node_modules/date-fns/getISOWeek.mjs
/**
* @name getISOWeek
* @category ISO Week Helpers
* @summary Get the ISO week of the given date.
*
* @description
* Get the ISO week of the given date.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The given date
*
* @returns The ISO week
*
* @example
* // Which week of the ISO-week numbering year is 2 January 2005?
* const result = getISOWeek(new Date(2005, 0, 2))
* //=> 53
*/
function getISOWeek(date) {
const _date = toDate(date);
const diff = +startOfISOWeek(_date) - +startOfISOWeekYear(_date);
// Round the number of weeks to the nearest integer because the number of
// milliseconds in a week is not constant (e.g. it's different in the week of
// the daylight saving time clock shift).
return Math.round(diff / millisecondsInWeek) + 1;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getISOWeek = ((/* unused pure expression or super */ null && (getISOWeek)));
;// ./node_modules/date-fns/getWeekYear.mjs
/**
* The {@link getWeekYear} function options.
*/
/**
* @name getWeekYear
* @category Week-Numbering Year Helpers
* @summary Get the local week-numbering year of the given date.
*
* @description
* Get the local week-numbering year of the given date.
* The exact calculation depends on the values of
* `options.weekStartsOn` (which is the index of the first day of the week)
* and `options.firstWeekContainsDate` (which is the day of January, which is always in
* the first week of the week-numbering year)
*
* Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The given date
* @param options - An object with options.
*
* @returns The local week-numbering year
*
* @example
* // Which week numbering year is 26 December 2004 with the default settings?
* const result = getWeekYear(new Date(2004, 11, 26))
* //=> 2005
*
* @example
* // Which week numbering year is 26 December 2004 if week starts on Saturday?
* const result = getWeekYear(new Date(2004, 11, 26), { weekStartsOn: 6 })
* //=> 2004
*
* @example
* // Which week numbering year is 26 December 2004 if the first week contains 4 January?
* const result = getWeekYear(new Date(2004, 11, 26), { firstWeekContainsDate: 4 })
* //=> 2004
*/
function getWeekYear(date, options) {
const _date = toDate(date);
const year = _date.getFullYear();
const defaultOptions = getDefaultOptions();
const firstWeekContainsDate =
options?.firstWeekContainsDate ??
options?.locale?.options?.firstWeekContainsDate ??
defaultOptions.firstWeekContainsDate ??
defaultOptions.locale?.options?.firstWeekContainsDate ??
1;
const firstWeekOfNextYear = constructFrom(date, 0);
firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
firstWeekOfNextYear.setHours(0, 0, 0, 0);
const startOfNextYear = startOfWeek(firstWeekOfNextYear, options);
const firstWeekOfThisYear = constructFrom(date, 0);
firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
firstWeekOfThisYear.setHours(0, 0, 0, 0);
const startOfThisYear = startOfWeek(firstWeekOfThisYear, options);
if (_date.getTime() >= startOfNextYear.getTime()) {
return year + 1;
} else if (_date.getTime() >= startOfThisYear.getTime()) {
return year;
} else {
return year - 1;
}
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getWeekYear = ((/* unused pure expression or super */ null && (getWeekYear)));
;// ./node_modules/date-fns/startOfWeekYear.mjs
/**
* The {@link startOfWeekYear} function options.
*/
/**
* @name startOfWeekYear
* @category Week-Numbering Year Helpers
* @summary Return the start of a local week-numbering year for the given date.
*
* @description
* Return the start of a local week-numbering year.
* The exact calculation depends on the values of
* `options.weekStartsOn` (which is the index of the first day of the week)
* and `options.firstWeekContainsDate` (which is the day of January, which is always in
* the first week of the week-numbering year)
*
* Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
* @param options - An object with options
*
* @returns The start of a week-numbering year
*
* @example
* // The start of an a week-numbering year for 2 July 2005 with default settings:
* const result = startOfWeekYear(new Date(2005, 6, 2))
* //=> Sun Dec 26 2004 00:00:00
*
* @example
* // The start of a week-numbering year for 2 July 2005
* // if Monday is the first day of week
* // and 4 January is always in the first week of the year:
* const result = startOfWeekYear(new Date(2005, 6, 2), {
* weekStartsOn: 1,
* firstWeekContainsDate: 4
* })
* //=> Mon Jan 03 2005 00:00:00
*/
function startOfWeekYear(date, options) {
const defaultOptions = getDefaultOptions();
const firstWeekContainsDate =
options?.firstWeekContainsDate ??
options?.locale?.options?.firstWeekContainsDate ??
defaultOptions.firstWeekContainsDate ??
defaultOptions.locale?.options?.firstWeekContainsDate ??
1;
const year = getWeekYear(date, options);
const firstWeek = constructFrom(date, 0);
firstWeek.setFullYear(year, 0, firstWeekContainsDate);
firstWeek.setHours(0, 0, 0, 0);
const _date = startOfWeek(firstWeek, options);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfWeekYear = ((/* unused pure expression or super */ null && (startOfWeekYear)));
;// ./node_modules/date-fns/getWeek.mjs
/**
* The {@link getWeek} function options.
*/
/**
* @name getWeek
* @category Week Helpers
* @summary Get the local week index of the given date.
*
* @description
* Get the local week index of the given date.
* The exact calculation depends on the values of
* `options.weekStartsOn` (which is the index of the first day of the week)
* and `options.firstWeekContainsDate` (which is the day of January, which is always in
* the first week of the week-numbering year)
*
* Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The given date
* @param options - An object with options
*
* @returns The week
*
* @example
* // Which week of the local week numbering year is 2 January 2005 with default options?
* const result = getWeek(new Date(2005, 0, 2))
* //=> 2
*
* @example
* // Which week of the local week numbering year is 2 January 2005,
* // if Monday is the first day of the week,
* // and the first week of the year always contains 4 January?
* const result = getWeek(new Date(2005, 0, 2), {
* weekStartsOn: 1,
* firstWeekContainsDate: 4
* })
* //=> 53
*/
function getWeek(date, options) {
const _date = toDate(date);
const diff = +startOfWeek(_date, options) - +startOfWeekYear(_date, options);
// Round the number of weeks to the nearest integer because the number of
// milliseconds in a week is not constant (e.g. it's different in the week of
// the daylight saving time clock shift).
return Math.round(diff / millisecondsInWeek) + 1;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getWeek = ((/* unused pure expression or super */ null && (getWeek)));
;// ./node_modules/date-fns/_lib/addLeadingZeros.mjs
function addLeadingZeros(number, targetLength) {
const sign = number < 0 ? "-" : "";
const output = Math.abs(number).toString().padStart(targetLength, "0");
return sign + output;
}
;// ./node_modules/date-fns/_lib/format/lightFormatters.mjs
/*
* | | Unit | | Unit |
* |-----|--------------------------------|-----|--------------------------------|
* | a | AM, PM | A* | |
* | d | Day of month | D | |
* | h | Hour [1-12] | H | Hour [0-23] |
* | m | Minute | M | Month |
* | s | Second | S | Fraction of second |
* | y | Year (abs) | Y | |
*
* Letters marked by * are not implemented but reserved by Unicode standard.
*/
const lightFormatters = {
// Year
y(date, token) {
// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
// | Year | y | yy | yyy | yyyy | yyyyy |
// |----------|-------|----|-------|-------|-------|
// | AD 1 | 1 | 01 | 001 | 0001 | 00001 |
// | AD 12 | 12 | 12 | 012 | 0012 | 00012 |
// | AD 123 | 123 | 23 | 123 | 0123 | 00123 |
// | AD 1234 | 1234 | 34 | 1234 | 1234 | 01234 |
// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
const signedYear = date.getFullYear();
// Returns 1 for 1 BC (which is year 0 in JavaScript)
const year = signedYear > 0 ? signedYear : 1 - signedYear;
return addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
},
// Month
M(date, token) {
const month = date.getMonth();
return token === "M" ? String(month + 1) : addLeadingZeros(month + 1, 2);
},
// Day of the month
d(date, token) {
return addLeadingZeros(date.getDate(), token.length);
},
// AM or PM
a(date, token) {
const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
switch (token) {
case "a":
case "aa":
return dayPeriodEnumValue.toUpperCase();
case "aaa":
return dayPeriodEnumValue;
case "aaaaa":
return dayPeriodEnumValue[0];
case "aaaa":
default:
return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
}
},
// Hour [1-12]
h(date, token) {
return addLeadingZeros(date.getHours() % 12 || 12, token.length);
},
// Hour [0-23]
H(date, token) {
return addLeadingZeros(date.getHours(), token.length);
},
// Minute
m(date, token) {
return addLeadingZeros(date.getMinutes(), token.length);
},
// Second
s(date, token) {
return addLeadingZeros(date.getSeconds(), token.length);
},
// Fraction of second
S(date, token) {
const numberOfDigits = token.length;
const milliseconds = date.getMilliseconds();
const fractionalSeconds = Math.trunc(
milliseconds * Math.pow(10, numberOfDigits - 3),
);
return addLeadingZeros(fractionalSeconds, token.length);
},
};
;// ./node_modules/date-fns/_lib/format/formatters.mjs
const dayPeriodEnum = {
am: "am",
pm: "pm",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
};
/*
* | | Unit | | Unit |
* |-----|--------------------------------|-----|--------------------------------|
* | a | AM, PM | A* | Milliseconds in day |
* | b | AM, PM, noon, midnight | B | Flexible day period |
* | c | Stand-alone local day of week | C* | Localized hour w/ day period |
* | d | Day of month | D | Day of year |
* | e | Local day of week | E | Day of week |
* | f | | F* | Day of week in month |
* | g* | Modified Julian day | G | Era |
* | h | Hour [1-12] | H | Hour [0-23] |
* | i! | ISO day of week | I! | ISO week of year |
* | j* | Localized hour w/ day period | J* | Localized hour w/o day period |
* | k | Hour [1-24] | K | Hour [0-11] |
* | l* | (deprecated) | L | Stand-alone month |
* | m | Minute | M | Month |
* | n | | N | |
* | o! | Ordinal number modifier | O | Timezone (GMT) |
* | p! | Long localized time | P! | Long localized date |
* | q | Stand-alone quarter | Q | Quarter |
* | r* | Related Gregorian year | R! | ISO week-numbering year |
* | s | Second | S | Fraction of second |
* | t! | Seconds timestamp | T! | Milliseconds timestamp |
* | u | Extended year | U* | Cyclic year |
* | v* | Timezone (generic non-locat.) | V* | Timezone (location) |
* | w | Local week of year | W* | Week of month |
* | x | Timezone (ISO-8601 w/o Z) | X | Timezone (ISO-8601) |
* | y | Year (abs) | Y | Local week-numbering year |
* | z | Timezone (specific non-locat.) | Z* | Timezone (aliases) |
*
* Letters marked by * are not implemented but reserved by Unicode standard.
*
* Letters marked by ! are non-standard, but implemented by date-fns:
* - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
* - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
* i.e. 7 for Sunday, 1 for Monday, etc.
* - `I` is ISO week of year, as opposed to `w` which is local week of year.
* - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
* `R` is supposed to be used in conjunction with `I` and `i`
* for universal ISO week-numbering date, whereas
* `Y` is supposed to be used in conjunction with `w` and `e`
* for week-numbering date specific to the locale.
* - `P` is long localized date format
* - `p` is long localized time format
*/
const formatters = {
// Era
G: function (date, token, localize) {
const era = date.getFullYear() > 0 ? 1 : 0;
switch (token) {
// AD, BC
case "G":
case "GG":
case "GGG":
return localize.era(era, { width: "abbreviated" });
// A, B
case "GGGGG":
return localize.era(era, { width: "narrow" });
// Anno Domini, Before Christ
case "GGGG":
default:
return localize.era(era, { width: "wide" });
}
},
// Year
y: function (date, token, localize) {
// Ordinal number
if (token === "yo") {
const signedYear = date.getFullYear();
// Returns 1 for 1 BC (which is year 0 in JavaScript)
const year = signedYear > 0 ? signedYear : 1 - signedYear;
return localize.ordinalNumber(year, { unit: "year" });
}
return lightFormatters.y(date, token);
},
// Local week-numbering year
Y: function (date, token, localize, options) {
const signedWeekYear = getWeekYear(date, options);
// Returns 1 for 1 BC (which is year 0 in JavaScript)
const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
// Two digit year
if (token === "YY") {
const twoDigitYear = weekYear % 100;
return addLeadingZeros(twoDigitYear, 2);
}
// Ordinal number
if (token === "Yo") {
return localize.ordinalNumber(weekYear, { unit: "year" });
}
// Padding
return addLeadingZeros(weekYear, token.length);
},
// ISO week-numbering year
R: function (date, token) {
const isoWeekYear = getISOWeekYear(date);
// Padding
return addLeadingZeros(isoWeekYear, token.length);
},
// Extended year. This is a single number designating the year of this calendar system.
// The main difference between `y` and `u` localizers are B.C. years:
// | Year | `y` | `u` |
// |------|-----|-----|
// | AC 1 | 1 | 1 |
// | BC 1 | 1 | 0 |
// | BC 2 | 2 | -1 |
// Also `yy` always returns the last two digits of a year,
// while `uu` pads single digit years to 2 characters and returns other years unchanged.
u: function (date, token) {
const year = date.getFullYear();
return addLeadingZeros(year, token.length);
},
// Quarter
Q: function (date, token, localize) {
const quarter = Math.ceil((date.getMonth() + 1) / 3);
switch (token) {
// 1, 2, 3, 4
case "Q":
return String(quarter);
// 01, 02, 03, 04
case "QQ":
return addLeadingZeros(quarter, 2);
// 1st, 2nd, 3rd, 4th
case "Qo":
return localize.ordinalNumber(quarter, { unit: "quarter" });
// Q1, Q2, Q3, Q4
case "QQQ":
return localize.quarter(quarter, {
width: "abbreviated",
context: "formatting",
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "QQQQQ":
return localize.quarter(quarter, {
width: "narrow",
context: "formatting",
});
// 1st quarter, 2nd quarter, ...
case "QQQQ":
default:
return localize.quarter(quarter, {
width: "wide",
context: "formatting",
});
}
},
// Stand-alone quarter
q: function (date, token, localize) {
const quarter = Math.ceil((date.getMonth() + 1) / 3);
switch (token) {
// 1, 2, 3, 4
case "q":
return String(quarter);
// 01, 02, 03, 04
case "qq":
return addLeadingZeros(quarter, 2);
// 1st, 2nd, 3rd, 4th
case "qo":
return localize.ordinalNumber(quarter, { unit: "quarter" });
// Q1, Q2, Q3, Q4
case "qqq":
return localize.quarter(quarter, {
width: "abbreviated",
context: "standalone",
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "qqqqq":
return localize.quarter(quarter, {
width: "narrow",
context: "standalone",
});
// 1st quarter, 2nd quarter, ...
case "qqqq":
default:
return localize.quarter(quarter, {
width: "wide",
context: "standalone",
});
}
},
// Month
M: function (date, token, localize) {
const month = date.getMonth();
switch (token) {
case "M":
case "MM":
return lightFormatters.M(date, token);
// 1st, 2nd, ..., 12th
case "Mo":
return localize.ordinalNumber(month + 1, { unit: "month" });
// Jan, Feb, ..., Dec
case "MMM":
return localize.month(month, {
width: "abbreviated",
context: "formatting",
});
// J, F, ..., D
case "MMMMM":
return localize.month(month, {
width: "narrow",
context: "formatting",
});
// January, February, ..., December
case "MMMM":
default:
return localize.month(month, { width: "wide", context: "formatting" });
}
},
// Stand-alone month
L: function (date, token, localize) {
const month = date.getMonth();
switch (token) {
// 1, 2, ..., 12
case "L":
return String(month + 1);
// 01, 02, ..., 12
case "LL":
return addLeadingZeros(month + 1, 2);
// 1st, 2nd, ..., 12th
case "Lo":
return localize.ordinalNumber(month + 1, { unit: "month" });
// Jan, Feb, ..., Dec
case "LLL":
return localize.month(month, {
width: "abbreviated",
context: "standalone",
});
// J, F, ..., D
case "LLLLL":
return localize.month(month, {
width: "narrow",
context: "standalone",
});
// January, February, ..., December
case "LLLL":
default:
return localize.month(month, { width: "wide", context: "standalone" });
}
},
// Local week of year
w: function (date, token, localize, options) {
const week = getWeek(date, options);
if (token === "wo") {
return localize.ordinalNumber(week, { unit: "week" });
}
return addLeadingZeros(week, token.length);
},
// ISO week of year
I: function (date, token, localize) {
const isoWeek = getISOWeek(date);
if (token === "Io") {
return localize.ordinalNumber(isoWeek, { unit: "week" });
}
return addLeadingZeros(isoWeek, token.length);
},
// Day of the month
d: function (date, token, localize) {
if (token === "do") {
return localize.ordinalNumber(date.getDate(), { unit: "date" });
}
return lightFormatters.d(date, token);
},
// Day of year
D: function (date, token, localize) {
const dayOfYear = getDayOfYear(date);
if (token === "Do") {
return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
}
return addLeadingZeros(dayOfYear, token.length);
},
// Day of week
E: function (date, token, localize) {
const dayOfWeek = date.getDay();
switch (token) {
// Tue
case "E":
case "EE":
case "EEE":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "formatting",
});
// T
case "EEEEE":
return localize.day(dayOfWeek, {
width: "narrow",
context: "formatting",
});
// Tu
case "EEEEEE":
return localize.day(dayOfWeek, {
width: "short",
context: "formatting",
});
// Tuesday
case "EEEE":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "formatting",
});
}
},
// Local day of week
e: function (date, token, localize, options) {
const dayOfWeek = date.getDay();
const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
switch (token) {
// Numerical value (Nth day of week with current locale or weekStartsOn)
case "e":
return String(localDayOfWeek);
// Padded numerical value
case "ee":
return addLeadingZeros(localDayOfWeek, 2);
// 1st, 2nd, ..., 7th
case "eo":
return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
case "eee":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "formatting",
});
// T
case "eeeee":
return localize.day(dayOfWeek, {
width: "narrow",
context: "formatting",
});
// Tu
case "eeeeee":
return localize.day(dayOfWeek, {
width: "short",
context: "formatting",
});
// Tuesday
case "eeee":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "formatting",
});
}
},
// Stand-alone local day of week
c: function (date, token, localize, options) {
const dayOfWeek = date.getDay();
const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
switch (token) {
// Numerical value (same as in `e`)
case "c":
return String(localDayOfWeek);
// Padded numerical value
case "cc":
return addLeadingZeros(localDayOfWeek, token.length);
// 1st, 2nd, ..., 7th
case "co":
return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
case "ccc":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "standalone",
});
// T
case "ccccc":
return localize.day(dayOfWeek, {
width: "narrow",
context: "standalone",
});
// Tu
case "cccccc":
return localize.day(dayOfWeek, {
width: "short",
context: "standalone",
});
// Tuesday
case "cccc":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "standalone",
});
}
},
// ISO day of week
i: function (date, token, localize) {
const dayOfWeek = date.getDay();
const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
switch (token) {
// 2
case "i":
return String(isoDayOfWeek);
// 02
case "ii":
return addLeadingZeros(isoDayOfWeek, token.length);
// 2nd
case "io":
return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
// Tue
case "iii":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "formatting",
});
// T
case "iiiii":
return localize.day(dayOfWeek, {
width: "narrow",
context: "formatting",
});
// Tu
case "iiiiii":
return localize.day(dayOfWeek, {
width: "short",
context: "formatting",
});
// Tuesday
case "iiii":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "formatting",
});
}
},
// AM or PM
a: function (date, token, localize) {
const hours = date.getHours();
const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
switch (token) {
case "a":
case "aa":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
});
case "aaa":
return localize
.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
})
.toLowerCase();
case "aaaaa":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "narrow",
context: "formatting",
});
case "aaaa":
default:
return localize.dayPeriod(dayPeriodEnumValue, {
width: "wide",
context: "formatting",
});
}
},
// AM, PM, midnight, noon
b: function (date, token, localize) {
const hours = date.getHours();
let dayPeriodEnumValue;
if (hours === 12) {
dayPeriodEnumValue = dayPeriodEnum.noon;
} else if (hours === 0) {
dayPeriodEnumValue = dayPeriodEnum.midnight;
} else {
dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
}
switch (token) {
case "b":
case "bb":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
});
case "bbb":
return localize
.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
})
.toLowerCase();
case "bbbbb":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "narrow",
context: "formatting",
});
case "bbbb":
default:
return localize.dayPeriod(dayPeriodEnumValue, {
width: "wide",
context: "formatting",
});
}
},
// in the morning, in the afternoon, in the evening, at night
B: function (date, token, localize) {
const hours = date.getHours();
let dayPeriodEnumValue;
if (hours >= 17) {
dayPeriodEnumValue = dayPeriodEnum.evening;
} else if (hours >= 12) {
dayPeriodEnumValue = dayPeriodEnum.afternoon;
} else if (hours >= 4) {
dayPeriodEnumValue = dayPeriodEnum.morning;
} else {
dayPeriodEnumValue = dayPeriodEnum.night;
}
switch (token) {
case "B":
case "BB":
case "BBB":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
});
case "BBBBB":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "narrow",
context: "formatting",
});
case "BBBB":
default:
return localize.dayPeriod(dayPeriodEnumValue, {
width: "wide",
context: "formatting",
});
}
},
// Hour [1-12]
h: function (date, token, localize) {
if (token === "ho") {
let hours = date.getHours() % 12;
if (hours === 0) hours = 12;
return localize.ordinalNumber(hours, { unit: "hour" });
}
return lightFormatters.h(date, token);
},
// Hour [0-23]
H: function (date, token, localize) {
if (token === "Ho") {
return localize.ordinalNumber(date.getHours(), { unit: "hour" });
}
return lightFormatters.H(date, token);
},
// Hour [0-11]
K: function (date, token, localize) {
const hours = date.getHours() % 12;
if (token === "Ko") {
return localize.ordinalNumber(hours, { unit: "hour" });
}
return addLeadingZeros(hours, token.length);
},
// Hour [1-24]
k: function (date, token, localize) {
let hours = date.getHours();
if (hours === 0) hours = 24;
if (token === "ko") {
return localize.ordinalNumber(hours, { unit: "hour" });
}
return addLeadingZeros(hours, token.length);
},
// Minute
m: function (date, token, localize) {
if (token === "mo") {
return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
}
return lightFormatters.m(date, token);
},
// Second
s: function (date, token, localize) {
if (token === "so") {
return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
}
return lightFormatters.s(date, token);
},
// Fraction of second
S: function (date, token) {
return lightFormatters.S(date, token);
},
// Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
X: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
if (timezoneOffset === 0) {
return "Z";
}
switch (token) {
// Hours and optional minutes
case "X":
return formatTimezoneWithOptionalMinutes(timezoneOffset);
// Hours, minutes and optional seconds without `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `XX`
case "XXXX":
case "XX": // Hours and minutes without `:` delimiter
return formatTimezone(timezoneOffset);
// Hours, minutes and optional seconds with `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `XXX`
case "XXXXX":
case "XXX": // Hours and minutes with `:` delimiter
default:
return formatTimezone(timezoneOffset, ":");
}
},
// Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
x: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
switch (token) {
// Hours and optional minutes
case "x":
return formatTimezoneWithOptionalMinutes(timezoneOffset);
// Hours, minutes and optional seconds without `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `xx`
case "xxxx":
case "xx": // Hours and minutes without `:` delimiter
return formatTimezone(timezoneOffset);
// Hours, minutes and optional seconds with `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `xxx`
case "xxxxx":
case "xxx": // Hours and minutes with `:` delimiter
default:
return formatTimezone(timezoneOffset, ":");
}
},
// Timezone (GMT)
O: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
switch (token) {
// Short
case "O":
case "OO":
case "OOO":
return "GMT" + formatTimezoneShort(timezoneOffset, ":");
// Long
case "OOOO":
default:
return "GMT" + formatTimezone(timezoneOffset, ":");
}
},
// Timezone (specific non-location)
z: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
switch (token) {
// Short
case "z":
case "zz":
case "zzz":
return "GMT" + formatTimezoneShort(timezoneOffset, ":");
// Long
case "zzzz":
default:
return "GMT" + formatTimezone(timezoneOffset, ":");
}
},
// Seconds timestamp
t: function (date, token, _localize) {
const timestamp = Math.trunc(date.getTime() / 1000);
return addLeadingZeros(timestamp, token.length);
},
// Milliseconds timestamp
T: function (date, token, _localize) {
const timestamp = date.getTime();
return addLeadingZeros(timestamp, token.length);
},
};
function formatTimezoneShort(offset, delimiter = "") {
const sign = offset > 0 ? "-" : "+";
const absOffset = Math.abs(offset);
const hours = Math.trunc(absOffset / 60);
const minutes = absOffset % 60;
if (minutes === 0) {
return sign + String(hours);
}
return sign + String(hours) + delimiter + addLeadingZeros(minutes, 2);
}
function formatTimezoneWithOptionalMinutes(offset, delimiter) {
if (offset % 60 === 0) {
const sign = offset > 0 ? "-" : "+";
return sign + addLeadingZeros(Math.abs(offset) / 60, 2);
}
return formatTimezone(offset, delimiter);
}
function formatTimezone(offset, delimiter = "") {
const sign = offset > 0 ? "-" : "+";
const absOffset = Math.abs(offset);
const hours = addLeadingZeros(Math.trunc(absOffset / 60), 2);
const minutes = addLeadingZeros(absOffset % 60, 2);
return sign + hours + delimiter + minutes;
}
;// ./node_modules/date-fns/_lib/format/longFormatters.mjs
const dateLongFormatter = (pattern, formatLong) => {
switch (pattern) {
case "P":
return formatLong.date({ width: "short" });
case "PP":
return formatLong.date({ width: "medium" });
case "PPP":
return formatLong.date({ width: "long" });
case "PPPP":
default:
return formatLong.date({ width: "full" });
}
};
const timeLongFormatter = (pattern, formatLong) => {
switch (pattern) {
case "p":
return formatLong.time({ width: "short" });
case "pp":
return formatLong.time({ width: "medium" });
case "ppp":
return formatLong.time({ width: "long" });
case "pppp":
default:
return formatLong.time({ width: "full" });
}
};
const dateTimeLongFormatter = (pattern, formatLong) => {
const matchResult = pattern.match(/(P+)(p+)?/) || [];
const datePattern = matchResult[1];
const timePattern = matchResult[2];
if (!timePattern) {
return dateLongFormatter(pattern, formatLong);
}
let dateTimeFormat;
switch (datePattern) {
case "P":
dateTimeFormat = formatLong.dateTime({ width: "short" });
break;
case "PP":
dateTimeFormat = formatLong.dateTime({ width: "medium" });
break;
case "PPP":
dateTimeFormat = formatLong.dateTime({ width: "long" });
break;
case "PPPP":
default:
dateTimeFormat = formatLong.dateTime({ width: "full" });
break;
}
return dateTimeFormat
.replace("{{date}}", dateLongFormatter(datePattern, formatLong))
.replace("{{time}}", timeLongFormatter(timePattern, formatLong));
};
const longFormatters = {
p: timeLongFormatter,
P: dateTimeLongFormatter,
};
;// ./node_modules/date-fns/_lib/protectedTokens.mjs
const dayOfYearTokenRE = /^D+$/;
const weekYearTokenRE = /^Y+$/;
const throwTokens = ["D", "DD", "YY", "YYYY"];
function isProtectedDayOfYearToken(token) {
return dayOfYearTokenRE.test(token);
}
function isProtectedWeekYearToken(token) {
return weekYearTokenRE.test(token);
}
function warnOrThrowProtectedError(token, format, input) {
const _message = message(token, format, input);
console.warn(_message);
if (throwTokens.includes(token)) throw new RangeError(_message);
}
function message(token, format, input) {
const subject = token[0] === "Y" ? "years" : "days of the month";
return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
}
;// ./node_modules/date-fns/isDate.mjs
/**
* @name isDate
* @category Common Helpers
* @summary Is the given value a date?
*
* @description
* Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
*
* @param value - The value to check
*
* @returns True if the given value is a date
*
* @example
* // For a valid date:
* const result = isDate(new Date())
* //=> true
*
* @example
* // For an invalid date:
* const result = isDate(new Date(NaN))
* //=> true
*
* @example
* // For some value:
* const result = isDate('2014-02-31')
* //=> false
*
* @example
* // For an object:
* const result = isDate({})
* //=> false
*/
function isDate(value) {
return (
value instanceof Date ||
(typeof value === "object" &&
Object.prototype.toString.call(value) === "[object Date]")
);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isDate = ((/* unused pure expression or super */ null && (isDate)));
;// ./node_modules/date-fns/isValid.mjs
/**
* @name isValid
* @category Common Helpers
* @summary Is the given date valid?
*
* @description
* Returns false if argument is Invalid Date and true otherwise.
* Argument is converted to Date using `toDate`. See [toDate](https://date-fns.org/docs/toDate)
* Invalid Date is a Date, whose time value is NaN.
*
* Time value of Date: http://es5.github.io/#x15.9.1.1
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to check
*
* @returns The date is valid
*
* @example
* // For the valid date:
* const result = isValid(new Date(2014, 1, 31))
* //=> true
*
* @example
* // For the value, convertable into a date:
* const result = isValid(1393804800000)
* //=> true
*
* @example
* // For the invalid date:
* const result = isValid(new Date(''))
* //=> false
*/
function isValid(date) {
if (!isDate(date) && typeof date !== "number") {
return false;
}
const _date = toDate(date);
return !isNaN(Number(_date));
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isValid = ((/* unused pure expression or super */ null && (isValid)));
;// ./node_modules/date-fns/format.mjs
// Rexports of internal for libraries to use.
// See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874
// This RegExp consists of three parts separated by `|`:
// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token
// (one of the certain letters followed by `o`)
// - (\w)\1* matches any sequences of the same letter
// - '' matches two quote characters in a row
// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
// except a single quote symbol, which ends the sequence.
// Two quote characters do not end the sequence.
// If there is no matching single quote
// then the sequence will continue until the end of the string.
// - . matches any single character unmatched by previous parts of the RegExps
const formattingTokensRegExp =
/[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
// This RegExp catches symbols escaped by quotes, and also
// sequences of symbols P, p, and the combinations like `PPPPPPPppppp`
const longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
const escapedStringRegExp = /^'([^]*?)'?$/;
const doubleQuoteRegExp = /''/g;
const unescapedLatinCharacterRegExp = /[a-zA-Z]/;
/**
* The {@link format} function options.
*/
/**
* @name format
* @alias formatDate
* @category Common Helpers
* @summary Format the date.
*
* @description
* Return the formatted date string in the given format. The result may vary by locale.
*
* > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
* > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
*
* The characters wrapped between two single quotes characters (') are escaped.
* Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
* (see the last example)
*
* Format of the string is based on Unicode Technical Standard #35:
* https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
* with a few additions (see note 7 below the table).
*
* Accepted patterns:
* | Unit | Pattern | Result examples | Notes |
* |---------------------------------|---------|-----------------------------------|-------|
* | Era | G..GGG | AD, BC | |
* | | GGGG | Anno Domini, Before Christ | 2 |
* | | GGGGG | A, B | |
* | Calendar year | y | 44, 1, 1900, 2017 | 5 |
* | | yo | 44th, 1st, 0th, 17th | 5,7 |
* | | yy | 44, 01, 00, 17 | 5 |
* | | yyy | 044, 001, 1900, 2017 | 5 |
* | | yyyy | 0044, 0001, 1900, 2017 | 5 |
* | | yyyyy | ... | 3,5 |
* | Local week-numbering year | Y | 44, 1, 1900, 2017 | 5 |
* | | Yo | 44th, 1st, 1900th, 2017th | 5,7 |
* | | YY | 44, 01, 00, 17 | 5,8 |
* | | YYY | 044, 001, 1900, 2017 | 5 |
* | | YYYY | 0044, 0001, 1900, 2017 | 5,8 |
* | | YYYYY | ... | 3,5 |
* | ISO week-numbering year | R | -43, 0, 1, 1900, 2017 | 5,7 |
* | | RR | -43, 00, 01, 1900, 2017 | 5,7 |
* | | RRR | -043, 000, 001, 1900, 2017 | 5,7 |
* | | RRRR | -0043, 0000, 0001, 1900, 2017 | 5,7 |
* | | RRRRR | ... | 3,5,7 |
* | Extended year | u | -43, 0, 1, 1900, 2017 | 5 |
* | | uu | -43, 01, 1900, 2017 | 5 |
* | | uuu | -043, 001, 1900, 2017 | 5 |
* | | uuuu | -0043, 0001, 1900, 2017 | 5 |
* | | uuuuu | ... | 3,5 |
* | Quarter (formatting) | Q | 1, 2, 3, 4 | |
* | | Qo | 1st, 2nd, 3rd, 4th | 7 |
* | | QQ | 01, 02, 03, 04 | |
* | | QQQ | Q1, Q2, Q3, Q4 | |
* | | QQQQ | 1st quarter, 2nd quarter, ... | 2 |
* | | QQQQQ | 1, 2, 3, 4 | 4 |
* | Quarter (stand-alone) | q | 1, 2, 3, 4 | |
* | | qo | 1st, 2nd, 3rd, 4th | 7 |
* | | qq | 01, 02, 03, 04 | |
* | | qqq | Q1, Q2, Q3, Q4 | |
* | | qqqq | 1st quarter, 2nd quarter, ... | 2 |
* | | qqqqq | 1, 2, 3, 4 | 4 |
* | Month (formatting) | M | 1, 2, ..., 12 | |
* | | Mo | 1st, 2nd, ..., 12th | 7 |
* | | MM | 01, 02, ..., 12 | |
* | | MMM | Jan, Feb, ..., Dec | |
* | | MMMM | January, February, ..., December | 2 |
* | | MMMMM | J, F, ..., D | |
* | Month (stand-alone) | L | 1, 2, ..., 12 | |
* | | Lo | 1st, 2nd, ..., 12th | 7 |
* | | LL | 01, 02, ..., 12 | |
* | | LLL | Jan, Feb, ..., Dec | |
* | | LLLL | January, February, ..., December | 2 |
* | | LLLLL | J, F, ..., D | |
* | Local week of year | w | 1, 2, ..., 53 | |
* | | wo | 1st, 2nd, ..., 53th | 7 |
* | | ww | 01, 02, ..., 53 | |
* | ISO week of year | I | 1, 2, ..., 53 | 7 |
* | | Io | 1st, 2nd, ..., 53th | 7 |
* | | II | 01, 02, ..., 53 | 7 |
* | Day of month | d | 1, 2, ..., 31 | |
* | | do | 1st, 2nd, ..., 31st | 7 |
* | | dd | 01, 02, ..., 31 | |
* | Day of year | D | 1, 2, ..., 365, 366 | 9 |
* | | Do | 1st, 2nd, ..., 365th, 366th | 7 |
* | | DD | 01, 02, ..., 365, 366 | 9 |
* | | DDD | 001, 002, ..., 365, 366 | |
* | | DDDD | ... | 3 |
* | Day of week (formatting) | E..EEE | Mon, Tue, Wed, ..., Sun | |
* | | EEEE | Monday, Tuesday, ..., Sunday | 2 |
* | | EEEEE | M, T, W, T, F, S, S | |
* | | EEEEEE | Mo, Tu, We, Th, Fr, Sa, Su | |
* | ISO day of week (formatting) | i | 1, 2, 3, ..., 7 | 7 |
* | | io | 1st, 2nd, ..., 7th | 7 |
* | | ii | 01, 02, ..., 07 | 7 |
* | | iii | Mon, Tue, Wed, ..., Sun | 7 |
* | | iiii | Monday, Tuesday, ..., Sunday | 2,7 |
* | | iiiii | M, T, W, T, F, S, S | 7 |
* | | iiiiii | Mo, Tu, We, Th, Fr, Sa, Su | 7 |
* | Local day of week (formatting) | e | 2, 3, 4, ..., 1 | |
* | | eo | 2nd, 3rd, ..., 1st | 7 |
* | | ee | 02, 03, ..., 01 | |
* | | eee | Mon, Tue, Wed, ..., Sun | |
* | | eeee | Monday, Tuesday, ..., Sunday | 2 |
* | | eeeee | M, T, W, T, F, S, S | |
* | | eeeeee | Mo, Tu, We, Th, Fr, Sa, Su | |
* | Local day of week (stand-alone) | c | 2, 3, 4, ..., 1 | |
* | | co | 2nd, 3rd, ..., 1st | 7 |
* | | cc | 02, 03, ..., 01 | |
* | | ccc | Mon, Tue, Wed, ..., Sun | |
* | | cccc | Monday, Tuesday, ..., Sunday | 2 |
* | | ccccc | M, T, W, T, F, S, S | |
* | | cccccc | Mo, Tu, We, Th, Fr, Sa, Su | |
* | AM, PM | a..aa | AM, PM | |
* | | aaa | am, pm | |
* | | aaaa | a.m., p.m. | 2 |
* | | aaaaa | a, p | |
* | AM, PM, noon, midnight | b..bb | AM, PM, noon, midnight | |
* | | bbb | am, pm, noon, midnight | |
* | | bbbb | a.m., p.m., noon, midnight | 2 |
* | | bbbbb | a, p, n, mi | |
* | Flexible day period | B..BBB | at night, in the morning, ... | |
* | | BBBB | at night, in the morning, ... | 2 |
* | | BBBBB | at night, in the morning, ... | |
* | Hour [1-12] | h | 1, 2, ..., 11, 12 | |
* | | ho | 1st, 2nd, ..., 11th, 12th | 7 |
* | | hh | 01, 02, ..., 11, 12 | |
* | Hour [0-23] | H | 0, 1, 2, ..., 23 | |
* | | Ho | 0th, 1st, 2nd, ..., 23rd | 7 |
* | | HH | 00, 01, 02, ..., 23 | |
* | Hour [0-11] | K | 1, 2, ..., 11, 0 | |
* | | Ko | 1st, 2nd, ..., 11th, 0th | 7 |
* | | KK | 01, 02, ..., 11, 00 | |
* | Hour [1-24] | k | 24, 1, 2, ..., 23 | |
* | | ko | 24th, 1st, 2nd, ..., 23rd | 7 |
* | | kk | 24, 01, 02, ..., 23 | |
* | Minute | m | 0, 1, ..., 59 | |
* | | mo | 0th, 1st, ..., 59th | 7 |
* | | mm | 00, 01, ..., 59 | |
* | Second | s | 0, 1, ..., 59 | |
* | | so | 0th, 1st, ..., 59th | 7 |
* | | ss | 00, 01, ..., 59 | |
* | Fraction of second | S | 0, 1, ..., 9 | |
* | | SS | 00, 01, ..., 99 | |
* | | SSS | 000, 001, ..., 999 | |
* | | SSSS | ... | 3 |
* | Timezone (ISO-8601 w/ Z) | X | -08, +0530, Z | |
* | | XX | -0800, +0530, Z | |
* | | XXX | -08:00, +05:30, Z | |
* | | XXXX | -0800, +0530, Z, +123456 | 2 |
* | | XXXXX | -08:00, +05:30, Z, +12:34:56 | |
* | Timezone (ISO-8601 w/o Z) | x | -08, +0530, +00 | |
* | | xx | -0800, +0530, +0000 | |
* | | xxx | -08:00, +05:30, +00:00 | 2 |
* | | xxxx | -0800, +0530, +0000, +123456 | |
* | | xxxxx | -08:00, +05:30, +00:00, +12:34:56 | |
* | Timezone (GMT) | O...OOO | GMT-8, GMT+5:30, GMT+0 | |
* | | OOOO | GMT-08:00, GMT+05:30, GMT+00:00 | 2 |
* | Timezone (specific non-locat.) | z...zzz | GMT-8, GMT+5:30, GMT+0 | 6 |
* | | zzzz | GMT-08:00, GMT+05:30, GMT+00:00 | 2,6 |
* | Seconds timestamp | t | 512969520 | 7 |
* | | tt | ... | 3,7 |
* | Milliseconds timestamp | T | 512969520900 | 7 |
* | | TT | ... | 3,7 |
* | Long localized date | P | 04/29/1453 | 7 |
* | | PP | Apr 29, 1453 | 7 |
* | | PPP | April 29th, 1453 | 7 |
* | | PPPP | Friday, April 29th, 1453 | 2,7 |
* | Long localized time | p | 12:00 AM | 7 |
* | | pp | 12:00:00 AM | 7 |
* | | ppp | 12:00:00 AM GMT+2 | 7 |
* | | pppp | 12:00:00 AM GMT+02:00 | 2,7 |
* | Combination of date and time | Pp | 04/29/1453, 12:00 AM | 7 |
* | | PPpp | Apr 29, 1453, 12:00:00 AM | 7 |
* | | PPPppp | April 29th, 1453 at ... | 7 |
* | | PPPPpppp| Friday, April 29th, 1453 at ... | 2,7 |
* Notes:
* 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
* are the same as "stand-alone" units, but are different in some languages.
* "Formatting" units are declined according to the rules of the language
* in the context of a date. "Stand-alone" units are always nominative singular:
*
* `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
*
* `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
*
* 2. Any sequence of the identical letters is a pattern, unless it is escaped by
* the single quote characters (see below).
* If the sequence is longer than listed in table (e.g. `EEEEEEEEEEE`)
* the output will be the same as default pattern for this unit, usually
* the longest one (in case of ISO weekdays, `EEEE`). Default patterns for units
* are marked with "2" in the last column of the table.
*
* `format(new Date(2017, 10, 6), 'MMM') //=> 'Nov'`
*
* `format(new Date(2017, 10, 6), 'MMMM') //=> 'November'`
*
* `format(new Date(2017, 10, 6), 'MMMMM') //=> 'N'`
*
* `format(new Date(2017, 10, 6), 'MMMMMM') //=> 'November'`
*
* `format(new Date(2017, 10, 6), 'MMMMMMM') //=> 'November'`
*
* 3. Some patterns could be unlimited length (such as `yyyyyyyy`).
* The output will be padded with zeros to match the length of the pattern.
*
* `format(new Date(2017, 10, 6), 'yyyyyyyy') //=> '00002017'`
*
* 4. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
* These tokens represent the shortest form of the quarter.
*
* 5. The main difference between `y` and `u` patterns are B.C. years:
*
* | Year | `y` | `u` |
* |------|-----|-----|
* | AC 1 | 1 | 1 |
* | BC 1 | 1 | 0 |
* | BC 2 | 2 | -1 |
*
* Also `yy` always returns the last two digits of a year,
* while `uu` pads single digit years to 2 characters and returns other years unchanged:
*
* | Year | `yy` | `uu` |
* |------|------|------|
* | 1 | 01 | 01 |
* | 14 | 14 | 14 |
* | 376 | 76 | 376 |
* | 1453 | 53 | 1453 |
*
* The same difference is true for local and ISO week-numbering years (`Y` and `R`),
* except local week-numbering years are dependent on `options.weekStartsOn`
* and `options.firstWeekContainsDate` (compare [getISOWeekYear](https://date-fns.org/docs/getISOWeekYear)
* and [getWeekYear](https://date-fns.org/docs/getWeekYear)).
*
* 6. Specific non-location timezones are currently unavailable in `date-fns`,
* so right now these tokens fall back to GMT timezones.
*
* 7. These patterns are not in the Unicode Technical Standard #35:
* - `i`: ISO day of week
* - `I`: ISO week of year
* - `R`: ISO week-numbering year
* - `t`: seconds timestamp
* - `T`: milliseconds timestamp
* - `o`: ordinal number modifier
* - `P`: long localized date
* - `p`: long localized time
*
* 8. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.
* You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
*
* 9. `D` and `DD` tokens represent days of the year but they are often confused with days of the month.
* You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
* @param format - The string of tokens
* @param options - An object with options
*
* @returns The formatted date string
*
* @throws `date` must not be Invalid Date
* @throws `options.locale` must contain `localize` property
* @throws `options.locale` must contain `formatLong` property
* @throws use `yyyy` instead of `YYYY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws use `yy` instead of `YY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws use `d` instead of `D` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws use `dd` instead of `DD` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws format string contains an unescaped latin alphabet character
*
* @example
* // Represent 11 February 2014 in middle-endian format:
* const result = format(new Date(2014, 1, 11), 'MM/dd/yyyy')
* //=> '02/11/2014'
*
* @example
* // Represent 2 July 2014 in Esperanto:
* import { eoLocale } from 'date-fns/locale/eo'
* const result = format(new Date(2014, 6, 2), "do 'de' MMMM yyyy", {
* locale: eoLocale
* })
* //=> '2-a de julio 2014'
*
* @example
* // Escape string by single quote characters:
* const result = format(new Date(2014, 6, 2, 15), "h 'o''clock'")
* //=> "3 o'clock"
*/
function format(date, formatStr, options) {
const defaultOptions = getDefaultOptions();
const locale = options?.locale ?? defaultOptions.locale ?? enUS;
const firstWeekContainsDate =
options?.firstWeekContainsDate ??
options?.locale?.options?.firstWeekContainsDate ??
defaultOptions.firstWeekContainsDate ??
defaultOptions.locale?.options?.firstWeekContainsDate ??
1;
const weekStartsOn =
options?.weekStartsOn ??
options?.locale?.options?.weekStartsOn ??
defaultOptions.weekStartsOn ??
defaultOptions.locale?.options?.weekStartsOn ??
0;
const originalDate = toDate(date);
if (!isValid(originalDate)) {
throw new RangeError("Invalid time value");
}
let parts = formatStr
.match(longFormattingTokensRegExp)
.map((substring) => {
const firstCharacter = substring[0];
if (firstCharacter === "p" || firstCharacter === "P") {
const longFormatter = longFormatters[firstCharacter];
return longFormatter(substring, locale.formatLong);
}
return substring;
})
.join("")
.match(formattingTokensRegExp)
.map((substring) => {
// Replace two single quote characters with one single quote character
if (substring === "''") {
return { isToken: false, value: "'" };
}
const firstCharacter = substring[0];
if (firstCharacter === "'") {
return { isToken: false, value: cleanEscapedString(substring) };
}
if (formatters[firstCharacter]) {
return { isToken: true, value: substring };
}
if (firstCharacter.match(unescapedLatinCharacterRegExp)) {
throw new RangeError(
"Format string contains an unescaped latin alphabet character `" +
firstCharacter +
"`",
);
}
return { isToken: false, value: substring };
});
// invoke localize preprocessor (only for french locales at the moment)
if (locale.localize.preprocessor) {
parts = locale.localize.preprocessor(originalDate, parts);
}
const formatterOptions = {
firstWeekContainsDate,
weekStartsOn,
locale,
};
return parts
.map((part) => {
if (!part.isToken) return part.value;
const token = part.value;
if (
(!options?.useAdditionalWeekYearTokens &&
isProtectedWeekYearToken(token)) ||
(!options?.useAdditionalDayOfYearTokens &&
isProtectedDayOfYearToken(token))
) {
warnOrThrowProtectedError(token, formatStr, String(date));
}
const formatter = formatters[token[0]];
return formatter(originalDate, token, locale.localize, formatterOptions);
})
.join("");
}
function cleanEscapedString(input) {
const matched = input.match(escapedStringRegExp);
if (!matched) {
return input;
}
return matched[1].replace(doubleQuoteRegExp, "'");
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_format = ((/* unused pure expression or super */ null && (format)));
;// ./node_modules/date-fns/isSameMonth.mjs
/**
* @name isSameMonth
* @category Month Helpers
* @summary Are the given dates in the same month (and year)?
*
* @description
* Are the given dates in the same month (and year)?
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param dateLeft - The first date to check
* @param dateRight - The second date to check
*
* @returns The dates are in the same month (and year)
*
* @example
* // Are 2 September 2014 and 25 September 2014 in the same month?
* const result = isSameMonth(new Date(2014, 8, 2), new Date(2014, 8, 25))
* //=> true
*
* @example
* // Are 2 September 2014 and 25 September 2015 in the same month?
* const result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25))
* //=> false
*/
function isSameMonth(dateLeft, dateRight) {
const _dateLeft = toDate(dateLeft);
const _dateRight = toDate(dateRight);
return (
_dateLeft.getFullYear() === _dateRight.getFullYear() &&
_dateLeft.getMonth() === _dateRight.getMonth()
);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isSameMonth = ((/* unused pure expression or super */ null && (isSameMonth)));
;// ./node_modules/date-fns/isEqual.mjs
/**
* @name isEqual
* @category Common Helpers
* @summary Are the given dates equal?
*
* @description
* Are the given dates equal?
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param dateLeft - The first date to compare
* @param dateRight - The second date to compare
*
* @returns The dates are equal
*
* @example
* // Are 2 July 2014 06:30:45.000 and 2 July 2014 06:30:45.500 equal?
* const result = isEqual(
* new Date(2014, 6, 2, 6, 30, 45, 0),
* new Date(2014, 6, 2, 6, 30, 45, 500)
* )
* //=> false
*/
function isEqual(leftDate, rightDate) {
const _dateLeft = toDate(leftDate);
const _dateRight = toDate(rightDate);
return +_dateLeft === +_dateRight;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isEqual = ((/* unused pure expression or super */ null && (isEqual)));
;// ./node_modules/date-fns/isSameDay.mjs
/**
* @name isSameDay
* @category Day Helpers
* @summary Are the given dates in the same day (and year and month)?
*
* @description
* Are the given dates in the same day (and year and month)?
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param dateLeft - The first date to check
* @param dateRight - The second date to check
* @returns The dates are in the same day (and year and month)
*
* @example
* // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
* const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
* //=> true
*
* @example
* // Are 4 September and 4 October in the same day?
* const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))
* //=> false
*
* @example
* // Are 4 September, 2014 and 4 September, 2015 in the same day?
* const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4))
* //=> false
*/
function isSameDay(dateLeft, dateRight) {
const dateLeftStartOfDay = startOfDay(dateLeft);
const dateRightStartOfDay = startOfDay(dateRight);
return +dateLeftStartOfDay === +dateRightStartOfDay;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isSameDay = ((/* unused pure expression or super */ null && (isSameDay)));
;// ./node_modules/date-fns/addDays.mjs
/**
* @name addDays
* @category Day Helpers
* @summary Add the specified number of days to the given date.
*
* @description
* Add the specified number of days to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param amount - The amount of days to be added.
*
* @returns The new date with the days added
*
* @example
* // Add 10 days to 1 September 2014:
* const result = addDays(new Date(2014, 8, 1), 10)
* //=> Thu Sep 11 2014 00:00:00
*/
function addDays(date, amount) {
const _date = toDate(date);
if (isNaN(amount)) return constructFrom(date, NaN);
if (!amount) {
// If 0 days, no-op to avoid changing times in the hour before end of DST
return _date;
}
_date.setDate(_date.getDate() + amount);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_addDays = ((/* unused pure expression or super */ null && (addDays)));
;// ./node_modules/date-fns/addWeeks.mjs
/**
* @name addWeeks
* @category Week Helpers
* @summary Add the specified number of weeks to the given date.
*
* @description
* Add the specified number of week to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param amount - The amount of weeks to be added.
*
* @returns The new date with the weeks added
*
* @example
* // Add 4 weeks to 1 September 2014:
* const result = addWeeks(new Date(2014, 8, 1), 4)
* //=> Mon Sep 29 2014 00:00:00
*/
function addWeeks(date, amount) {
const days = amount * 7;
return addDays(date, days);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_addWeeks = ((/* unused pure expression or super */ null && (addWeeks)));
;// ./node_modules/date-fns/subWeeks.mjs
/**
* @name subWeeks
* @category Week Helpers
* @summary Subtract the specified number of weeks from the given date.
*
* @description
* Subtract the specified number of weeks from the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param amount - The amount of weeks to be subtracted.
*
* @returns The new date with the weeks subtracted
*
* @example
* // Subtract 4 weeks from 1 September 2014:
* const result = subWeeks(new Date(2014, 8, 1), 4)
* //=> Mon Aug 04 2014 00:00:00
*/
function subWeeks(date, amount) {
return addWeeks(date, -amount);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_subWeeks = ((/* unused pure expression or super */ null && (subWeeks)));
;// ./node_modules/date-fns/endOfWeek.mjs
/**
* The {@link endOfWeek} function options.
*/
/**
* @name endOfWeek
* @category Week Helpers
* @summary Return the end of a week for the given date.
*
* @description
* Return the end of a week for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
* @param options - An object with options
*
* @returns The end of a week
*
* @example
* // The end of a week for 2 September 2014 11:55:00:
* const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0))
* //=> Sat Sep 06 2014 23:59:59.999
*
* @example
* // If the week starts on Monday, the end of the week for 2 September 2014 11:55:00:
* const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
* //=> Sun Sep 07 2014 23:59:59.999
*/
function endOfWeek(date, options) {
const defaultOptions = getDefaultOptions();
const weekStartsOn =
options?.weekStartsOn ??
options?.locale?.options?.weekStartsOn ??
defaultOptions.weekStartsOn ??
defaultOptions.locale?.options?.weekStartsOn ??
0;
const _date = toDate(date);
const day = _date.getDay();
const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
_date.setDate(_date.getDate() + diff);
_date.setHours(23, 59, 59, 999);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_endOfWeek = ((/* unused pure expression or super */ null && (endOfWeek)));
;// ./node_modules/@wordpress/icons/build-module/library/arrow-right.js
var arrow_right_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "m14.5 6.5-1 1 3.7 3.7H4v1.6h13.2l-3.7 3.7 1 1 5.6-5.5z" }) });
;// ./node_modules/@wordpress/icons/build-module/library/arrow-left.js
var arrow_left_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M20 11.2H6.8l3.7-3.7-1-1L3.9 12l5.6 5.5 1-1-3.7-3.7H20z" }) });
;// external ["wp","date"]
const external_wp_date_namespaceObject = window["wp"]["date"];
;// ./node_modules/date-fns/isAfter.mjs
/**
* @name isAfter
* @category Common Helpers
* @summary Is the first date after the second one?
*
* @description
* Is the first date after the second one?
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date that should be after the other one to return true
* @param dateToCompare - The date to compare with
*
* @returns The first date is after the second date
*
* @example
* // Is 10 July 1989 after 11 February 1987?
* const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
* //=> true
*/
function isAfter(date, dateToCompare) {
const _date = toDate(date);
const _dateToCompare = toDate(dateToCompare);
return _date.getTime() > _dateToCompare.getTime();
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isAfter = ((/* unused pure expression or super */ null && (isAfter)));
;// ./node_modules/date-fns/isBefore.mjs
/**
* @name isBefore
* @category Common Helpers
* @summary Is the first date before the second one?
*
* @description
* Is the first date before the second one?
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date that should be before the other one to return true
* @param dateToCompare - The date to compare with
*
* @returns The first date is before the second date
*
* @example
* // Is 10 July 1989 before 11 February 1987?
* const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
* //=> false
*/
function isBefore(date, dateToCompare) {
const _date = toDate(date);
const _dateToCompare = toDate(dateToCompare);
return +_date < +_dateToCompare;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isBefore = ((/* unused pure expression or super */ null && (isBefore)));
;// ./node_modules/date-fns/getDaysInMonth.mjs
/**
* @name getDaysInMonth
* @category Month Helpers
* @summary Get the number of days in a month of the given date.
*
* @description
* Get the number of days in a month of the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The given date
*
* @returns The number of days in a month
*
* @example
* // How many days are in February 2000?
* const result = getDaysInMonth(new Date(2000, 1))
* //=> 29
*/
function getDaysInMonth(date) {
const _date = toDate(date);
const year = _date.getFullYear();
const monthIndex = _date.getMonth();
const lastDayOfMonth = constructFrom(date, 0);
lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);
lastDayOfMonth.setHours(0, 0, 0, 0);
return lastDayOfMonth.getDate();
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getDaysInMonth = ((/* unused pure expression or super */ null && (getDaysInMonth)));
;// ./node_modules/date-fns/setMonth.mjs
/**
* @name setMonth
* @category Month Helpers
* @summary Set the month to the given date.
*
* @description
* Set the month to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param month - The month index to set (0-11)
*
* @returns The new date with the month set
*
* @example
* // Set February to 1 September 2014:
* const result = setMonth(new Date(2014, 8, 1), 1)
* //=> Sat Feb 01 2014 00:00:00
*/
function setMonth(date, month) {
const _date = toDate(date);
const year = _date.getFullYear();
const day = _date.getDate();
const dateWithDesiredMonth = constructFrom(date, 0);
dateWithDesiredMonth.setFullYear(year, month, 15);
dateWithDesiredMonth.setHours(0, 0, 0, 0);
const daysInMonth = getDaysInMonth(dateWithDesiredMonth);
// Set the last day of the new month
// if the original date was the last day of the longer month
_date.setMonth(month, Math.min(day, daysInMonth));
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_setMonth = ((/* unused pure expression or super */ null && (setMonth)));
;// ./node_modules/date-fns/set.mjs
/**
* @name set
* @category Common Helpers
* @summary Set date values to a given date.
*
* @description
* Set date values to a given date.
*
* Sets time values to date from object `values`.
* A value is not set if it is undefined or null or doesn't exist in `values`.
*
* Note about bundle size: `set` does not internally use `setX` functions from date-fns but instead opts
* to use native `Date#setX` methods. If you use this function, you may not want to include the
* other `setX` functions that date-fns provides if you are concerned about the bundle size.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param values - The date values to be set
*
* @returns The new date with options set
*
* @example
* // Transform 1 September 2014 into 20 October 2015 in a single line:
* const result = set(new Date(2014, 8, 20), { year: 2015, month: 9, date: 20 })
* //=> Tue Oct 20 2015 00:00:00
*
* @example
* // Set 12 PM to 1 September 2014 01:23:45 to 1 September 2014 12:00:00:
* const result = set(new Date(2014, 8, 1, 1, 23, 45), { hours: 12 })
* //=> Mon Sep 01 2014 12:23:45
*/
function set(date, values) {
let _date = toDate(date);
// Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
if (isNaN(+_date)) {
return constructFrom(date, NaN);
}
if (values.year != null) {
_date.setFullYear(values.year);
}
if (values.month != null) {
_date = setMonth(_date, values.month);
}
if (values.date != null) {
_date.setDate(values.date);
}
if (values.hours != null) {
_date.setHours(values.hours);
}
if (values.minutes != null) {
_date.setMinutes(values.minutes);
}
if (values.seconds != null) {
_date.setSeconds(values.seconds);
}
if (values.milliseconds != null) {
_date.setMilliseconds(values.milliseconds);
}
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_set = ((/* unused pure expression or super */ null && (set)));
;// ./node_modules/date-fns/startOfToday.mjs
/**
* @name startOfToday
* @category Day Helpers
* @summary Return the start of today.
* @pure false
*
* @description
* Return the start of today.
*
* @returns The start of today
*
* @example
* // If today is 6 October 2014:
* const result = startOfToday()
* //=> Mon Oct 6 2014 00:00:00
*/
function startOfToday() {
return startOfDay(Date.now());
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfToday = ((/* unused pure expression or super */ null && (startOfToday)));
;// ./node_modules/date-fns/setYear.mjs
/**
* @name setYear
* @category Year Helpers
* @summary Set the year to the given date.
*
* @description
* Set the year to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param year - The year of the new date
*
* @returns The new date with the year set
*
* @example
* // Set year 2013 to 1 September 2014:
* const result = setYear(new Date(2014, 8, 1), 2013)
* //=> Sun Sep 01 2013 00:00:00
*/
function setYear(date, year) {
const _date = toDate(date);
// Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
if (isNaN(+_date)) {
return constructFrom(date, NaN);
}
_date.setFullYear(year);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_setYear = ((/* unused pure expression or super */ null && (setYear)));
;// ./node_modules/date-fns/addYears.mjs
/**
* @name addYears
* @category Year Helpers
* @summary Add the specified number of years to the given date.
*
* @description
* Add the specified number of years to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param amount - The amount of years to be added.
*
* @returns The new date with the years added
*
* @example
* // Add 5 years to 1 September 2014:
* const result = addYears(new Date(2014, 8, 1), 5)
* //=> Sun Sep 01 2019 00:00:00
*/
function addYears(date, amount) {
return addMonths(date, amount * 12);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_addYears = ((/* unused pure expression or super */ null && (addYears)));
;// ./node_modules/date-fns/subYears.mjs
/**
* @name subYears
* @category Year Helpers
* @summary Subtract the specified number of years from the given date.
*
* @description
* Subtract the specified number of years from the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The date to be changed
* @param amount - The amount of years to be subtracted.
*
* @returns The new date with the years subtracted
*
* @example
* // Subtract 5 years from 1 September 2014:
* const result = subYears(new Date(2014, 8, 1), 5)
* //=> Tue Sep 01 2009 00:00:00
*/
function subYears(date, amount) {
return addYears(date, -amount);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_subYears = ((/* unused pure expression or super */ null && (subYears)));
;// ./node_modules/date-fns/eachDayOfInterval.mjs
/**
* The {@link eachDayOfInterval} function options.
*/
/**
* @name eachDayOfInterval
* @category Interval Helpers
* @summary Return the array of dates within the specified time interval.
*
* @description
* Return the array of dates within the specified time interval.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param interval - The interval.
* @param options - An object with options.
*
* @returns The array with starts of days from the day of the interval start to the day of the interval end
*
* @example
* // Each day between 6 October 2014 and 10 October 2014:
* const result = eachDayOfInterval({
* start: new Date(2014, 9, 6),
* end: new Date(2014, 9, 10)
* })
* //=> [
* // Mon Oct 06 2014 00:00:00,
* // Tue Oct 07 2014 00:00:00,
* // Wed Oct 08 2014 00:00:00,
* // Thu Oct 09 2014 00:00:00,
* // Fri Oct 10 2014 00:00:00
* // ]
*/
function eachDayOfInterval(interval, options) {
const startDate = toDate(interval.start);
const endDate = toDate(interval.end);
let reversed = +startDate > +endDate;
const endTime = reversed ? +startDate : +endDate;
const currentDate = reversed ? endDate : startDate;
currentDate.setHours(0, 0, 0, 0);
let step = options?.step ?? 1;
if (!step) return [];
if (step < 0) {
step = -step;
reversed = !reversed;
}
const dates = [];
while (+currentDate <= endTime) {
dates.push(toDate(currentDate));
currentDate.setDate(currentDate.getDate() + step);
currentDate.setHours(0, 0, 0, 0);
}
return reversed ? dates.reverse() : dates;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_eachDayOfInterval = ((/* unused pure expression or super */ null && (eachDayOfInterval)));
;// ./node_modules/date-fns/eachMonthOfInterval.mjs
/**
* The {@link eachMonthOfInterval} function options.
*/
/**
* @name eachMonthOfInterval
* @category Interval Helpers
* @summary Return the array of months within the specified time interval.
*
* @description
* Return the array of months within the specified time interval.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param interval - The interval
*
* @returns The array with starts of months from the month of the interval start to the month of the interval end
*
* @example
* // Each month between 6 February 2014 and 10 August 2014:
* const result = eachMonthOfInterval({
* start: new Date(2014, 1, 6),
* end: new Date(2014, 7, 10)
* })
* //=> [
* // Sat Feb 01 2014 00:00:00,
* // Sat Mar 01 2014 00:00:00,
* // Tue Apr 01 2014 00:00:00,
* // Thu May 01 2014 00:00:00,
* // Sun Jun 01 2014 00:00:00,
* // Tue Jul 01 2014 00:00:00,
* // Fri Aug 01 2014 00:00:00
* // ]
*/
function eachMonthOfInterval(interval, options) {
const startDate = toDate(interval.start);
const endDate = toDate(interval.end);
let reversed = +startDate > +endDate;
const endTime = reversed ? +startDate : +endDate;
const currentDate = reversed ? endDate : startDate;
currentDate.setHours(0, 0, 0, 0);
currentDate.setDate(1);
let step = options?.step ?? 1;
if (!step) return [];
if (step < 0) {
step = -step;
reversed = !reversed;
}
const dates = [];
while (+currentDate <= endTime) {
dates.push(toDate(currentDate));
currentDate.setMonth(currentDate.getMonth() + step);
}
return reversed ? dates.reverse() : dates;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_eachMonthOfInterval = ((/* unused pure expression or super */ null && (eachMonthOfInterval)));
;// ./node_modules/date-fns/startOfMonth.mjs
/**
* @name startOfMonth
* @category Month Helpers
* @summary Return the start of a month for the given date.
*
* @description
* Return the start of a month for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
*
* @returns The start of a month
*
* @example
* // The start of a month for 2 September 2014 11:55:00:
* const result = startOfMonth(new Date(2014, 8, 2, 11, 55, 0))
* //=> Mon Sep 01 2014 00:00:00
*/
function startOfMonth(date) {
const _date = toDate(date);
_date.setDate(1);
_date.setHours(0, 0, 0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfMonth = ((/* unused pure expression or super */ null && (startOfMonth)));
;// ./node_modules/date-fns/endOfMonth.mjs
/**
* @name endOfMonth
* @category Month Helpers
* @summary Return the end of a month for the given date.
*
* @description
* Return the end of a month for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
*
* @returns The end of a month
*
* @example
* // The end of a month for 2 September 2014 11:55:00:
* const result = endOfMonth(new Date(2014, 8, 2, 11, 55, 0))
* //=> Tue Sep 30 2014 23:59:59.999
*/
function endOfMonth(date) {
const _date = toDate(date);
const month = _date.getMonth();
_date.setFullYear(_date.getFullYear(), month + 1, 0);
_date.setHours(23, 59, 59, 999);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_endOfMonth = ((/* unused pure expression or super */ null && (endOfMonth)));
;// ./node_modules/date-fns/eachWeekOfInterval.mjs
/**
* The {@link eachWeekOfInterval} function options.
*/
/**
* @name eachWeekOfInterval
* @category Interval Helpers
* @summary Return the array of weeks within the specified time interval.
*
* @description
* Return the array of weeks within the specified time interval.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param interval - The interval.
* @param options - An object with options.
*
* @returns The array with starts of weeks from the week of the interval start to the week of the interval end
*
* @example
* // Each week within interval 6 October 2014 - 23 November 2014:
* const result = eachWeekOfInterval({
* start: new Date(2014, 9, 6),
* end: new Date(2014, 10, 23)
* })
* //=> [
* // Sun Oct 05 2014 00:00:00,
* // Sun Oct 12 2014 00:00:00,
* // Sun Oct 19 2014 00:00:00,
* // Sun Oct 26 2014 00:00:00,
* // Sun Nov 02 2014 00:00:00,
* // Sun Nov 09 2014 00:00:00,
* // Sun Nov 16 2014 00:00:00,
* // Sun Nov 23 2014 00:00:00
* // ]
*/
function eachWeekOfInterval(interval, options) {
const startDate = toDate(interval.start);
const endDate = toDate(interval.end);
let reversed = +startDate > +endDate;
const startDateWeek = reversed
? startOfWeek(endDate, options)
: startOfWeek(startDate, options);
const endDateWeek = reversed
? startOfWeek(startDate, options)
: startOfWeek(endDate, options);
// Some timezones switch DST at midnight, making start of day unreliable in these timezones, 3pm is a safe bet
startDateWeek.setHours(15);
endDateWeek.setHours(15);
const endTime = +endDateWeek.getTime();
let currentDate = startDateWeek;
let step = options?.step ?? 1;
if (!step) return [];
if (step < 0) {
step = -step;
reversed = !reversed;
}
const dates = [];
while (+currentDate <= endTime) {
currentDate.setHours(0);
dates.push(toDate(currentDate));
currentDate = addWeeks(currentDate, step);
currentDate.setHours(15);
}
return reversed ? dates.reverse() : dates;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_eachWeekOfInterval = ((/* unused pure expression or super */ null && (eachWeekOfInterval)));
;// ./node_modules/@wordpress/components/build-module/date-time/date/use-lilius/index.js
let Month = /* @__PURE__ */ (function(Month2) {
Month2[Month2["JANUARY"] = 0] = "JANUARY";
Month2[Month2["FEBRUARY"] = 1] = "FEBRUARY";
Month2[Month2["MARCH"] = 2] = "MARCH";
Month2[Month2["APRIL"] = 3] = "APRIL";
Month2[Month2["MAY"] = 4] = "MAY";
Month2[Month2["JUNE"] = 5] = "JUNE";
Month2[Month2["JULY"] = 6] = "JULY";
Month2[Month2["AUGUST"] = 7] = "AUGUST";
Month2[Month2["SEPTEMBER"] = 8] = "SEPTEMBER";
Month2[Month2["OCTOBER"] = 9] = "OCTOBER";
Month2[Month2["NOVEMBER"] = 10] = "NOVEMBER";
Month2[Month2["DECEMBER"] = 11] = "DECEMBER";
return Month2;
})({});
let Day = /* @__PURE__ */ (function(Day2) {
Day2[Day2["SUNDAY"] = 0] = "SUNDAY";
Day2[Day2["MONDAY"] = 1] = "MONDAY";
Day2[Day2["TUESDAY"] = 2] = "TUESDAY";
Day2[Day2["WEDNESDAY"] = 3] = "WEDNESDAY";
Day2[Day2["THURSDAY"] = 4] = "THURSDAY";
Day2[Day2["FRIDAY"] = 5] = "FRIDAY";
Day2[Day2["SATURDAY"] = 6] = "SATURDAY";
return Day2;
})({});
const inRange = (date, min, max) => (isEqual(date, min) || isAfter(date, min)) && (isEqual(date, max) || isBefore(date, max));
const use_lilius_clearTime = (date) => set(date, {
hours: 0,
minutes: 0,
seconds: 0,
milliseconds: 0
});
const useLilius = ({
weekStartsOn = Day.SUNDAY,
viewing: initialViewing = /* @__PURE__ */ new Date(),
selected: initialSelected = [],
numberOfMonths = 1
} = {}) => {
const [viewing, setViewing] = (0,external_wp_element_namespaceObject.useState)(initialViewing);
const viewToday = (0,external_wp_element_namespaceObject.useCallback)(() => setViewing(startOfToday()), [setViewing]);
const viewMonth = (0,external_wp_element_namespaceObject.useCallback)((month) => setViewing((v) => setMonth(v, month)), []);
const viewPreviousMonth = (0,external_wp_element_namespaceObject.useCallback)(() => setViewing((v) => subMonths(v, 1)), []);
const viewNextMonth = (0,external_wp_element_namespaceObject.useCallback)(() => setViewing((v) => addMonths(v, 1)), []);
const viewYear = (0,external_wp_element_namespaceObject.useCallback)((year) => setViewing((v) => setYear(v, year)), []);
const viewPreviousYear = (0,external_wp_element_namespaceObject.useCallback)(() => setViewing((v) => subYears(v, 1)), []);
const viewNextYear = (0,external_wp_element_namespaceObject.useCallback)(() => setViewing((v) => addYears(v, 1)), []);
const [selected, setSelected] = (0,external_wp_element_namespaceObject.useState)(initialSelected.map(use_lilius_clearTime));
const clearSelected = () => setSelected([]);
const isSelected = (0,external_wp_element_namespaceObject.useCallback)((date) => selected.findIndex((s) => isEqual(s, date)) > -1, [selected]);
const select = (0,external_wp_element_namespaceObject.useCallback)((date, replaceExisting) => {
if (replaceExisting) {
setSelected(Array.isArray(date) ? date : [date]);
} else {
setSelected((selectedItems) => selectedItems.concat(Array.isArray(date) ? date : [date]));
}
}, []);
const deselect = (0,external_wp_element_namespaceObject.useCallback)((date) => setSelected((selectedItems) => Array.isArray(date) ? selectedItems.filter((s) => !date.map((d) => d.getTime()).includes(s.getTime())) : selectedItems.filter((s) => !isEqual(s, date))), []);
const toggle = (0,external_wp_element_namespaceObject.useCallback)((date, replaceExisting) => isSelected(date) ? deselect(date) : select(date, replaceExisting), [deselect, isSelected, select]);
const selectRange = (0,external_wp_element_namespaceObject.useCallback)((start, end, replaceExisting) => {
if (replaceExisting) {
setSelected(eachDayOfInterval({
start,
end
}));
} else {
setSelected((selectedItems) => selectedItems.concat(eachDayOfInterval({
start,
end
})));
}
}, []);
const deselectRange = (0,external_wp_element_namespaceObject.useCallback)((start, end) => {
setSelected((selectedItems) => selectedItems.filter((s) => !eachDayOfInterval({
start,
end
}).map((d) => d.getTime()).includes(s.getTime())));
}, []);
const calendar = (0,external_wp_element_namespaceObject.useMemo)(() => eachMonthOfInterval({
start: startOfMonth(viewing),
end: endOfMonth(addMonths(viewing, numberOfMonths - 1))
}).map((month) => eachWeekOfInterval({
start: startOfMonth(month),
end: endOfMonth(month)
}, {
weekStartsOn
}).map((week) => eachDayOfInterval({
start: startOfWeek(week, {
weekStartsOn
}),
end: endOfWeek(week, {
weekStartsOn
})
}))), [viewing, weekStartsOn, numberOfMonths]);
return {
clearTime: use_lilius_clearTime,
inRange,
viewing,
setViewing,
viewToday,
viewMonth,
viewPreviousMonth,
viewNextMonth,
viewYear,
viewPreviousYear,
viewNextYear,
selected,
setSelected,
clearSelected,
isSelected,
select,
deselect,
toggle,
selectRange,
deselectRange,
calendar
};
};
;// ./node_modules/@wordpress/components/build-module/date-time/date/styles.js
function date_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const styles_Wrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e105ri6r7"
} : 0)(boxSizingReset, ";" + ( true ? "" : 0));
const Navigator = /* @__PURE__ */ emotion_styled_base_browser_esm(h_stack_component_component_default, true ? {
target: "e105ri6r6"
} : 0)("column-gap:", space(2), ";display:grid;grid-template-columns:0.5fr repeat( 5, 1fr ) 0.5fr;justify-items:center;margin-bottom:", space(4), ";" + ( true ? "" : 0));
const ViewPreviousMonthButton = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "e105ri6r5"
} : 0)( true ? {
name: "sarfoe",
styles: "grid-column:1/2"
} : 0);
const ViewNextMonthButton = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "e105ri6r4"
} : 0)( true ? {
name: "1v98r3z",
styles: "grid-column:7/8"
} : 0);
const NavigatorHeading = /* @__PURE__ */ emotion_styled_base_browser_esm(heading_component_component_default, true ? {
target: "e105ri6r3"
} : 0)("font-size:", config_values_default.fontSize, ";font-weight:", config_values_default.fontWeight, ";grid-column:2/7;strong{font-weight:", config_values_default.fontWeightHeading, ";}" + ( true ? "" : 0));
const Calendar = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e105ri6r2"
} : 0)("column-gap:", space(2), ";display:grid;grid-template-columns:0.5fr repeat( 5, 1fr ) 0.5fr;justify-items:center;row-gap:", space(2), ";" + ( true ? "" : 0));
const DayOfWeek = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e105ri6r1"
} : 0)("color:", COLORS.theme.gray[700], ";font-size:", config_values_default.fontSize, ";line-height:", config_values_default.fontLineHeightBase, ";" + ( true ? "" : 0));
const DayButton = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
shouldForwardProp: (prop) => !["column", "isSelected", "isToday", "hasEvents"].includes(prop),
target: "e105ri6r0"
} : 0)("grid-column:", (props) => props.column, ";position:relative;justify-content:center;", (props) => props.disabled && `
pointer-events: none;
`, " &&&{border-radius:", config_values_default.radiusRound, ";height:", space(7), ";width:", space(7), ";", (props) => props.isSelected && `
background: ${COLORS.theme.accent};
&,
&:hover:not(:disabled, [aria-disabled=true]) {
color: ${COLORS.theme.accentInverted};
}
&:focus:not(:disabled),
&:focus:not(:disabled) {
border: ${config_values_default.borderWidthFocus} solid currentColor;
}
/* Highlight the selected day for high-contrast mode */
&::after {
content: '';
position: absolute;
pointer-events: none;
inset: 0;
border-radius: inherit;
border: 1px solid transparent;
}
`, " ", (props) => !props.isSelected && props.isToday && `
background: ${COLORS.theme.gray[200]};
`, ";}", (props) => props.hasEvents && `
::before {
border: 2px solid ${props.isSelected ? COLORS.theme.accentInverted : COLORS.theme.accent};
border-radius: ${config_values_default.radiusRound};
content: " ";
left: 50%;
position: absolute;
transform: translate(-50%, 9px);
}
`, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/date-time/utils.js
function inputToDate(input) {
if (typeof input === "string") {
return new Date(input);
}
return toDate(input);
}
function from12hTo24h(hours, isPm) {
return isPm ? (hours % 12 + 12) % 24 : hours % 12;
}
function from24hTo12h(hours) {
return hours % 12 || 12;
}
function buildPadInputStateReducer(pad) {
return (state, action) => {
const nextState = {
...state
};
if (action.type === COMMIT || action.type === PRESS_UP || action.type === PRESS_DOWN) {
if (nextState.value !== void 0) {
nextState.value = nextState.value.toString().padStart(pad, "0");
}
}
return nextState;
};
}
function validateInputElementTarget(event) {
var _ownerDocument$defaul;
const HTMLInputElementInstance = (_ownerDocument$defaul = event.target?.ownerDocument.defaultView?.HTMLInputElement) !== null && _ownerDocument$defaul !== void 0 ? _ownerDocument$defaul : HTMLInputElement;
if (!(event.target instanceof HTMLInputElementInstance)) {
return false;
}
return event.target.validity.valid;
}
;// ./node_modules/@wordpress/components/build-module/date-time/constants.js
const TIMEZONELESS_FORMAT = "yyyy-MM-dd'T'HH:mm:ss";
;// ./node_modules/@wordpress/components/build-module/date-time/date/index.js
function DatePicker({
currentDate,
onChange,
events = [],
isInvalidDate,
onMonthPreviewed,
startOfWeek: weekStartsOn = 0
}) {
const date = currentDate ? inputToDate(currentDate) : /* @__PURE__ */ new Date();
const {
calendar,
viewing,
setSelected,
setViewing,
isSelected,
viewPreviousMonth,
viewNextMonth
} = useLilius({
selected: [startOfDay(date)],
viewing: startOfDay(date),
weekStartsOn
});
const [focusable, setFocusable] = (0,external_wp_element_namespaceObject.useState)(startOfDay(date));
const [isFocusWithinCalendar, setIsFocusWithinCalendar] = (0,external_wp_element_namespaceObject.useState)(false);
const [prevCurrentDate, setPrevCurrentDate] = (0,external_wp_element_namespaceObject.useState)(currentDate);
if (currentDate !== prevCurrentDate) {
setPrevCurrentDate(currentDate);
setSelected([startOfDay(date)]);
setViewing(startOfDay(date));
setFocusable(startOfDay(date));
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(styles_Wrapper, {
className: "components-datetime__date",
role: "application",
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Calendar"),
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Navigator, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ViewPreviousMonthButton, {
icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? arrow_right_default : arrow_left_default,
variant: "tertiary",
"aria-label": (0,external_wp_i18n_namespaceObject.__)("View previous month"),
onClick: () => {
viewPreviousMonth();
setFocusable(subMonths(focusable, 1));
onMonthPreviewed?.(format(subMonths(viewing, 1), TIMEZONELESS_FORMAT));
},
size: "compact"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(NavigatorHeading, {
level: 3,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("strong", {
children: (0,external_wp_date_namespaceObject.dateI18n)("F", viewing, -viewing.getTimezoneOffset())
}), " ", (0,external_wp_date_namespaceObject.dateI18n)("Y", viewing, -viewing.getTimezoneOffset())]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ViewNextMonthButton, {
icon: (0,external_wp_i18n_namespaceObject.isRTL)() ? arrow_left_default : arrow_right_default,
variant: "tertiary",
"aria-label": (0,external_wp_i18n_namespaceObject.__)("View next month"),
onClick: () => {
viewNextMonth();
setFocusable(addMonths(focusable, 1));
onMonthPreviewed?.(format(addMonths(viewing, 1), TIMEZONELESS_FORMAT));
},
size: "compact"
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Calendar, {
onFocus: () => setIsFocusWithinCalendar(true),
onBlur: () => setIsFocusWithinCalendar(false),
children: [calendar[0][0].map((day) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DayOfWeek, {
children: (0,external_wp_date_namespaceObject.dateI18n)("D", day, -day.getTimezoneOffset())
}, day.toString())), calendar[0].map((week) => week.map((day, index) => {
if (!isSameMonth(day, viewing)) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(date_Day, {
day,
column: index + 1,
isSelected: isSelected(day),
isFocusable: isEqual(day, focusable),
isFocusAllowed: isFocusWithinCalendar,
isToday: isSameDay(day, /* @__PURE__ */ new Date()),
isInvalid: isInvalidDate ? isInvalidDate(day) : false,
numEvents: events.filter((event) => isSameDay(event.date, day)).length,
onClick: () => {
setSelected([day]);
setFocusable(day);
onChange?.(format(
// Don't change the selected date's time fields.
new Date(day.getFullYear(), day.getMonth(), day.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()),
TIMEZONELESS_FORMAT
));
},
onKeyDown: (event) => {
let nextFocusable;
if (event.key === "ArrowLeft") {
nextFocusable = addDays(day, (0,external_wp_i18n_namespaceObject.isRTL)() ? 1 : -1);
}
if (event.key === "ArrowRight") {
nextFocusable = addDays(day, (0,external_wp_i18n_namespaceObject.isRTL)() ? -1 : 1);
}
if (event.key === "ArrowUp") {
nextFocusable = subWeeks(day, 1);
}
if (event.key === "ArrowDown") {
nextFocusable = addWeeks(day, 1);
}
if (event.key === "PageUp") {
nextFocusable = subMonths(day, 1);
}
if (event.key === "PageDown") {
nextFocusable = addMonths(day, 1);
}
if (event.key === "Home") {
nextFocusable = startOfWeek(day);
}
if (event.key === "End") {
nextFocusable = startOfDay(endOfWeek(day));
}
if (nextFocusable) {
event.preventDefault();
setFocusable(nextFocusable);
if (!isSameMonth(nextFocusable, viewing)) {
setViewing(nextFocusable);
onMonthPreviewed?.(format(nextFocusable, TIMEZONELESS_FORMAT));
}
}
}
}, day.toString());
}))]
})]
});
}
function date_Day({
day,
column,
isSelected,
isFocusable,
isFocusAllowed,
isToday,
isInvalid,
numEvents,
onClick,
onKeyDown
}) {
const ref = (0,external_wp_element_namespaceObject.useRef)();
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (ref.current && isFocusable && isFocusAllowed) {
ref.current.focus();
}
}, [isFocusable]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DayButton, {
__next40pxDefaultSize: true,
ref,
className: "components-datetime__date__day",
disabled: isInvalid,
tabIndex: isFocusable ? 0 : -1,
"aria-label": getDayLabel(day, isSelected, numEvents),
column,
isSelected,
isToday,
hasEvents: numEvents > 0,
onClick,
onKeyDown,
children: (0,external_wp_date_namespaceObject.dateI18n)("j", day, -day.getTimezoneOffset())
});
}
function getDayLabel(date, isSelected, numEvents) {
const {
formats
} = (0,external_wp_date_namespaceObject.getSettings)();
const localizedDate = (0,external_wp_date_namespaceObject.dateI18n)(formats.date, date, -date.getTimezoneOffset());
if (isSelected && numEvents > 0) {
return (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The calendar date. 2: Number of events on the calendar date.
(0,external_wp_i18n_namespaceObject._n)("%1$s. Selected. There is %2$d event", "%1$s. Selected. There are %2$d events", numEvents),
localizedDate,
numEvents
);
} else if (isSelected) {
return (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The calendar date.
(0,external_wp_i18n_namespaceObject.__)("%1$s. Selected"),
localizedDate
);
} else if (numEvents > 0) {
return (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: 1: The calendar date. 2: Number of events on the calendar date.
(0,external_wp_i18n_namespaceObject._n)("%1$s. There is %2$d event", "%1$s. There are %2$d events", numEvents),
localizedDate,
numEvents
);
}
return localizedDate;
}
var date_default = DatePicker;
;// ./node_modules/date-fns/startOfMinute.mjs
/**
* @name startOfMinute
* @category Minute Helpers
* @summary Return the start of a minute for the given date.
*
* @description
* Return the start of a minute for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The original date
*
* @returns The start of a minute
*
* @example
* // The start of a minute for 1 December 2014 22:15:45.400:
* const result = startOfMinute(new Date(2014, 11, 1, 22, 15, 45, 400))
* //=> Mon Dec 01 2014 22:15:00
*/
function startOfMinute(date) {
const _date = toDate(date);
_date.setSeconds(0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_startOfMinute = ((/* unused pure expression or super */ null && (startOfMinute)));
;// ./node_modules/@wordpress/components/build-module/date-time/time/styles.js
function time_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const time_styles_Wrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "evcr2319"
} : 0)("box-sizing:border-box;font-size:", config_values_default.fontSize, ";" + ( true ? "" : 0));
const Fieldset = /* @__PURE__ */ emotion_styled_base_browser_esm("fieldset", true ? {
target: "evcr2318"
} : 0)("border:0;margin:0 0 ", space(2 * 2), " 0;padding:0;&:last-child{margin-bottom:0;}" + ( true ? "" : 0));
const TimeWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "evcr2317"
} : 0)( true ? {
name: "pd0mhc",
styles: "direction:ltr;display:flex"
} : 0);
const baseInput = /* @__PURE__ */ emotion_react_browser_esm_css("&&& ", Input, "{padding-left:", space(2), ";padding-right:", space(2), ";text-align:center;}" + ( true ? "" : 0), true ? "" : 0);
const HoursInput = /* @__PURE__ */ emotion_styled_base_browser_esm(number_control_default, true ? {
target: "evcr2316"
} : 0)(baseInput, " width:", space(9), ";&&& ", Input, "{padding-right:0;}&&& ", BackdropUI, "{border-right:0;border-top-right-radius:0;border-bottom-right-radius:0;}" + ( true ? "" : 0));
const TimeSeparator = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "evcr2315"
} : 0)("border-top:", config_values_default.borderWidth, " solid ", COLORS.gray[700], ";border-bottom:", config_values_default.borderWidth, " solid ", COLORS.gray[700], ";font-size:", config_values_default.fontSize, ";line-height:calc(\n ", config_values_default.controlHeight, " - ", config_values_default.borderWidth, " * 2\n );display:inline-block;" + ( true ? "" : 0));
const MinutesInput = /* @__PURE__ */ emotion_styled_base_browser_esm(number_control_default, true ? {
target: "evcr2314"
} : 0)(baseInput, " width:", space(9), ";&&& ", Input, "{padding-left:0;}&&& ", BackdropUI, "{border-left:0;border-top-left-radius:0;border-bottom-left-radius:0;}" + ( true ? "" : 0));
const MonthSelectWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "evcr2313"
} : 0)( true ? {
name: "1ff36h2",
styles: "flex-grow:1"
} : 0);
const DayInput = /* @__PURE__ */ emotion_styled_base_browser_esm(number_control_default, true ? {
target: "evcr2312"
} : 0)(baseInput, " width:", space(9), ";" + ( true ? "" : 0));
const YearInput = /* @__PURE__ */ emotion_styled_base_browser_esm(number_control_default, true ? {
target: "evcr2311"
} : 0)(baseInput, " width:", space(14), ";" + ( true ? "" : 0));
const TimeZone = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "evcr2310"
} : 0)( true ? {
name: "ebu3jh",
styles: "text-decoration:underline dotted"
} : 0);
;// ./node_modules/@wordpress/components/build-module/date-time/time/timezone.js
const timezone_TimeZone = () => {
const {
timezone
} = (0,external_wp_date_namespaceObject.getSettings)();
const userTimezoneOffset = -1 * ((/* @__PURE__ */ new Date()).getTimezoneOffset() / 60);
if (Number(timezone.offset) === userTimezoneOffset) {
return null;
}
const offsetSymbol = Number(timezone.offset) >= 0 ? "+" : "";
const zoneAbbr = "" !== timezone.abbr && isNaN(Number(timezone.abbr)) ? timezone.abbr : `UTC${offsetSymbol}${timezone.offsetFormatted}`;
const prettyTimezoneString = timezone.string.replace("_", " ");
const timezoneDetail = "UTC" === timezone.string ? (0,external_wp_i18n_namespaceObject.__)("Coordinated Universal Time") : `(${zoneAbbr}) ${prettyTimezoneString}`;
const hasNoAdditionalTimezoneDetail = prettyTimezoneString.trim().length === 0;
return hasNoAdditionalTimezoneDetail ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TimeZone, {
className: "components-datetime__timezone",
children: zoneAbbr
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tooltip_default, {
placement: "top",
text: timezoneDetail,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TimeZone, {
className: "components-datetime__timezone",
children: zoneAbbr
})
});
};
var timezone_default = timezone_TimeZone;
;// ./node_modules/@wordpress/components/build-module/toggle-group-control/toggle-group-control-option/component.js
function UnforwardedToggleGroupControlOption(props, ref) {
const {
label,
...restProps
} = props;
const optionLabel = restProps["aria-label"] || label;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_option_base_component_component_default, {
...restProps,
"aria-label": optionLabel,
ref,
children: label
});
}
const ToggleGroupControlOption = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToggleGroupControlOption);
var toggle_group_control_option_component_component_default = ToggleGroupControlOption;
;// ./node_modules/@wordpress/components/build-module/date-time/time/time-input/index.js
function TimeInput({
value: valueProp,
defaultValue,
is12Hour,
label,
minutesProps,
onChange
}) {
const [value = {
hours: (/* @__PURE__ */ new Date()).getHours(),
minutes: (/* @__PURE__ */ new Date()).getMinutes()
}, setValue] = useControlledValue({
value: valueProp,
onChange,
defaultValue
});
const dayPeriod = parseDayPeriod(value.hours);
const hours12Format = from24hTo12h(value.hours);
const buildNumberControlChangeCallback = (method) => {
return (_value, {
event
}) => {
if (!validateInputElementTarget(event)) {
return;
}
const numberValue = Number(_value);
setValue({
...value,
[method]: method === "hours" && is12Hour ? from12hTo24h(numberValue, dayPeriod === "PM") : numberValue
});
};
};
const buildAmPmChangeCallback = (_value) => {
return () => {
if (dayPeriod === _value) {
return;
}
setValue({
...value,
hours: from12hTo24h(hours12Format, _value === "PM")
});
};
};
function parseDayPeriod(_hours) {
return _hours < 12 ? "AM" : "PM";
}
const Wrapper = label ? Fieldset : external_wp_element_namespaceObject.Fragment;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Wrapper, {
children: [label && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default.VisualLabel, {
as: "legend",
children: label
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
alignment: "left",
expanded: false,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(TimeWrapper, {
className: "components-datetime__time-field components-datetime__time-field-time",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(HoursInput, {
className: "components-datetime__time-field-hours-input",
label: (0,external_wp_i18n_namespaceObject.__)("Hours"),
hideLabelFromVision: true,
__next40pxDefaultSize: true,
value: String(is12Hour ? hours12Format : value.hours).padStart(2, "0"),
step: 1,
min: is12Hour ? 1 : 0,
max: is12Hour ? 12 : 23,
required: true,
spinControls: "none",
isPressEnterToChange: true,
isDragEnabled: false,
isShiftStepEnabled: false,
onChange: buildNumberControlChangeCallback("hours"),
__unstableStateReducer: buildPadInputStateReducer(2)
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TimeSeparator, {
className: "components-datetime__time-separator",
"aria-hidden": "true",
children: ":"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MinutesInput, {
className: dist_clsx(
"components-datetime__time-field-minutes-input",
// Unused, for backwards compatibility.
minutesProps?.className
),
label: (0,external_wp_i18n_namespaceObject.__)("Minutes"),
hideLabelFromVision: true,
__next40pxDefaultSize: true,
value: String(value.minutes).padStart(2, "0"),
step: 1,
min: 0,
max: 59,
required: true,
spinControls: "none",
isPressEnterToChange: true,
isDragEnabled: false,
isShiftStepEnabled: false,
onChange: (...args) => {
buildNumberControlChangeCallback("minutes")(...args);
minutesProps?.onChange?.(...args);
},
__unstableStateReducer: buildPadInputStateReducer(2),
...minutesProps
})]
}), is12Hour && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(toggle_group_control_component_component_default, {
__next40pxDefaultSize: true,
__nextHasNoMarginBottom: true,
isBlock: true,
label: (0,external_wp_i18n_namespaceObject.__)("Select AM or PM"),
hideLabelFromVision: true,
value: dayPeriod,
onChange: (newValue) => {
buildAmPmChangeCallback(newValue)();
},
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_option_component_component_default, {
value: "AM",
label: (0,external_wp_i18n_namespaceObject.__)("AM")
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_option_component_component_default, {
value: "PM",
label: (0,external_wp_i18n_namespaceObject.__)("PM")
})]
})]
})]
});
}
var time_input_default = (/* unused pure expression or super */ null && (TimeInput));
;// ./node_modules/@wordpress/components/build-module/date-time/time/index.js
const VALID_DATE_ORDERS = ["dmy", "mdy", "ymd"];
function TimePicker({
is12Hour,
currentTime,
onChange,
dateOrder: dateOrderProp,
hideLabelFromVision = false
}) {
const [date, setDate] = (0,external_wp_element_namespaceObject.useState)(() => (
// Truncate the date at the minutes, see: #15495.
currentTime ? startOfMinute(inputToDate(currentTime)) : /* @__PURE__ */ new Date()
));
(0,external_wp_element_namespaceObject.useEffect)(() => {
setDate(currentTime ? startOfMinute(inputToDate(currentTime)) : /* @__PURE__ */ new Date());
}, [currentTime]);
const monthOptions = [{
value: "01",
label: (0,external_wp_i18n_namespaceObject.__)("January")
}, {
value: "02",
label: (0,external_wp_i18n_namespaceObject.__)("February")
}, {
value: "03",
label: (0,external_wp_i18n_namespaceObject.__)("March")
}, {
value: "04",
label: (0,external_wp_i18n_namespaceObject.__)("April")
}, {
value: "05",
label: (0,external_wp_i18n_namespaceObject.__)("May")
}, {
value: "06",
label: (0,external_wp_i18n_namespaceObject.__)("June")
}, {
value: "07",
label: (0,external_wp_i18n_namespaceObject.__)("July")
}, {
value: "08",
label: (0,external_wp_i18n_namespaceObject.__)("August")
}, {
value: "09",
label: (0,external_wp_i18n_namespaceObject.__)("September")
}, {
value: "10",
label: (0,external_wp_i18n_namespaceObject.__)("October")
}, {
value: "11",
label: (0,external_wp_i18n_namespaceObject.__)("November")
}, {
value: "12",
label: (0,external_wp_i18n_namespaceObject.__)("December")
}];
const {
day,
month,
year,
minutes,
hours
} = (0,external_wp_element_namespaceObject.useMemo)(() => ({
day: format(date, "dd"),
month: format(date, "MM"),
year: format(date, "yyyy"),
minutes: format(date, "mm"),
hours: format(date, "HH"),
am: format(date, "a")
}), [date]);
const buildNumberControlChangeCallback = (method) => {
const callback = (value, {
event
}) => {
if (!validateInputElementTarget(event)) {
return;
}
const numberValue = Number(value);
const newDate = set(date, {
[method]: numberValue
});
setDate(newDate);
onChange?.(format(newDate, TIMEZONELESS_FORMAT));
};
return callback;
};
const onTimeInputChangeCallback = ({
hours: newHours,
minutes: newMinutes
}) => {
const newDate = set(date, {
hours: newHours,
minutes: newMinutes
});
setDate(newDate);
onChange?.(format(newDate, TIMEZONELESS_FORMAT));
};
const dayField = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DayInput, {
className: "components-datetime__time-field components-datetime__time-field-day",
label: (0,external_wp_i18n_namespaceObject.__)("Day"),
hideLabelFromVision: true,
__next40pxDefaultSize: true,
value: day,
step: 1,
min: 1,
max: 31,
required: true,
spinControls: "none",
isPressEnterToChange: true,
isDragEnabled: false,
isShiftStepEnabled: false,
onChange: buildNumberControlChangeCallback("date")
}, "day");
const monthField = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MonthSelectWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(select_control_default, {
className: "components-datetime__time-field components-datetime__time-field-month",
label: (0,external_wp_i18n_namespaceObject.__)("Month"),
hideLabelFromVision: true,
__next40pxDefaultSize: true,
__nextHasNoMarginBottom: true,
value: month,
options: monthOptions,
onChange: (value) => {
const newDate = setMonth(date, Number(value) - 1);
setDate(newDate);
onChange?.(format(newDate, TIMEZONELESS_FORMAT));
}
})
}, "month");
const yearField = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(YearInput, {
className: "components-datetime__time-field components-datetime__time-field-year",
label: (0,external_wp_i18n_namespaceObject.__)("Year"),
hideLabelFromVision: true,
__next40pxDefaultSize: true,
value: year,
step: 1,
min: 1,
max: 9999,
required: true,
spinControls: "none",
isPressEnterToChange: true,
isDragEnabled: false,
isShiftStepEnabled: false,
onChange: buildNumberControlChangeCallback("year"),
__unstableStateReducer: buildPadInputStateReducer(4)
}, "year");
const defaultDateOrder = is12Hour ? "mdy" : "dmy";
const dateOrder = dateOrderProp && VALID_DATE_ORDERS.includes(dateOrderProp) ? dateOrderProp : defaultDateOrder;
const fields = dateOrder.split("").map((field) => {
switch (field) {
case "d":
return dayField;
case "m":
return monthField;
case "y":
return yearField;
default:
return null;
}
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(time_styles_Wrapper, {
className: "components-datetime__time",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Fieldset, {
children: [hideLabelFromVision ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "legend",
children: (0,external_wp_i18n_namespaceObject.__)("Time")
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default.VisualLabel, {
as: "legend",
className: "components-datetime__time-legend",
children: (0,external_wp_i18n_namespaceObject.__)("Time")
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
className: "components-datetime__time-wrapper",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TimeInput, {
value: {
hours: Number(hours),
minutes: Number(minutes)
},
is12Hour,
onChange: onTimeInputChangeCallback
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(timezone_default, {})]
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Fieldset, {
children: [hideLabelFromVision ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "legend",
children: (0,external_wp_i18n_namespaceObject.__)("Date")
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default.VisualLabel, {
as: "legend",
className: "components-datetime__time-legend",
children: (0,external_wp_i18n_namespaceObject.__)("Date")
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(h_stack_component_component_default, {
className: "components-datetime__time-wrapper",
children: fields
})]
})]
});
}
TimePicker.TimeInput = TimeInput;
Object.assign(TimePicker.TimeInput, {
displayName: "TimePicker.TimeInput"
});
var time_default = TimePicker;
;// ./node_modules/@wordpress/components/build-module/date-time/date-time/styles.js
function date_time_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const date_time_styles_Wrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(v_stack_component_component_default, true ? {
target: "e1p5onf00"
} : 0)( true ? {
name: "1khn195",
styles: "box-sizing:border-box"
} : 0);
;// ./node_modules/@wordpress/components/build-module/date-time/date-time/index.js
const date_time_noop = () => {
};
function UnforwardedDateTimePicker({
currentDate,
is12Hour,
dateOrder,
isInvalidDate,
onMonthPreviewed = date_time_noop,
onChange,
events,
startOfWeek
}, ref) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(date_time_styles_Wrapper, {
ref,
className: "components-datetime",
spacing: 4,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(time_default, {
currentTime: currentDate,
onChange,
is12Hour,
dateOrder
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(date_default, {
currentDate,
onChange,
isInvalidDate,
events,
onMonthPreviewed,
startOfWeek
})]
})
});
}
const DateTimePicker = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedDateTimePicker);
var date_time_default = DateTimePicker;
;// ./node_modules/@wordpress/components/build-module/date-time/index.js
var date_time_date_time_default = date_time_default;
;// ./node_modules/@wordpress/components/build-module/dimension-control/sizes.js
const findSizeBySlug = (sizes, slug) => sizes.find((size) => slug === size.slug);
var sizes_default = [{
name: (0,external_wp_i18n_namespaceObject._x)("None", "Size of a UI element"),
slug: "none"
}, {
name: (0,external_wp_i18n_namespaceObject._x)("Small", "Size of a UI element"),
slug: "small"
}, {
name: (0,external_wp_i18n_namespaceObject._x)("Medium", "Size of a UI element"),
slug: "medium"
}, {
name: (0,external_wp_i18n_namespaceObject._x)("Large", "Size of a UI element"),
slug: "large"
}, {
name: (0,external_wp_i18n_namespaceObject._x)("Extra Large", "Size of a UI element"),
slug: "xlarge"
}];
;// ./node_modules/@wordpress/components/build-module/dimension-control/index.js
const dimension_control_CONTEXT_VALUE = {
BaseControl: {
// Temporary during deprecation grace period: Overrides the underlying `__associatedWPComponentName`
// via the context system to override the value set by SelectControl.
_overrides: {
__associatedWPComponentName: "DimensionControl"
}
}
};
function DimensionControl(props) {
const {
__next40pxDefaultSize = false,
__nextHasNoMarginBottom = false,
label,
value,
sizes = sizes_default,
icon,
onChange,
className = ""
} = props;
external_wp_deprecated_default()("wp.components.DimensionControl", {
since: "6.7",
version: "7.0"
});
maybeWarnDeprecated36pxSize({
componentName: "DimensionControl",
__next40pxDefaultSize,
size: void 0
});
const onChangeSpacingSize = (val) => {
const theSize = findSizeBySlug(sizes, val);
if (!theSize || value === theSize.slug) {
onChange?.(void 0);
} else if (typeof onChange === "function") {
onChange(theSize.slug);
}
};
const formatSizesAsOptions = (theSizes) => {
const options = theSizes.map(({
name,
slug
}) => ({
label: name,
value: slug
}));
return [{
label: (0,external_wp_i18n_namespaceObject.__)("Default"),
value: ""
}, ...options];
};
const selectLabel = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [icon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon
}), label]
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ContextSystemProvider, {
value: dimension_control_CONTEXT_VALUE,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(select_control_default, {
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true,
__nextHasNoMarginBottom,
className: dist_clsx(className, "block-editor-dimension-control"),
label: selectLabel,
hideLabelFromVision: false,
value,
onChange: onChangeSpacingSize,
options: formatSizesAsOptions(sizes)
})
});
}
var dimension_control_default = DimensionControl;
;// ./node_modules/@wordpress/components/build-module/disabled/styles/disabled-styles.js
function disabled_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const disabled_styles_disabledStyles = true ? {
name: "u2jump",
styles: "position:relative;pointer-events:none;&::after{content:'';position:absolute;top:0;right:0;bottom:0;left:0;}*{pointer-events:none;}"
} : 0;
;// ./node_modules/@wordpress/components/build-module/disabled/index.js
const Context = (0,external_wp_element_namespaceObject.createContext)(false);
Context.displayName = "DisabledContext";
const {
Consumer,
Provider: disabled_Provider
} = Context;
function Disabled({
className,
children,
isDisabled = true,
...props
}) {
const cx = useCx();
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(disabled_Provider, {
value: isDisabled,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
// @ts-ignore Reason: inert is a recent HTML attribute
inert: isDisabled ? "true" : void 0,
className: isDisabled ? cx(disabled_styles_disabledStyles, className, "components-disabled") : void 0,
...props,
children
})
});
}
Disabled.Context = Context;
Disabled.Consumer = Consumer;
var disabled_default = Disabled;
;// ./node_modules/@wordpress/components/build-module/disclosure/index.js
const UnforwardedDisclosureContent = ({
visible,
children,
...props
}, ref) => {
const disclosure = useDisclosureStore({
open: visible
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DisclosureContent, {
store: disclosure,
ref,
...props,
children
});
};
const disclosure_DisclosureContent = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedDisclosureContent);
var disclosure_default = (/* unused pure expression or super */ null && (disclosure_DisclosureContent));
;// ./node_modules/@wordpress/components/build-module/draggable/index.js
const dragImageClass = "components-draggable__invisible-drag-image";
const cloneWrapperClass = "components-draggable__clone";
const clonePadding = 0;
const bodyClass = "is-dragging-components-draggable";
function Draggable({
children,
onDragStart,
onDragOver,
onDragEnd,
appendToOwnerDocument = false,
cloneClassname,
elementId,
transferData,
__experimentalTransferDataType: transferDataType = "text",
__experimentalDragComponent: dragComponent
}) {
const dragComponentRef = (0,external_wp_element_namespaceObject.useRef)(null);
const cleanupRef = (0,external_wp_element_namespaceObject.useRef)(() => {
});
function end(event) {
event.preventDefault();
cleanupRef.current();
if (onDragEnd) {
onDragEnd(event);
}
}
function start(event) {
const {
ownerDocument
} = event.target;
event.dataTransfer.setData(transferDataType, JSON.stringify(transferData));
const cloneWrapper = ownerDocument.createElement("div");
cloneWrapper.style.top = "0";
cloneWrapper.style.left = "0";
const dragImage = ownerDocument.createElement("div");
if ("function" === typeof event.dataTransfer.setDragImage) {
dragImage.classList.add(dragImageClass);
ownerDocument.body.appendChild(dragImage);
event.dataTransfer.setDragImage(dragImage, 0, 0);
}
cloneWrapper.classList.add(cloneWrapperClass);
if (cloneClassname) {
cloneWrapper.classList.add(cloneClassname);
}
let x = 0;
let y = 0;
if (dragComponentRef.current) {
x = event.clientX;
y = event.clientY;
cloneWrapper.style.transform = `translate( ${x}px, ${y}px )`;
const clonedDragComponent = ownerDocument.createElement("div");
clonedDragComponent.innerHTML = dragComponentRef.current.innerHTML;
cloneWrapper.appendChild(clonedDragComponent);
ownerDocument.body.appendChild(cloneWrapper);
} else {
const element = ownerDocument.getElementById(elementId);
const elementRect = element.getBoundingClientRect();
const elementWrapper = element.parentNode;
const elementTopOffset = elementRect.top;
const elementLeftOffset = elementRect.left;
cloneWrapper.style.width = `${elementRect.width + clonePadding * 2}px`;
const clone = element.cloneNode(true);
clone.id = `clone-${elementId}`;
x = elementLeftOffset - clonePadding;
y = elementTopOffset - clonePadding;
cloneWrapper.style.transform = `translate( ${x}px, ${y}px )`;
Array.from(clone.querySelectorAll("iframe")).forEach((child) => child.parentNode?.removeChild(child));
cloneWrapper.appendChild(clone);
if (appendToOwnerDocument) {
ownerDocument.body.appendChild(cloneWrapper);
} else {
elementWrapper?.appendChild(cloneWrapper);
}
}
let cursorLeft = event.clientX;
let cursorTop = event.clientY;
function over(e) {
if (cursorLeft === e.clientX && cursorTop === e.clientY) {
return;
}
const nextX = x + e.clientX - cursorLeft;
const nextY = y + e.clientY - cursorTop;
cloneWrapper.style.transform = `translate( ${nextX}px, ${nextY}px )`;
cursorLeft = e.clientX;
cursorTop = e.clientY;
x = nextX;
y = nextY;
if (onDragOver) {
onDragOver(e);
}
}
const throttledDragOver = (0,external_wp_compose_namespaceObject.throttle)(over, 16);
ownerDocument.addEventListener("dragover", throttledDragOver);
ownerDocument.body.classList.add(bodyClass);
if (onDragStart) {
onDragStart(event);
}
cleanupRef.current = () => {
if (cloneWrapper && cloneWrapper.parentNode) {
cloneWrapper.parentNode.removeChild(cloneWrapper);
}
if (dragImage && dragImage.parentNode) {
dragImage.parentNode.removeChild(dragImage);
}
ownerDocument.body.classList.remove(bodyClass);
ownerDocument.removeEventListener("dragover", throttledDragOver);
};
}
(0,external_wp_element_namespaceObject.useEffect)(() => () => {
cleanupRef.current();
}, []);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [children({
onDraggableStart: start,
onDraggableEnd: end
}), dragComponent && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-draggable-drag-component-root",
style: {
display: "none"
},
ref: dragComponentRef,
children: dragComponent
})]
});
}
var draggable_default = Draggable;
;// ./node_modules/@wordpress/icons/build-module/library/upload.js
var upload_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M18.5 15v3.5H13V6.7l4.5 4.1 1-1.1-6.2-5.8-5.8 5.8 1 1.1 4-4v11.7h-6V15H4v5h16v-5z" }) });
;// ./node_modules/@wordpress/components/build-module/drop-zone/index.js
function DropZoneComponent({
className,
icon = upload_default,
label,
onFilesDrop,
onHTMLDrop,
onDrop,
isEligible = () => true,
...restProps
}) {
const [isDraggingOverDocument, setIsDraggingOverDocument] = (0,external_wp_element_namespaceObject.useState)();
const [isDraggingOverElement, setIsDraggingOverElement] = (0,external_wp_element_namespaceObject.useState)();
const [isActive, setIsActive] = (0,external_wp_element_namespaceObject.useState)();
const ref = (0,external_wp_compose_namespaceObject.__experimentalUseDropZone)({
onDrop(event) {
if (!event.dataTransfer) {
return;
}
const files = (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(event.dataTransfer);
const html = event.dataTransfer.getData("text/html");
if (html && onHTMLDrop) {
onHTMLDrop(html);
} else if (files.length && onFilesDrop) {
onFilesDrop(files);
} else if (onDrop) {
onDrop(event);
}
},
onDragStart(event) {
setIsDraggingOverDocument(true);
if (!event.dataTransfer) {
return;
}
if (event.dataTransfer.types.includes("text/html")) {
setIsActive(!!onHTMLDrop);
} else if (
// Check for the types because sometimes the files themselves
// are only available on drop.
event.dataTransfer.types.includes("Files") || (0,external_wp_dom_namespaceObject.getFilesFromDataTransfer)(event.dataTransfer).length > 0
) {
setIsActive(!!onFilesDrop);
} else {
setIsActive(!!onDrop && isEligible(event.dataTransfer));
}
},
onDragEnd() {
setIsDraggingOverElement(false);
setIsDraggingOverDocument(false);
setIsActive(void 0);
},
onDragEnter() {
setIsDraggingOverElement(true);
},
onDragLeave() {
setIsDraggingOverElement(false);
}
});
const classes = dist_clsx("components-drop-zone", className, {
"is-active": isActive,
"is-dragging-over-document": isDraggingOverDocument,
"is-dragging-over-element": isDraggingOverElement
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...restProps,
ref,
className: classes,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-drop-zone__content",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-drop-zone__content-inner",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon,
className: "components-drop-zone__content-icon"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-drop-zone__content-text",
children: label ? label : (0,external_wp_i18n_namespaceObject.__)("Drop files to upload")
})]
})
})
});
}
var drop_zone_default = DropZoneComponent;
;// ./node_modules/@wordpress/components/build-module/drop-zone/provider.js
function DropZoneProvider({
children
}) {
external_wp_deprecated_default()("wp.components.DropZoneProvider", {
since: "5.8",
hint: "wp.component.DropZone no longer needs a provider. wp.components.DropZoneProvider is safe to remove from your code."
});
return children;
}
;// ./node_modules/@wordpress/icons/build-module/library/swatch.js
var swatch_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M7.1 5.7 8 6.9c.4-.3.9-.6 1.5-.8l-.6-1.4c-.7.3-1.3.6-1.8 1ZM4.6 8.9l1.4.6c.2-.5.5-1 .8-1.5l-1.2-.9c-.4.6-.8 1.2-1 1.8Zm14.8 0c-.3-.7-.6-1.3-1-1.8l-1.2.9c.3.4.6.9.8 1.5l1.4-.6ZM7.1 18.3c.6.4 1.2.8 1.8 1l.6-1.4c-.5-.2-1-.5-1.5-.8l-.9 1.2ZM5.5 12v-.9h-.7l-.7-.2v2l1.5-.2v-.9Zm-.7 3h-.2c.3.7.6 1.3 1 1.9l1.2-.9c-.3-.4-.6-.9-.8-1.5l-1.2.5Zm9.7 3 .5 1.2v.2c.7-.3 1.3-.6 1.9-1l-.9-1.2c-.4.3-.9.6-1.5.8Zm-2.5.5h-.9l-.2 1.3v.2h2l-.2-1.5h-.9Zm7.9-7.5-1.5.2V13h.7l.7.2v-2ZM18 14.5c-.2.5-.5 1-.8 1.5l1.2.9c.4-.6.8-1.2 1-1.8h-.2l-1.2-.6ZM11 4.1l.2 1.5H13V4.2h-1.9ZM14.5 6c.5.2 1 .5 1.5.8l.9-1.2c-.6-.4-1.2-.8-1.8-1L14.5 6Z" }) });
;// ./node_modules/@wordpress/components/build-module/duotone-picker/color-list-picker/index.js
function ColorOption({
label,
value,
colors,
disableCustomColors,
enableAlpha,
onChange
}) {
const [isOpen, setIsOpen] = (0,external_wp_element_namespaceObject.useState)(false);
const idRoot = (0,external_wp_compose_namespaceObject.useInstanceId)(ColorOption, "color-list-picker-option");
const labelId = `${idRoot}__label`;
const contentId = `${idRoot}__content`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
className: "components-color-list-picker__swatch-button",
id: labelId,
onClick: () => setIsOpen((prev) => !prev),
"aria-expanded": isOpen,
"aria-controls": contentId,
icon: value ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_indicator_default, {
colorValue: value,
className: "components-color-list-picker__swatch-color"
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon: swatch_default
}),
text: label
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
role: "group",
id: contentId,
"aria-labelledby": labelId,
"aria-hidden": !isOpen,
children: isOpen && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_palette_default, {
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Color options"),
className: "components-color-list-picker__color-picker",
colors,
value,
clearable: false,
onChange,
disableCustomColors,
enableAlpha
})
})]
});
}
function ColorListPicker({
colors,
labels,
value = [],
disableCustomColors,
enableAlpha,
onChange
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-color-list-picker",
children: labels.map((label, index) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ColorOption, {
label,
value: value[index],
colors,
disableCustomColors,
enableAlpha,
onChange: (newColor) => {
const newColors = value.slice();
newColors[index] = newColor;
onChange(newColors);
}
}, index))
});
}
var color_list_picker_default = ColorListPicker;
;// ./node_modules/@wordpress/components/build-module/duotone-picker/utils.js
k([names]);
function getDefaultColors(palette) {
if (!palette || palette.length < 2) {
return ["#000", "#fff"];
}
return palette.map(({
color
}) => ({
color,
brightness: w(color).brightness()
})).reduce(([min, max], current) => {
return [current.brightness <= min.brightness ? current : min, current.brightness >= max.brightness ? current : max];
}, [{
brightness: 1,
color: ""
}, {
brightness: 0,
color: ""
}]).map(({
color
}) => color);
}
function getGradientFromCSSColors(colors = [], angle = "90deg") {
const l = 100 / colors.length;
const stops = colors.map((c, i) => `${c} ${i * l}%, ${c} ${(i + 1) * l}%`).join(", ");
return `linear-gradient( ${angle}, ${stops} )`;
}
function getColorStopsFromColors(colors) {
return colors.map((color, i) => ({
position: i * 100 / (colors.length - 1),
color
}));
}
function getColorsFromColorStops(colorStops = []) {
return colorStops.map(({
color
}) => color);
}
;// ./node_modules/@wordpress/components/build-module/duotone-picker/custom-duotone-bar.js
const PLACEHOLDER_VALUES = ["#333", "#CCC"];
function CustomDuotoneBar({
value,
onChange
}) {
const hasGradient = !!value;
const values = hasGradient ? value : PLACEHOLDER_VALUES;
const background = getGradientFromCSSColors(values);
const controlPoints = getColorStopsFromColors(values);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomGradientBar, {
disableInserter: true,
background,
hasGradient,
value: controlPoints,
onChange: (newColorStops) => {
const newValue = getColorsFromColorStops(newColorStops);
onChange(newValue);
}
});
}
;// ./node_modules/@wordpress/components/build-module/duotone-picker/duotone-picker.js
function DuotonePicker({
asButtons,
loop,
clearable = true,
unsetable = true,
colorPalette,
duotonePalette,
disableCustomColors,
disableCustomDuotone,
value,
onChange,
"aria-label": ariaLabel,
"aria-labelledby": ariaLabelledby,
...otherProps
}) {
const [defaultDark, defaultLight] = (0,external_wp_element_namespaceObject.useMemo)(() => getDefaultColors(colorPalette), [colorPalette]);
const isUnset = value === "unset";
const unsetOptionLabel = (0,external_wp_i18n_namespaceObject.__)("Unset");
const unsetOption = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.Option, {
value: "unset",
isSelected: isUnset,
tooltipText: unsetOptionLabel,
"aria-label": unsetOptionLabel,
className: "components-duotone-picker__color-indicator",
onClick: () => {
onChange(isUnset ? void 0 : "unset");
}
}, "unset");
const duotoneOptions = duotonePalette.map(({
colors,
slug,
name
}) => {
const style = {
background: getGradientFromCSSColors(colors, "135deg"),
color: "transparent"
};
const tooltipText = name !== null && name !== void 0 ? name : (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: duotone code e.g: "dark-grayscale" or "7f7f7f-ffffff".
(0,external_wp_i18n_namespaceObject.__)("Duotone code: %s"),
slug
);
const label = name ? (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the option e.g: "Dark grayscale".
(0,external_wp_i18n_namespaceObject.__)("Duotone: %s"),
name
) : tooltipText;
const isSelected = es6_default()(colors, value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.Option, {
value: colors,
isSelected,
"aria-label": label,
tooltipText,
style,
onClick: () => {
onChange(isSelected ? void 0 : colors);
}
}, slug);
});
const {
metaProps,
labelProps
} = getComputeCircularOptionPickerCommonProps(asButtons, loop, ariaLabel, ariaLabelledby);
const options = unsetable ? [unsetOption, ...duotoneOptions] : duotoneOptions;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default, {
...otherProps,
...metaProps,
...labelProps,
options,
actions: !!clearable && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(circular_option_picker_circular_option_picker_default.ButtonAction, {
onClick: () => onChange(void 0),
accessibleWhenDisabled: true,
disabled: !value,
children: (0,external_wp_i18n_namespaceObject.__)("Clear")
}),
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
paddingTop: options.length === 0 ? 0 : 4,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(v_stack_component_component_default, {
spacing: 3,
children: [!disableCustomColors && !disableCustomDuotone && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CustomDuotoneBar, {
value: isUnset ? void 0 : value,
onChange
}), !disableCustomDuotone && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_list_picker_default, {
labels: [(0,external_wp_i18n_namespaceObject.__)("Shadows"), (0,external_wp_i18n_namespaceObject.__)("Highlights")],
colors: colorPalette,
value: isUnset ? void 0 : value,
disableCustomColors,
enableAlpha: true,
onChange: (newColors) => {
if (!newColors[0]) {
newColors[0] = defaultDark;
}
if (!newColors[1]) {
newColors[1] = defaultLight;
}
const newValue = newColors.length >= 2 ? newColors : void 0;
onChange(newValue);
}
})]
})
})
});
}
var duotone_picker_default = DuotonePicker;
;// ./node_modules/@wordpress/components/build-module/duotone-picker/duotone-swatch.js
function DuotoneSwatch({
values
}) {
return values ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(color_indicator_default, {
colorValue: getGradientFromCSSColors(values, "135deg")
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon: swatch_default
});
}
var duotone_swatch_default = DuotoneSwatch;
;// ./node_modules/@wordpress/components/build-module/external-link/index.js
function UnforwardedExternalLink(props, ref) {
const {
href,
children,
className,
rel = "",
...additionalProps
} = props;
const optimizedRel = [...new Set([...rel.split(" "), "external", "noreferrer", "noopener"].filter(Boolean))].join(" ");
const classes = dist_clsx("components-external-link", className);
const isInternalAnchor = !!href?.startsWith("#");
const onClickHandler = (event) => {
if (isInternalAnchor) {
event.preventDefault();
}
if (props.onClick) {
props.onClick(event);
}
};
return (
/* eslint-disable react/jsx-no-target-blank */
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("a", {
...additionalProps,
className: classes,
href,
onClick: onClickHandler,
target: "_blank",
rel: optimizedRel,
ref,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-external-link__contents",
children
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-external-link__icon",
"aria-label": (
/* translators: accessibility text */
(0,external_wp_i18n_namespaceObject.__)("(opens in a new tab)")
),
children: "\u2197"
})]
})
);
}
const ExternalLink = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedExternalLink);
var external_link_default = ExternalLink;
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/utils.js
const INITIAL_BOUNDS = {
width: 200,
height: 170
};
const VIDEO_EXTENSIONS = ["avi", "mpg", "mpeg", "mov", "mp4", "m4v", "ogg", "ogv", "webm", "wmv"];
function getExtension(filename = "") {
const parts = filename.split(".");
return parts[parts.length - 1];
}
function isVideoType(filename = "") {
if (!filename) {
return false;
}
return filename.startsWith("data:video/") || VIDEO_EXTENSIONS.includes(getExtension(filename));
}
function fractionToPercentage(fraction) {
return Math.round(fraction * 100);
}
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/styles/focal-point-picker-style.js
function focal_point_picker_style_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const MediaWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeew7dm8"
} : 0)( true ? {
name: "jqnsxy",
styles: "background-color:transparent;display:flex;text-align:center;width:100%"
} : 0);
const MediaContainer = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeew7dm7"
} : 0)("align-items:center;border-radius:", config_values_default.radiusSmall, ";cursor:pointer;display:inline-flex;justify-content:center;margin:auto;position:relative;height:100%;&:after{border-radius:inherit;bottom:0;box-shadow:inset 0 0 0 1px rgba( 0, 0, 0, 0.1 );content:'';left:0;pointer-events:none;position:absolute;right:0;top:0;}img,video{border-radius:inherit;box-sizing:border-box;display:block;height:auto;margin:0;max-height:100%;max-width:100%;pointer-events:none;user-select:none;width:100%;}" + ( true ? "" : 0));
const MediaPlaceholder = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeew7dm6"
} : 0)("background:", COLORS.gray[100], ";border-radius:inherit;box-sizing:border-box;height:", INITIAL_BOUNDS.height, "px;max-width:280px;min-width:", INITIAL_BOUNDS.width, "px;width:100%;" + ( true ? "" : 0));
const focal_point_picker_style_StyledUnitControl = /* @__PURE__ */ emotion_styled_base_browser_esm(unit_control_default, true ? {
target: "eeew7dm5"
} : 0)( true ? {
name: "1d3w5wq",
styles: "width:100%"
} : 0);
var focal_point_picker_style_ref2 = true ? {
name: "1mn7kwb",
styles: "padding-bottom:1em"
} : 0;
const deprecatedBottomMargin = ({
__nextHasNoMarginBottom
}) => {
return !__nextHasNoMarginBottom ? focal_point_picker_style_ref2 : void 0;
};
var focal_point_picker_style_ref = true ? {
name: "1mn7kwb",
styles: "padding-bottom:1em"
} : 0;
const extraHelpTextMargin = ({
hasHelpText = false
}) => {
return hasHelpText ? focal_point_picker_style_ref : void 0;
};
const ControlWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_component_component_default, true ? {
target: "eeew7dm4"
} : 0)("max-width:320px;padding-top:1em;", extraHelpTextMargin, " ", deprecatedBottomMargin, ";" + ( true ? "" : 0));
const GridView = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeew7dm3"
} : 0)("left:50%;overflow:hidden;pointer-events:none;position:absolute;top:50%;transform:translate3d( -50%, -50%, 0 );z-index:1;@media not ( prefers-reduced-motion ){transition:opacity 100ms linear;}opacity:", ({
showOverlay
}) => showOverlay ? 1 : 0, ";" + ( true ? "" : 0));
const GridLine = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeew7dm2"
} : 0)( true ? {
name: "1yzbo24",
styles: "background:rgba( 255, 255, 255, 0.4 );backdrop-filter:blur( 16px ) saturate( 180% );position:absolute;transform:translateZ( 0 )"
} : 0);
const GridLineX = /* @__PURE__ */ emotion_styled_base_browser_esm(GridLine, true ? {
target: "eeew7dm1"
} : 0)( true ? {
name: "1sw8ur",
styles: "height:1px;left:1px;right:1px"
} : 0);
const GridLineY = /* @__PURE__ */ emotion_styled_base_browser_esm(GridLine, true ? {
target: "eeew7dm0"
} : 0)( true ? {
name: "188vg4t",
styles: "width:1px;top:1px;bottom:1px"
} : 0);
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/controls.js
const TEXTCONTROL_MIN = 0;
const TEXTCONTROL_MAX = 100;
const controls_noop = () => {
};
function FocalPointPickerControls({
__nextHasNoMarginBottom,
hasHelpText,
onChange = controls_noop,
point = {
x: 0.5,
y: 0.5
}
}) {
const valueX = fractionToPercentage(point.x);
const valueY = fractionToPercentage(point.y);
const handleChange = (value, axis) => {
if (value === void 0) {
return;
}
const num = parseInt(value, 10);
if (!isNaN(num)) {
onChange({
...point,
[axis]: num / 100
});
}
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ControlWrapper, {
className: "focal-point-picker__controls",
__nextHasNoMarginBottom,
hasHelpText,
gap: 4,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FocalPointUnitControl, {
label: (0,external_wp_i18n_namespaceObject.__)("Left"),
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Focal point left position"),
value: [valueX, "%"].join(""),
onChange: (next) => handleChange(next, "x"),
dragDirection: "e"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FocalPointUnitControl, {
label: (0,external_wp_i18n_namespaceObject.__)("Top"),
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Focal point top position"),
value: [valueY, "%"].join(""),
onChange: (next) => handleChange(next, "y"),
dragDirection: "s"
})]
});
}
function FocalPointUnitControl(props) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(focal_point_picker_style_StyledUnitControl, {
__next40pxDefaultSize: true,
className: "focal-point-picker__controls-position-unit-control",
labelPosition: "top",
max: TEXTCONTROL_MAX,
min: TEXTCONTROL_MIN,
units: [{
value: "%",
label: "%"
}],
...props
});
}
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/styles/focal-point-style.js
const PointerCircle = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e19snlhg0"
} : 0)("background-color:transparent;cursor:grab;height:40px;margin:-20px 0 0 -20px;position:absolute;user-select:none;width:40px;will-change:transform;z-index:10000;background:rgba( 255, 255, 255, 0.4 );border:1px solid rgba( 255, 255, 255, 0.4 );border-radius:", config_values_default.radiusRound, ";backdrop-filter:blur( 16px ) saturate( 180% );box-shadow:rgb( 0 0 0 / 10% ) 0px 0px 8px;@media not ( prefers-reduced-motion ){transition:transform 100ms linear;}", ({
isDragging
}) => isDragging && `
box-shadow: rgb( 0 0 0 / 12% ) 0px 0px 10px;
transform: scale( 1.1 );
cursor: grabbing;
`, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/focal-point.js
function FocalPoint({
left = "50%",
top = "50%",
...props
}) {
const style = {
left,
top
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PointerCircle, {
...props,
className: "components-focal-point-picker__icon_container",
style
});
}
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/grid.js
function FocalPointPickerGrid({
bounds,
...props
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(GridView, {
...props,
className: "components-focal-point-picker__grid",
style: {
width: bounds.width,
height: bounds.height
},
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLineX, {
style: {
top: "33%"
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLineX, {
style: {
top: "66%"
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLineY, {
style: {
left: "33%"
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GridLineY, {
style: {
left: "66%"
}
})]
});
}
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/media.js
function media_Media({
alt,
autoPlay,
src,
onLoad,
mediaRef,
// Exposing muted prop for test rendering purposes
// https://github.com/testing-library/react-testing-library/issues/470
muted = true,
...props
}) {
if (!src) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaPlaceholder, {
className: "components-focal-point-picker__media components-focal-point-picker__media--placeholder",
ref: mediaRef,
...props
});
}
const isVideo = isVideoType(src);
return isVideo ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("video", {
...props,
autoPlay,
className: "components-focal-point-picker__media components-focal-point-picker__media--video",
loop: true,
muted,
onLoadedData: onLoad,
ref: mediaRef,
src
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("img", {
...props,
alt,
className: "components-focal-point-picker__media components-focal-point-picker__media--image",
onLoad,
ref: mediaRef,
src
});
}
;// ./node_modules/@wordpress/components/build-module/focal-point-picker/index.js
const GRID_OVERLAY_TIMEOUT = 600;
function FocalPointPicker({
__nextHasNoMarginBottom,
autoPlay = true,
className,
help,
label,
onChange,
onDrag,
onDragEnd,
onDragStart,
resolvePoint,
url,
value: valueProp = {
x: 0.5,
y: 0.5
},
...restProps
}) {
const [point, setPoint] = (0,external_wp_element_namespaceObject.useState)(valueProp);
const [showGridOverlay, setShowGridOverlay] = (0,external_wp_element_namespaceObject.useState)(false);
const {
startDrag,
endDrag,
isDragging
} = (0,external_wp_compose_namespaceObject.__experimentalUseDragging)({
onDragStart: (event) => {
dragAreaRef.current?.focus();
const value = getValueWithinDragArea(event);
if (!value) {
return;
}
onDragStart?.(value, event);
setPoint(value);
},
onDragMove: (event) => {
event.preventDefault();
const value = getValueWithinDragArea(event);
if (!value) {
return;
}
onDrag?.(value, event);
setPoint(value);
},
onDragEnd: () => {
onDragEnd?.();
onChange?.(point);
}
});
const {
x,
y
} = isDragging ? point : valueProp;
const dragAreaRef = (0,external_wp_element_namespaceObject.useRef)(null);
const [bounds, setBounds] = (0,external_wp_element_namespaceObject.useState)(INITIAL_BOUNDS);
const refUpdateBounds = (0,external_wp_element_namespaceObject.useRef)(() => {
if (!dragAreaRef.current) {
return;
}
const {
clientWidth: width,
clientHeight: height
} = dragAreaRef.current;
setBounds(width > 0 && height > 0 ? {
width,
height
} : {
...INITIAL_BOUNDS
});
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
const updateBounds = refUpdateBounds.current;
if (!dragAreaRef.current) {
return;
}
const {
defaultView
} = dragAreaRef.current.ownerDocument;
defaultView?.addEventListener("resize", updateBounds);
return () => defaultView?.removeEventListener("resize", updateBounds);
}, []);
(0,external_wp_compose_namespaceObject.useIsomorphicLayoutEffect)(() => void refUpdateBounds.current(), []);
const getValueWithinDragArea = ({
clientX,
clientY,
shiftKey
}) => {
if (!dragAreaRef.current) {
return;
}
const {
top,
left
} = dragAreaRef.current.getBoundingClientRect();
let nextX = (clientX - left) / bounds.width;
let nextY = (clientY - top) / bounds.height;
if (shiftKey) {
nextX = Math.round(nextX / 0.1) * 0.1;
nextY = Math.round(nextY / 0.1) * 0.1;
}
return getFinalValue({
x: nextX,
y: nextY
});
};
const getFinalValue = (value) => {
var _resolvePoint;
const resolvedValue = (_resolvePoint = resolvePoint?.(value)) !== null && _resolvePoint !== void 0 ? _resolvePoint : value;
resolvedValue.x = Math.max(0, Math.min(resolvedValue.x, 1));
resolvedValue.y = Math.max(0, Math.min(resolvedValue.y, 1));
const roundToTwoDecimalPlaces = (n) => Math.round(n * 100) / 100;
return {
x: roundToTwoDecimalPlaces(resolvedValue.x),
y: roundToTwoDecimalPlaces(resolvedValue.y)
};
};
const arrowKeyStep = (event) => {
const {
code,
shiftKey
} = event;
if (!["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(code)) {
return;
}
event.preventDefault();
const value = {
x,
y
};
const step = shiftKey ? 0.1 : 0.01;
const delta = code === "ArrowUp" || code === "ArrowLeft" ? -1 * step : step;
const axis = code === "ArrowUp" || code === "ArrowDown" ? "y" : "x";
value[axis] = value[axis] + delta;
onChange?.(getFinalValue(value));
};
const focalPointPosition = {
left: x !== void 0 ? x * bounds.width : 0.5 * bounds.width,
top: y !== void 0 ? y * bounds.height : 0.5 * bounds.height
};
const classes = dist_clsx("components-focal-point-picker-control", className);
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(FocalPointPicker);
const id = `inspector-focal-point-picker-control-${instanceId}`;
use_update_effect_default(() => {
setShowGridOverlay(true);
const timeout = window.setTimeout(() => {
setShowGridOverlay(false);
}, GRID_OVERLAY_TIMEOUT);
return () => window.clearTimeout(timeout);
}, [x, y]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(base_control_default, {
...restProps,
__nextHasNoMarginBottom,
__associatedWPComponentName: "FocalPointPicker",
label,
id,
help,
className: classes,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MediaWrapper, {
className: "components-focal-point-picker-wrapper",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(MediaContainer, {
className: "components-focal-point-picker",
onKeyDown: arrowKeyStep,
onMouseDown: startDrag,
onBlur: () => {
if (isDragging) {
endDrag();
}
},
ref: dragAreaRef,
role: "button",
tabIndex: -1,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FocalPointPickerGrid, {
bounds,
showOverlay: showGridOverlay
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(media_Media, {
alt: (0,external_wp_i18n_namespaceObject.__)("Media preview"),
autoPlay,
onLoad: refUpdateBounds.current,
src: url
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FocalPoint, {
...focalPointPosition,
isDragging
})]
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FocalPointPickerControls, {
__nextHasNoMarginBottom,
hasHelpText: !!help,
point: {
x,
y
},
onChange: (value) => {
onChange?.(getFinalValue(value));
}
})]
});
}
var focal_point_picker_default = FocalPointPicker;
;// ./node_modules/@wordpress/components/build-module/focusable-iframe/index.js
function FocusableIframe({
iframeRef,
...props
}) {
const ref = (0,external_wp_compose_namespaceObject.useMergeRefs)([iframeRef, (0,external_wp_compose_namespaceObject.useFocusableIframe)()]);
external_wp_deprecated_default()("wp.components.FocusableIframe", {
since: "5.9",
alternative: "wp.compose.useFocusableIframe"
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("iframe", {
ref,
...props
});
}
;// ./node_modules/@wordpress/components/build-module/font-size-picker/styles.js
function font_size_picker_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const styles_Container = /* @__PURE__ */ emotion_styled_base_browser_esm("fieldset", true ? {
target: "e8tqeku4"
} : 0)( true ? {
name: "k2q51s",
styles: "border:0;margin:0;padding:0;display:contents"
} : 0);
const styles_Header = /* @__PURE__ */ emotion_styled_base_browser_esm(h_stack_component_component_default, true ? {
target: "e8tqeku3"
} : 0)("height:", space(4), ";" + ( true ? "" : 0));
const HeaderToggle = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "e8tqeku2"
} : 0)("margin-top:", space(-1), ";" + ( true ? "" : 0));
const HeaderLabel = /* @__PURE__ */ emotion_styled_base_browser_esm(base_control_default.VisualLabel, true ? {
target: "e8tqeku1"
} : 0)("display:flex;gap:", space(1), ";justify-content:flex-start;margin-bottom:0;" + ( true ? "" : 0));
const StyledCustomSelectControl = /* @__PURE__ */ emotion_styled_base_browser_esm(custom_select_control_default, true ? {
target: "e8tqeku0"
} : 0)( true ? {
name: "anvx77",
styles: ".components-custom-select-control__item .components-custom-select-control__item-hint{width:100%;}"
} : 0);
;// ./node_modules/@wordpress/components/build-module/font-size-picker/utils.js
function isSimpleCssValue(value) {
const sizeRegex = /^[\d\.]+(px|em|rem|vw|vh|%|svw|lvw|dvw|svh|lvh|dvh|vi|svi|lvi|dvi|vb|svb|lvb|dvb|vmin|svmin|lvmin|dvmin|vmax|svmax|lvmax|dvmax)?$/i;
return sizeRegex.test(String(value));
}
function generateFontSizeHint(fontSize) {
if (fontSize.hint) {
return fontSize.hint;
}
if (isSimpleCssValue(fontSize.size)) {
return String(fontSize.size);
}
return void 0;
}
;// ./node_modules/@wordpress/components/build-module/font-size-picker/font-size-picker-select.js
const DEFAULT_OPTION = {
key: "default",
name: (0,external_wp_i18n_namespaceObject.__)("Default"),
value: void 0
};
const FontSizePickerSelect = (props) => {
const {
__next40pxDefaultSize,
fontSizes,
value,
size,
valueMode = "literal",
onChange
} = props;
const options = [DEFAULT_OPTION, ...fontSizes.map((fontSize) => {
const hint = generateFontSizeHint(fontSize);
return {
key: fontSize.slug,
name: fontSize.name || fontSize.slug,
value: fontSize.size,
hint
};
})];
const selectedOption = (0,external_wp_element_namespaceObject.useMemo)(() => {
var _options$find;
if (value === void 0) {
return DEFAULT_OPTION;
}
if (valueMode === "slug") {
const optionBySlug = options.find((option) => option.key === value);
if (optionBySlug) {
return optionBySlug;
}
}
return (_options$find = options.find((option) => option.value === value)) !== null && _options$find !== void 0 ? _options$find : DEFAULT_OPTION;
}, [value, valueMode, options]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledCustomSelectControl, {
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true,
className: "components-font-size-picker__select",
label: (0,external_wp_i18n_namespaceObject.__)("Font size"),
hideLabelFromVision: true,
describedBy: (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: Currently selected font size.
(0,external_wp_i18n_namespaceObject.__)("Currently selected font size: %s"),
selectedOption.name
),
options,
value: selectedOption,
showSelectedHint: true,
onChange: ({
selectedItem
}) => {
const matchingFontSize = selectedItem.key === "default" ? void 0 : fontSizes.find((fontSize) => fontSize.slug === selectedItem.key);
onChange(selectedItem.value, matchingFontSize);
},
size
});
};
var font_size_picker_select_default = FontSizePickerSelect;
;// ./node_modules/@wordpress/components/build-module/font-size-picker/constants.js
const T_SHIRT_ABBREVIATIONS = [
/* translators: S stands for 'small' and is a size label. */
(0,external_wp_i18n_namespaceObject.__)("S"),
/* translators: M stands for 'medium' and is a size label. */
(0,external_wp_i18n_namespaceObject.__)("M"),
/* translators: L stands for 'large' and is a size label. */
(0,external_wp_i18n_namespaceObject.__)("L"),
/* translators: XL stands for 'extra large' and is a size label. */
(0,external_wp_i18n_namespaceObject.__)("XL"),
/* translators: XXL stands for 'extra extra large' and is a size label. */
(0,external_wp_i18n_namespaceObject.__)("XXL")
];
const T_SHIRT_NAMES = [(0,external_wp_i18n_namespaceObject.__)("Small"), (0,external_wp_i18n_namespaceObject.__)("Medium"), (0,external_wp_i18n_namespaceObject.__)("Large"), (0,external_wp_i18n_namespaceObject.__)("Extra Large"), (0,external_wp_i18n_namespaceObject.__)("Extra Extra Large")];
;// ./node_modules/@wordpress/components/build-module/font-size-picker/font-size-picker-toggle-group.js
const FontSizePickerToggleGroup = (props) => {
const {
fontSizes,
value,
valueMode = "literal",
__next40pxDefaultSize,
size,
onChange
} = props;
const currentValue = (() => {
if (!value) {
return void 0;
}
if (valueMode === "slug") {
return String(value);
}
const matchingFontSizes = fontSizes.filter((fontSize) => fontSize.size === value);
if (matchingFontSizes.length > 1) {
return void 0;
}
const fontSizeBySize = fontSizes.find((fontSize) => fontSize.size === value);
return fontSizeBySize?.slug;
})();
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_component_component_default, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true,
label: (0,external_wp_i18n_namespaceObject.__)("Font size"),
hideLabelFromVision: true,
value: currentValue,
onChange: (newSlug) => {
if (newSlug === void 0) {
onChange(void 0);
} else {
const selectedFontSize = fontSizes.find((fontSize) => fontSize.slug === String(newSlug));
if (selectedFontSize) {
onChange(selectedFontSize.size, selectedFontSize);
}
}
},
isBlock: true,
size,
children: fontSizes.map((fontSize, index) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_option_component_component_default, {
value: fontSize.slug,
label: T_SHIRT_ABBREVIATIONS[index],
"aria-label": fontSize.name || T_SHIRT_NAMES[index],
showTooltip: true
}, fontSize.slug))
});
};
var font_size_picker_toggle_group_default = FontSizePickerToggleGroup;
;// ./node_modules/@wordpress/components/build-module/font-size-picker/index.js
const DEFAULT_UNITS = ["px", "em", "rem", "vw", "vh"];
const MAX_TOGGLE_GROUP_SIZES = 5;
const UnforwardedFontSizePicker = (props, ref) => {
const {
__next40pxDefaultSize = false,
fallbackFontSize,
fontSizes = [],
disableCustomFontSizes = false,
onChange,
size = "default",
units: unitsProp = DEFAULT_UNITS,
value,
valueMode = "literal",
withSlider = false,
withReset = true
} = props;
const labelId = (0,external_wp_compose_namespaceObject.useInstanceId)(UnforwardedFontSizePicker, "font-size-picker-label");
const units = useCustomUnits({
availableUnits: unitsProp
});
const selectedFontSize = (() => {
if (!value) {
return void 0;
}
if (valueMode === "slug") {
return fontSizes.find((fontSize) => fontSize.slug === value);
}
return fontSizes.find((fontSize) => fontSize.size === value);
})();
const isCustomValue = !!value && !selectedFontSize;
const [userRequestedCustom, setUserRequestedCustom] = (0,external_wp_element_namespaceObject.useState)(isCustomValue);
const resolvedValueForControls = valueMode === "slug" ? selectedFontSize?.size : value;
let currentPickerType;
if (!disableCustomFontSizes && userRequestedCustom) {
currentPickerType = "custom";
} else {
currentPickerType = fontSizes.length > MAX_TOGGLE_GROUP_SIZES ? "select" : "togglegroup";
}
if (fontSizes.length === 0 && disableCustomFontSizes) {
return null;
}
const hasUnits = typeof resolvedValueForControls === "string" || typeof fontSizes[0]?.size === "string";
const [valueQuantity, valueUnit] = parseQuantityAndUnitFromRawValue(resolvedValueForControls, units);
const isValueUnitRelative = !!valueUnit && ["em", "rem", "vw", "vh"].includes(valueUnit);
const isDisabled = value === void 0;
maybeWarnDeprecated36pxSize({
componentName: "FontSizePicker",
__next40pxDefaultSize,
size
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(styles_Container, {
ref,
className: "components-font-size-picker",
"aria-labelledby": labelId,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(styles_Header, {
className: "components-font-size-picker__header",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(HeaderLabel, {
id: labelId,
children: (0,external_wp_i18n_namespaceObject.__)("Font size")
}), !disableCustomFontSizes && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(HeaderToggle, {
label: currentPickerType === "custom" ? (0,external_wp_i18n_namespaceObject.__)("Use size preset") : (0,external_wp_i18n_namespaceObject.__)("Set custom size"),
icon: settings_default,
onClick: () => setUserRequestedCustom(!userRequestedCustom),
isPressed: currentPickerType === "custom",
size: "small"
})]
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
children: [currentPickerType === "select" && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(font_size_picker_select_default, {
__next40pxDefaultSize,
fontSizes,
value,
valueMode,
disableCustomFontSizes,
size,
onChange: (newValue, selectedItem) => {
if (newValue === void 0) {
onChange?.(void 0, selectedItem);
} else {
onChange?.(hasUnits ? newValue : Number(newValue), selectedItem);
}
},
onSelectCustom: () => setUserRequestedCustom(true)
}), currentPickerType === "togglegroup" && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(font_size_picker_toggle_group_default, {
fontSizes,
value,
valueMode,
__next40pxDefaultSize,
size,
onChange: (newValue, selectedItem) => {
if (newValue === void 0) {
onChange?.(void 0, selectedItem);
} else {
onChange?.(hasUnits ? newValue : Number(newValue), selectedItem);
}
}
}), currentPickerType === "custom" && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(flex_component_component_default, {
className: "components-font-size-picker__custom-size-control",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_item_component_component_default, {
isBlock: true,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(unit_control_default, {
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true,
label: (0,external_wp_i18n_namespaceObject.__)("Font size"),
labelPosition: "top",
hideLabelFromVision: true,
value: hasUnits ? `${valueQuantity !== null && valueQuantity !== void 0 ? valueQuantity : ""}${valueUnit !== null && valueUnit !== void 0 ? valueUnit : ""}` : resolvedValueForControls,
onChange: (newValue) => {
setUserRequestedCustom(true);
if (newValue === void 0 || newValue === "") {
onChange?.(void 0);
} else {
onChange?.(hasUnits ? newValue : parseInt(newValue, 10));
}
},
size,
units: hasUnits ? units : [],
min: 0
})
}), withSlider && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_item_component_component_default, {
isBlock: true,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
marginX: 2,
marginBottom: 0,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(range_control_default, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize,
__shouldNotWarnDeprecated36pxSize: true,
className: "components-font-size-picker__custom-input",
label: (0,external_wp_i18n_namespaceObject.__)("Font size"),
hideLabelFromVision: true,
value: valueQuantity,
initialPosition: fallbackFontSize,
withInputField: false,
onChange: (newValue) => {
setUserRequestedCustom(true);
if (newValue === void 0) {
onChange?.(void 0);
} else if (hasUnits) {
onChange?.(newValue + (valueUnit !== null && valueUnit !== void 0 ? valueUnit : "px"));
} else {
onChange?.(newValue);
}
},
min: 0,
max: isValueUnitRelative ? 10 : 100,
step: isValueUnitRelative ? 0.1 : 1
})
})
}), withReset && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_item_component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Button, {
disabled: isDisabled,
accessibleWhenDisabled: true,
onClick: () => {
onChange?.(void 0);
},
variant: "secondary",
__next40pxDefaultSize: true,
size: size === "__unstable-large" || props.__next40pxDefaultSize ? "default" : "small",
children: (0,external_wp_i18n_namespaceObject.__)("Reset")
})
})]
})]
})]
});
};
const FontSizePicker = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedFontSizePicker);
var font_size_picker_default = FontSizePicker;
;// ./node_modules/@wordpress/components/build-module/form-file-upload/index.js
function FormFileUpload({
accept,
children,
multiple = false,
onChange,
onClick,
render,
...props
}) {
const ref = (0,external_wp_element_namespaceObject.useRef)(null);
const openFileDialog = () => {
ref.current?.click();
};
if (!render) {
maybeWarnDeprecated36pxSize({
componentName: "FormFileUpload",
__next40pxDefaultSize: props.__next40pxDefaultSize,
// @ts-expect-error - We don't "officially" support all Button props but this likely happens.
size: props.size
});
}
const ui = render ? render({
openFileDialog
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
onClick: openFileDialog,
...props,
children
});
const compatAccept = accept?.includes("audio/*") ? `${accept}, audio/mp3, audio/x-m4a, audio/x-m4b, audio/x-m4p, audio/x-wav, audio/webm` : accept;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-form-file-upload",
children: [ui, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
type: "file",
ref,
multiple,
style: {
display: "none"
},
accept: compatAccept,
onChange,
onClick,
"data-testid": "form-file-upload-input"
})]
});
}
var form_file_upload_default = FormFileUpload;
;// ./node_modules/@wordpress/components/build-module/form-toggle/index.js
const form_toggle_noop = () => {
};
function UnforwardedFormToggle(props, ref) {
const {
className,
checked,
id,
disabled,
onChange = form_toggle_noop,
onClick,
...additionalProps
} = props;
const wrapperClasses = dist_clsx("components-form-toggle", className, {
"is-checked": checked,
"is-disabled": disabled
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
className: wrapperClasses,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
className: "components-form-toggle__input",
id,
type: "checkbox",
checked,
onChange,
disabled,
onClick: (event) => {
event.currentTarget.focus();
onClick?.(event);
},
...additionalProps,
ref
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-form-toggle__track"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-form-toggle__thumb"
})]
});
}
const FormToggle = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedFormToggle);
var form_toggle_default = FormToggle;
;// ./node_modules/@wordpress/components/build-module/form-token-field/token.js
const token_noop = () => {
};
function Token({
value,
status,
title,
displayTransform,
isBorderless = false,
disabled = false,
onClickRemove = token_noop,
onMouseEnter,
onMouseLeave,
messages,
termPosition,
termsCount
}) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(Token);
const tokenClasses = dist_clsx("components-form-token-field__token", {
"is-error": "error" === status,
"is-success": "success" === status,
"is-validating": "validating" === status,
"is-borderless": isBorderless,
"is-disabled": disabled
});
const onClick = () => onClickRemove({
value
});
const transformedValue = displayTransform(value);
const termPositionAndCount = (0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: 1: term name, 2: term position in a set of terms, 3: total term set count. */
(0,external_wp_i18n_namespaceObject.__)("%1$s (%2$d of %3$d)"),
transformedValue,
termPosition,
termsCount
);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
className: tokenClasses,
onMouseEnter,
onMouseLeave,
title,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
className: "components-form-token-field__token-text",
id: `components-form-token-field__token-text-${instanceId}`,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "span",
children: termPositionAndCount
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
"aria-hidden": "true",
children: transformedValue
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
className: "components-form-token-field__remove-token",
size: "small",
icon: close_small_default,
onClick: !disabled ? onClick : void 0,
disabled,
label: messages.remove,
"aria-describedby": `components-form-token-field__token-text-${instanceId}`
})]
});
}
;// ./node_modules/@wordpress/components/build-module/form-token-field/styles.js
const deprecatedPaddings = ({
__next40pxDefaultSize,
hasTokens
}) => !__next40pxDefaultSize && /* @__PURE__ */ emotion_react_browser_esm_css("padding-top:", space(hasTokens ? 1 : 0.5), ";padding-bottom:", space(hasTokens ? 1 : 0.5), ";" + ( true ? "" : 0), true ? "" : 0);
const TokensAndInputWrapperFlex = /* @__PURE__ */ emotion_styled_base_browser_esm(flex_component_component_default, true ? {
target: "ehq8nmi0"
} : 0)("padding:7px;", boxSizingReset, " ", deprecatedPaddings, ";" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/form-token-field/index.js
const form_token_field_identity = (value) => value;
function FormTokenField(props) {
const {
autoCapitalize,
autoComplete,
maxLength,
placeholder,
label = (0,external_wp_i18n_namespaceObject.__)("Add item"),
className,
suggestions = [],
maxSuggestions = 100,
value = [],
displayTransform = form_token_field_identity,
saveTransform = (token) => token.trim(),
onChange = () => {
},
onInputChange = () => {
},
onFocus = void 0,
isBorderless = false,
disabled = false,
tokenizeOnSpace = false,
messages = {
added: (0,external_wp_i18n_namespaceObject.__)("Item added."),
removed: (0,external_wp_i18n_namespaceObject.__)("Item removed."),
remove: (0,external_wp_i18n_namespaceObject.__)("Remove item"),
__experimentalInvalid: (0,external_wp_i18n_namespaceObject.__)("Invalid item")
},
__experimentalRenderItem,
__experimentalExpandOnFocus = false,
__experimentalValidateInput = () => true,
__experimentalShowHowTo = true,
__next40pxDefaultSize = false,
__experimentalAutoSelectFirstMatch = false,
__nextHasNoMarginBottom = false,
tokenizeOnBlur = false
} = useDeprecated36pxDefaultSizeProp(props);
if (!__nextHasNoMarginBottom) {
external_wp_deprecated_default()("Bottom margin styles for wp.components.FormTokenField", {
since: "6.7",
version: "7.0",
hint: "Set the `__nextHasNoMarginBottom` prop to true to start opting into the new styles, which will become the default in a future version."
});
}
maybeWarnDeprecated36pxSize({
componentName: "FormTokenField",
size: void 0,
__next40pxDefaultSize
});
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(FormTokenField);
const [incompleteTokenValue, setIncompleteTokenValue] = (0,external_wp_element_namespaceObject.useState)("");
const [inputOffsetFromEnd, setInputOffsetFromEnd] = (0,external_wp_element_namespaceObject.useState)(0);
const [isActive, setIsActive] = (0,external_wp_element_namespaceObject.useState)(false);
const [isExpanded, setIsExpanded] = (0,external_wp_element_namespaceObject.useState)(false);
const [selectedSuggestionIndex, setSelectedSuggestionIndex] = (0,external_wp_element_namespaceObject.useState)(-1);
const [selectedSuggestionScroll, setSelectedSuggestionScroll] = (0,external_wp_element_namespaceObject.useState)(false);
const prevSuggestions = (0,external_wp_compose_namespaceObject.usePrevious)(suggestions);
const prevValue = (0,external_wp_compose_namespaceObject.usePrevious)(value);
const input = (0,external_wp_element_namespaceObject.useRef)(null);
const tokensAndInput = (0,external_wp_element_namespaceObject.useRef)(null);
const debouncedSpeak = (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (isActive && !hasFocus()) {
focus();
}
}, [isActive]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const suggestionsDidUpdate = !external_wp_isShallowEqual_default()(suggestions, prevSuggestions || []);
if (suggestionsDidUpdate || value !== prevValue) {
updateSuggestions(suggestionsDidUpdate);
}
}, [suggestions, prevSuggestions, value, prevValue]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
updateSuggestions();
}, [incompleteTokenValue]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
updateSuggestions();
}, [__experimentalAutoSelectFirstMatch]);
if (disabled && isActive) {
setIsActive(false);
setIncompleteTokenValue("");
}
function focus() {
input.current?.focus();
}
function hasFocus() {
return input.current === input.current?.ownerDocument.activeElement;
}
function onFocusHandler(event) {
if (hasFocus() || event.target === tokensAndInput.current) {
setIsActive(true);
setIsExpanded(__experimentalExpandOnFocus || isExpanded);
} else {
setIsActive(false);
}
if ("function" === typeof onFocus) {
onFocus(event);
}
}
function onBlur(event) {
if (inputHasValidValue() && __experimentalValidateInput(incompleteTokenValue)) {
setIsActive(false);
if (tokenizeOnBlur && inputHasValidValue()) {
addNewToken(incompleteTokenValue);
}
} else {
setIncompleteTokenValue("");
setInputOffsetFromEnd(0);
setIsActive(false);
if (__experimentalExpandOnFocus) {
const hasFocusWithin = event.relatedTarget === tokensAndInput.current;
setIsExpanded(hasFocusWithin);
} else {
setIsExpanded(false);
}
setSelectedSuggestionIndex(-1);
setSelectedSuggestionScroll(false);
}
}
function onKeyDown(event) {
let preventDefault = false;
if (event.defaultPrevented) {
return;
}
switch (event.key) {
case "Backspace":
preventDefault = handleDeleteKey(deleteTokenBeforeInput);
break;
case "Enter":
preventDefault = addCurrentToken();
break;
case "ArrowLeft":
preventDefault = handleLeftArrowKey();
break;
case "ArrowUp":
preventDefault = handleUpArrowKey();
break;
case "ArrowRight":
preventDefault = handleRightArrowKey();
break;
case "ArrowDown":
preventDefault = handleDownArrowKey();
break;
case "Delete":
preventDefault = handleDeleteKey(deleteTokenAfterInput);
break;
case "Space":
if (tokenizeOnSpace) {
preventDefault = addCurrentToken();
}
break;
case "Escape":
preventDefault = handleEscapeKey(event);
break;
case "Tab":
preventDefault = handleTabKey(event);
break;
default:
break;
}
if (preventDefault) {
event.preventDefault();
}
}
function onKeyPress(event) {
let preventDefault = false;
switch (event.key) {
case ",":
preventDefault = handleCommaKey();
break;
default:
break;
}
if (preventDefault) {
event.preventDefault();
}
}
function onContainerTouched(event) {
if (event.target === tokensAndInput.current && isActive) {
event.preventDefault();
}
}
function onTokenClickRemove(event) {
deleteToken(event.value);
focus();
}
function onSuggestionHovered(suggestion) {
const index = getMatchingSuggestions().indexOf(suggestion);
if (index >= 0) {
setSelectedSuggestionIndex(index);
setSelectedSuggestionScroll(false);
}
}
function onSuggestionSelected(suggestion) {
addNewToken(suggestion);
}
function onInputChangeHandler(event) {
const text = event.value;
const separator = tokenizeOnSpace ? /[ ,\t]+/ : /[,\t]+/;
const items = text.split(separator);
const tokenValue = items[items.length - 1] || "";
if (items.length > 1) {
addNewTokens(items.slice(0, -1));
}
setIncompleteTokenValue(tokenValue);
onInputChange(tokenValue);
}
function handleDeleteKey(_deleteToken) {
let preventDefault = false;
if (hasFocus() && isInputEmpty()) {
_deleteToken();
preventDefault = true;
}
return preventDefault;
}
function handleLeftArrowKey() {
let preventDefault = false;
if (isInputEmpty()) {
moveInputBeforePreviousToken();
preventDefault = true;
}
return preventDefault;
}
function handleRightArrowKey() {
let preventDefault = false;
if (isInputEmpty()) {
moveInputAfterNextToken();
preventDefault = true;
}
return preventDefault;
}
function handleUpArrowKey() {
setSelectedSuggestionIndex((index) => {
return (index === 0 ? getMatchingSuggestions(incompleteTokenValue, suggestions, value, maxSuggestions, saveTransform).length : index) - 1;
});
setSelectedSuggestionScroll(true);
return true;
}
function handleDownArrowKey() {
setSelectedSuggestionIndex((index) => {
return (index + 1) % getMatchingSuggestions(incompleteTokenValue, suggestions, value, maxSuggestions, saveTransform).length;
});
setSelectedSuggestionScroll(true);
return true;
}
function collapseSuggestionsList(event) {
if (event.target instanceof HTMLInputElement) {
setIncompleteTokenValue(event.target.value);
setIsExpanded(false);
setSelectedSuggestionIndex(-1);
setSelectedSuggestionScroll(false);
}
}
function handleEscapeKey(event) {
collapseSuggestionsList(event);
return true;
}
function handleTabKey(event) {
collapseSuggestionsList(event);
return false;
}
function handleCommaKey() {
if (inputHasValidValue()) {
addNewToken(incompleteTokenValue);
}
return true;
}
function moveInputToIndex(index) {
setInputOffsetFromEnd(value.length - Math.max(index, -1) - 1);
}
function moveInputBeforePreviousToken() {
setInputOffsetFromEnd((prevInputOffsetFromEnd) => {
return Math.min(prevInputOffsetFromEnd + 1, value.length);
});
}
function moveInputAfterNextToken() {
setInputOffsetFromEnd((prevInputOffsetFromEnd) => {
return Math.max(prevInputOffsetFromEnd - 1, 0);
});
}
function deleteTokenBeforeInput() {
const index = getIndexOfInput() - 1;
if (index > -1) {
deleteToken(value[index]);
}
}
function deleteTokenAfterInput() {
const index = getIndexOfInput();
if (index < value.length) {
deleteToken(value[index]);
moveInputToIndex(index);
}
}
function addCurrentToken() {
let preventDefault = false;
const selectedSuggestion = getSelectedSuggestion();
if (selectedSuggestion) {
addNewToken(selectedSuggestion);
preventDefault = true;
} else if (inputHasValidValue()) {
addNewToken(incompleteTokenValue);
preventDefault = true;
}
return preventDefault;
}
function addNewTokens(tokens) {
const tokensToAdd = [...new Set(tokens.map(saveTransform).filter(Boolean).filter((token) => !valueContainsToken(token)))];
if (tokensToAdd.length > 0) {
const newValue = [...value];
newValue.splice(getIndexOfInput(), 0, ...tokensToAdd);
onChange(newValue);
}
}
function addNewToken(token) {
if (!__experimentalValidateInput(token)) {
(0,external_wp_a11y_namespaceObject.speak)(messages.__experimentalInvalid, "assertive");
return;
}
addNewTokens([token]);
(0,external_wp_a11y_namespaceObject.speak)(messages.added, "assertive");
setIncompleteTokenValue("");
setSelectedSuggestionIndex(-1);
setSelectedSuggestionScroll(false);
setIsExpanded(!__experimentalExpandOnFocus);
if (isActive && !tokenizeOnBlur) {
focus();
}
}
function deleteToken(token) {
const newTokens = value.filter((item) => {
return getTokenValue(item) !== getTokenValue(token);
});
onChange(newTokens);
(0,external_wp_a11y_namespaceObject.speak)(messages.removed, "assertive");
}
function getTokenValue(token) {
if ("object" === typeof token) {
return token.value;
}
return token;
}
function getMatchingSuggestions(searchValue = incompleteTokenValue, _suggestions = suggestions, _value = value, _maxSuggestions = maxSuggestions, _saveTransform = saveTransform) {
let match = _saveTransform(searchValue);
const startsWithMatch = [];
const containsMatch = [];
const normalizedValue = _value.map((item) => {
if (typeof item === "string") {
return item;
}
return item.value;
});
if (match.length === 0) {
_suggestions = _suggestions.filter((suggestion) => !normalizedValue.includes(suggestion));
} else {
match = match.normalize("NFKC").toLocaleLowerCase();
_suggestions.forEach((suggestion) => {
const index = suggestion.normalize("NFKC").toLocaleLowerCase().indexOf(match);
if (normalizedValue.indexOf(suggestion) === -1) {
if (index === 0) {
startsWithMatch.push(suggestion);
} else if (index > 0) {
containsMatch.push(suggestion);
}
}
});
_suggestions = startsWithMatch.concat(containsMatch);
}
return _suggestions.slice(0, _maxSuggestions);
}
function getSelectedSuggestion() {
if (selectedSuggestionIndex !== -1) {
return getMatchingSuggestions()[selectedSuggestionIndex];
}
return void 0;
}
function valueContainsToken(token) {
return value.some((item) => {
return getTokenValue(token) === getTokenValue(item);
});
}
function getIndexOfInput() {
return value.length - inputOffsetFromEnd;
}
function isInputEmpty() {
return incompleteTokenValue.length === 0;
}
function inputHasValidValue() {
return saveTransform(incompleteTokenValue).length > 0;
}
function updateSuggestions(resetSelectedSuggestion = true) {
const inputHasMinimumChars = incompleteTokenValue.trim().length > 1;
const matchingSuggestions2 = getMatchingSuggestions(incompleteTokenValue);
const hasMatchingSuggestions = matchingSuggestions2.length > 0;
const shouldExpandIfFocuses = hasFocus() && __experimentalExpandOnFocus;
setIsExpanded(shouldExpandIfFocuses || inputHasMinimumChars && hasMatchingSuggestions);
if (resetSelectedSuggestion) {
if (__experimentalAutoSelectFirstMatch && inputHasMinimumChars && hasMatchingSuggestions) {
setSelectedSuggestionIndex(0);
setSelectedSuggestionScroll(true);
} else {
setSelectedSuggestionIndex(-1);
setSelectedSuggestionScroll(false);
}
}
if (inputHasMinimumChars) {
const message = hasMatchingSuggestions ? (0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: %d: number of results. */
(0,external_wp_i18n_namespaceObject._n)("%d result found, use up and down arrow keys to navigate.", "%d results found, use up and down arrow keys to navigate.", matchingSuggestions2.length),
matchingSuggestions2.length
) : (0,external_wp_i18n_namespaceObject.__)("No results.");
debouncedSpeak(message, "assertive");
}
}
function renderTokensAndInput() {
const components = value.map(renderToken);
components.splice(getIndexOfInput(), 0, renderInput());
return components;
}
function renderToken(token, index, tokens) {
const _value = getTokenValue(token);
const status = typeof token !== "string" ? token.status : void 0;
const termPosition = index + 1;
const termsCount = tokens.length;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_item_component_component_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Token, {
value: _value,
status,
title: typeof token !== "string" ? token.title : void 0,
displayTransform,
onClickRemove: onTokenClickRemove,
isBorderless: typeof token !== "string" && token.isBorderless || isBorderless,
onMouseEnter: typeof token !== "string" ? token.onMouseEnter : void 0,
onMouseLeave: typeof token !== "string" ? token.onMouseLeave : void 0,
disabled: "error" !== status && disabled,
messages,
termsCount,
termPosition
})
}, "token-" + _value);
}
function renderInput() {
const inputProps = {
instanceId,
autoCapitalize,
autoComplete,
placeholder: value.length === 0 ? placeholder : "",
disabled,
value: incompleteTokenValue,
onBlur,
isExpanded,
selectedSuggestionIndex
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(token_input_default, {
...inputProps,
onChange: !(maxLength && value.length >= maxLength) ? onInputChangeHandler : void 0,
ref: input
}, "input");
}
const classes = dist_clsx(className, "components-form-token-field__input-container", {
"is-active": isActive,
"is-disabled": disabled
});
let tokenFieldProps = {
className: "components-form-token-field",
tabIndex: -1
};
const matchingSuggestions = getMatchingSuggestions();
if (!disabled) {
tokenFieldProps = Object.assign({}, tokenFieldProps, {
onKeyDown: withIgnoreIMEEvents(onKeyDown),
onKeyPress,
onFocus: onFocusHandler
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
...tokenFieldProps,
children: [label && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledLabel, {
htmlFor: `components-form-token-input-${instanceId}`,
className: "components-form-token-field__label",
children: label
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
ref: tokensAndInput,
className: classes,
tabIndex: -1,
onMouseDown: onContainerTouched,
onTouchStart: onContainerTouched,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TokensAndInputWrapperFlex, {
justify: "flex-start",
align: "center",
gap: 1,
wrap: true,
__next40pxDefaultSize,
hasTokens: !!value.length,
children: renderTokensAndInput()
}), isExpanded && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(suggestions_list_default, {
instanceId,
match: saveTransform(incompleteTokenValue),
displayTransform,
suggestions: matchingSuggestions,
selectedIndex: selectedSuggestionIndex,
scrollIntoView: selectedSuggestionScroll,
onHover: onSuggestionHovered,
onSelect: onSuggestionSelected,
__experimentalRenderItem
})]
}), !__nextHasNoMarginBottom && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spacer_component_component_default, {
marginBottom: 2
}), __experimentalShowHowTo && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledHelp, {
id: `components-form-token-suggestions-howto-${instanceId}`,
className: "components-form-token-field__help",
__nextHasNoMarginBottom,
children: tokenizeOnSpace ? (0,external_wp_i18n_namespaceObject.__)("Separate with commas, spaces, or the Enter key.") : (0,external_wp_i18n_namespaceObject.__)("Separate with commas or the Enter key.")
})]
});
}
var form_token_field_default = FormTokenField;
;// ./node_modules/@wordpress/components/build-module/guide/icons.js
const PageControlIcon = () => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
width: "8",
height: "8",
fill: "none",
xmlns: "http://www.w3.org/2000/svg",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Circle, {
cx: "4",
cy: "4",
r: "4"
})
});
;// ./node_modules/@wordpress/components/build-module/guide/page-control.js
function PageControl({
currentPage,
numberOfPages,
setCurrentPage
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("ul", {
className: "components-guide__page-control",
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Guide controls"),
children: Array.from({
length: numberOfPages
}).map((_, page) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("li", {
// Set aria-current="step" on the active page, see https://www.w3.org/TR/wai-aria-1.1/#aria-current
"aria-current": page === currentPage ? "step" : void 0,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "small",
icon: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PageControlIcon, {}),
"aria-label": (0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: 1: current page number 2: total number of pages */
(0,external_wp_i18n_namespaceObject.__)("Page %1$d of %2$d"),
page + 1,
numberOfPages
),
onClick: () => setCurrentPage(page)
}, page)
}, page))
});
}
;// ./node_modules/@wordpress/components/build-module/guide/index.js
function Guide({
children,
className,
contentLabel,
finishButtonText = (0,external_wp_i18n_namespaceObject.__)("Finish"),
nextButtonText = (0,external_wp_i18n_namespaceObject.__)("Next"),
previousButtonText = (0,external_wp_i18n_namespaceObject.__)("Previous"),
onFinish,
pages = []
}) {
const ref = (0,external_wp_element_namespaceObject.useRef)(null);
const [currentPage, setCurrentPage] = (0,external_wp_element_namespaceObject.useState)(0);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const frame = ref.current?.querySelector(".components-guide");
if (frame instanceof HTMLElement) {
frame.focus();
}
}, [currentPage]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (external_wp_element_namespaceObject.Children.count(children)) {
external_wp_deprecated_default()("Passing children to <Guide>", {
since: "5.5",
alternative: "the `pages` prop"
});
}
}, [children]);
if (external_wp_element_namespaceObject.Children.count(children)) {
var _Children$map;
pages = (_Children$map = external_wp_element_namespaceObject.Children.map(children, (child) => ({
content: child
}))) !== null && _Children$map !== void 0 ? _Children$map : [];
}
const canGoBack = currentPage > 0;
const canGoForward = currentPage < pages.length - 1;
const goBack = () => {
if (canGoBack) {
setCurrentPage(currentPage - 1);
}
};
const goForward = () => {
if (canGoForward) {
setCurrentPage(currentPage + 1);
}
};
if (pages.length === 0) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(modal_default, {
className: dist_clsx("components-guide", className),
contentLabel,
isDismissible: pages.length > 1,
onRequestClose: onFinish,
onKeyDown: (event) => {
if (event.code === "ArrowLeft") {
goBack();
event.preventDefault();
} else if (event.code === "ArrowRight") {
goForward();
event.preventDefault();
}
},
ref,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-guide__container",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-guide__page",
children: [pages[currentPage].image, pages.length > 1 && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PageControl, {
currentPage,
numberOfPages: pages.length,
setCurrentPage
}), pages[currentPage].content]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-guide__footer",
children: [canGoBack && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
className: "components-guide__back-button",
variant: "tertiary",
onClick: goBack,
__next40pxDefaultSize: true,
children: previousButtonText
}), canGoForward && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
className: "components-guide__forward-button",
variant: "primary",
onClick: goForward,
__next40pxDefaultSize: true,
children: nextButtonText
}), !canGoForward && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
className: "components-guide__finish-button",
variant: "primary",
onClick: onFinish,
__next40pxDefaultSize: true,
children: finishButtonText
})]
})]
})
});
}
var guide_default = Guide;
;// ./node_modules/@wordpress/components/build-module/guide/page.js
function GuidePage(props) {
(0,external_wp_element_namespaceObject.useEffect)(() => {
external_wp_deprecated_default()("<GuidePage>", {
since: "5.5",
alternative: "the `pages` prop in <Guide>"
});
}, []);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...props
});
}
;// ./node_modules/@wordpress/components/build-module/button/deprecated.js
function UnforwardedIconButton({
label,
labelPosition,
size,
tooltip,
...props
}, ref) {
external_wp_deprecated_default()("wp.components.IconButton", {
since: "5.4",
alternative: "wp.components.Button",
version: "6.2"
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
...props,
ref,
tooltipPosition: labelPosition,
iconSize: size,
showTooltip: tooltip !== void 0 ? !!tooltip : void 0,
label: tooltip || label
});
}
var deprecated_default = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedIconButton);
;// ./node_modules/@wordpress/components/build-module/keyboard-shortcuts/index.js
function KeyboardShortcut({
target,
callback,
shortcut,
bindGlobal,
eventName
}) {
(0,external_wp_compose_namespaceObject.useKeyboardShortcut)(shortcut, callback, {
bindGlobal,
target,
eventName
});
return null;
}
function KeyboardShortcuts({
children,
shortcuts,
bindGlobal,
eventName
}) {
const target = (0,external_wp_element_namespaceObject.useRef)(null);
const element = Object.entries(shortcuts !== null && shortcuts !== void 0 ? shortcuts : {}).map(([shortcut, callback]) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(KeyboardShortcut, {
shortcut,
callback,
bindGlobal,
eventName,
target
}, shortcut));
if (!external_wp_element_namespaceObject.Children.count(children)) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: element
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
ref: target,
children: [element, children]
});
}
var keyboard_shortcuts_default = KeyboardShortcuts;
;// ./node_modules/@wordpress/components/build-module/menu-group/index.js
function MenuGroup(props) {
const {
children,
className = "",
label,
hideSeparator
} = props;
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(MenuGroup);
if (!external_wp_element_namespaceObject.Children.count(children)) {
return null;
}
const labelId = `components-menu-group-label-${instanceId}`;
const classNames = dist_clsx(className, "components-menu-group", {
"has-hidden-separator": hideSeparator
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: classNames,
children: [label && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-menu-group__label",
id: labelId,
"aria-hidden": "true",
children: label
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
role: "group",
"aria-labelledby": label ? labelId : void 0,
children
})]
});
}
var menu_group_default = MenuGroup;
;// ./node_modules/@wordpress/components/build-module/menu-item/index.js
function UnforwardedMenuItem(props, ref) {
let {
children,
info,
className,
icon,
iconPosition = "right",
shortcut,
isSelected,
role = "menuitem",
suffix,
...buttonProps
} = props;
className = dist_clsx("components-menu-item__button", className);
if (info) {
children = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
className: "components-menu-item__info-wrapper",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-menu-item__item",
children
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-menu-item__info",
children: info
})]
});
}
if (icon && typeof icon !== "string") {
icon = (0,external_wp_element_namespaceObject.cloneElement)(icon, {
className: dist_clsx("components-menu-items__item-icon", {
"has-icon-right": iconPosition === "right"
})
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(button_default, {
__next40pxDefaultSize: true,
ref,
"aria-checked": role === "menuitemcheckbox" || role === "menuitemradio" ? isSelected : void 0,
role,
icon: iconPosition === "left" ? icon : void 0,
className,
accessibleWhenDisabled: true,
...buttonProps,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-menu-item__item",
children
}), !suffix && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(shortcut_default, {
className: "components-menu-item__shortcut",
shortcut
}), !suffix && icon && iconPosition === "right" && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon
}), suffix]
});
}
const MenuItem = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedMenuItem);
var menu_item_default = MenuItem;
;// ./node_modules/@wordpress/components/build-module/menu-items-choice/index.js
const menu_items_choice_noop = () => {
};
function MenuItemsChoice({
choices = [],
onHover = menu_items_choice_noop,
onSelect,
value
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: choices.map((item) => {
const isSelected = value === item.value;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_item_default, {
role: "menuitemradio",
disabled: item.disabled,
icon: isSelected ? check_default : null,
info: item.info,
isSelected,
shortcut: item.shortcut,
className: "components-menu-items-choice",
onClick: () => {
if (!isSelected) {
onSelect(item.value);
}
},
onMouseEnter: () => onHover(item.value),
onMouseLeave: () => onHover(null),
"aria-label": item["aria-label"],
children: item.label
}, item.value);
})
});
}
var menu_items_choice_default = MenuItemsChoice;
;// ./node_modules/@wordpress/components/build-module/navigable-container/tabbable.js
function UnforwardedTabbableContainer({
eventToOffset,
...props
}, ref) {
const innerEventToOffset = (evt) => {
const {
code,
shiftKey
} = evt;
if ("Tab" === code) {
return shiftKey ? -1 : 1;
}
if (eventToOffset) {
return eventToOffset(evt);
}
return void 0;
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(container_default, {
ref,
stopNavigationEvents: true,
onlyBrowserTabstops: true,
eventToOffset: innerEventToOffset,
...props
});
}
const TabbableContainer = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTabbableContainer);
var tabbable_default = TabbableContainer;
;// ./node_modules/@wordpress/components/build-module/navigation/constants.js
const ROOT_MENU = "root";
const SEARCH_FOCUS_DELAY = 100;
;// ./node_modules/@wordpress/components/build-module/navigation/context.js
const context_noop = () => {
};
const defaultIsEmpty = () => false;
const defaultGetter = () => void 0;
const NavigationContext = (0,external_wp_element_namespaceObject.createContext)({
activeItem: void 0,
activeMenu: ROOT_MENU,
setActiveMenu: context_noop,
navigationTree: {
items: {},
getItem: defaultGetter,
addItem: context_noop,
removeItem: context_noop,
menus: {},
getMenu: defaultGetter,
addMenu: context_noop,
removeMenu: context_noop,
childMenu: {},
traverseMenu: context_noop,
isMenuEmpty: defaultIsEmpty
}
});
NavigationContext.displayName = "NavigationContext";
const useNavigationContext = () => (0,external_wp_element_namespaceObject.useContext)(NavigationContext);
;// ./node_modules/@wordpress/components/build-module/navigation/styles/navigation-styles.js
function navigation_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const NavigationUI = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeiismy11"
} : 0)("width:100%;box-sizing:border-box;padding:0 ", space(4), ";overflow:hidden;" + ( true ? "" : 0));
const MenuUI = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeiismy10"
} : 0)("margin-top:", space(6), ";margin-bottom:", space(6), ";display:flex;flex-direction:column;ul{padding:0;margin:0;list-style:none;}.components-navigation__back-button{margin-bottom:", space(6), ";}.components-navigation__group+.components-navigation__group{margin-top:", space(6), ";}" + ( true ? "" : 0));
const MenuBackButtonUI = /* @__PURE__ */ emotion_styled_base_browser_esm(button_default, true ? {
target: "eeiismy9"
} : 0)( true ? {
name: "26l0q2",
styles: "&.is-tertiary{color:inherit;opacity:0.7;&:hover:not( :disabled ){opacity:1;box-shadow:none;color:inherit;}&:active:not( :disabled ){background:transparent;opacity:1;color:inherit;}}"
} : 0);
const MenuTitleUI = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeiismy8"
} : 0)( true ? {
name: "1aubja5",
styles: "overflow:hidden;width:100%"
} : 0);
const MenuTitleSearchControlWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeiismy7"
} : 0)( true ? {
name: "rgorny",
styles: "margin:11px 0;padding:1px"
} : 0);
const MenuTitleActionsUI = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "eeiismy6"
} : 0)("height:", space(6), ";.components-button.is-small{color:inherit;opacity:0.7;margin-right:", space(1), ";padding:0;&:active:not( :disabled ){background:none;opacity:1;color:inherit;}&:hover:not( :disabled ){box-shadow:none;opacity:1;color:inherit;}}" + ( true ? "" : 0));
const GroupTitleUI = /* @__PURE__ */ emotion_styled_base_browser_esm(heading_component_component_default, true ? {
target: "eeiismy5"
} : 0)("min-height:", space(12), ";align-items:center;color:inherit;display:flex;justify-content:space-between;margin-bottom:", space(2), ";padding:", () => (0,external_wp_i18n_namespaceObject.isRTL)() ? `${space(1)} ${space(4)} ${space(1)} ${space(2)}` : `${space(1)} ${space(2)} ${space(1)} ${space(4)}`, ";" + ( true ? "" : 0));
const ItemBaseUI = /* @__PURE__ */ emotion_styled_base_browser_esm("li", true ? {
target: "eeiismy4"
} : 0)("border-radius:", config_values_default.radiusSmall, ";color:inherit;margin-bottom:0;>button,>a.components-button,>a{width:100%;color:inherit;opacity:0.7;padding:", space(2), " ", space(4), ";", rtl({
textAlign: "left"
}, {
textAlign: "right"
}), " &:hover,&:focus:not( [aria-disabled='true'] ):active,&:active:not( [aria-disabled='true'] ):active{color:inherit;opacity:1;}}&.is-active{background-color:", COLORS.theme.accent, ";color:", COLORS.theme.accentInverted, ";>button,.components-button:hover,>a{color:", COLORS.theme.accentInverted, ";opacity:1;}}>svg path{color:", COLORS.gray[600], ";}" + ( true ? "" : 0));
const ItemUI = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "eeiismy3"
} : 0)("display:flex;align-items:center;height:auto;min-height:40px;margin:0;padding:", space(1.5), " ", space(4), ";font-weight:400;line-height:20px;width:100%;color:inherit;opacity:0.7;" + ( true ? "" : 0));
const ItemIconUI = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "eeiismy2"
} : 0)("display:flex;margin-right:", space(2), ";" + ( true ? "" : 0));
const ItemBadgeUI = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "eeiismy1"
} : 0)("margin-left:", () => (0,external_wp_i18n_namespaceObject.isRTL)() ? "0" : space(2), ";margin-right:", () => (0,external_wp_i18n_namespaceObject.isRTL)() ? space(2) : "0", ";display:inline-flex;padding:", space(1), " ", space(3), ";border-radius:", config_values_default.radiusSmall, ";@keyframes fade-in{from{opacity:0;}to{opacity:1;}}@media not ( prefers-reduced-motion ){animation:fade-in 250ms ease-out;}" + ( true ? "" : 0));
const ItemTitleUI = /* @__PURE__ */ emotion_styled_base_browser_esm(text_component_component_default, true ? {
target: "eeiismy0"
} : 0)(() => (0,external_wp_i18n_namespaceObject.isRTL)() ? "margin-left: auto;" : "margin-right: auto;", " font-size:14px;line-height:20px;color:inherit;" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/navigation/use-navigation-tree-nodes.js
function useNavigationTreeNodes() {
const [nodes, setNodes] = (0,external_wp_element_namespaceObject.useState)({});
const getNode = (key) => nodes[key];
const addNode = (key, value) => {
const {
children,
...newNode
} = value;
return setNodes((original) => ({
...original,
[key]: newNode
}));
};
const removeNode = (key) => {
return setNodes((original) => {
const {
[key]: removedNode,
...remainingNodes
} = original;
return remainingNodes;
});
};
return {
nodes,
getNode,
addNode,
removeNode
};
}
;// ./node_modules/@wordpress/components/build-module/navigation/use-create-navigation-tree.js
const useCreateNavigationTree = () => {
const {
nodes: items,
getNode: getItem,
addNode: addItem,
removeNode: removeItem
} = useNavigationTreeNodes();
const {
nodes: menus,
getNode: getMenu,
addNode: addMenu,
removeNode: removeMenu
} = useNavigationTreeNodes();
const [childMenu, setChildMenu] = (0,external_wp_element_namespaceObject.useState)({});
const getChildMenu = (menu) => childMenu[menu] || [];
const traverseMenu = (startMenu, callback) => {
const visited = [];
let queue = [startMenu];
let current;
while (queue.length > 0) {
current = getMenu(queue.shift());
if (!current || visited.includes(current.menu)) {
continue;
}
visited.push(current.menu);
queue = [...queue, ...getChildMenu(current.menu)];
if (callback(current) === false) {
break;
}
}
};
const isMenuEmpty = (menuToCheck) => {
let isEmpty = true;
traverseMenu(menuToCheck, (current) => {
if (!current.isEmpty) {
isEmpty = false;
return false;
}
return void 0;
});
return isEmpty;
};
return {
items,
getItem,
addItem,
removeItem,
menus,
getMenu,
addMenu: (key, value) => {
setChildMenu((state) => {
const newState = {
...state
};
if (!value.parentMenu) {
return newState;
}
if (!newState[value.parentMenu]) {
newState[value.parentMenu] = [];
}
newState[value.parentMenu].push(key);
return newState;
});
addMenu(key, value);
},
removeMenu,
childMenu,
traverseMenu,
isMenuEmpty
};
};
;// ./node_modules/@wordpress/components/build-module/navigation/index.js
const navigation_noop = () => {
};
function Navigation({
activeItem,
activeMenu = ROOT_MENU,
children,
className,
onActivateMenu = navigation_noop
}) {
const [menu, setMenu] = (0,external_wp_element_namespaceObject.useState)(activeMenu);
const [slideOrigin, setSlideOrigin] = (0,external_wp_element_namespaceObject.useState)();
const navigationTree = useCreateNavigationTree();
const defaultSlideOrigin = (0,external_wp_i18n_namespaceObject.isRTL)() ? "right" : "left";
external_wp_deprecated_default()("wp.components.Navigation (and all subcomponents)", {
since: "6.8",
version: "7.1",
alternative: "wp.components.Navigator"
});
const setActiveMenu = (menuId, slideInOrigin = defaultSlideOrigin) => {
if (!navigationTree.getMenu(menuId)) {
return;
}
setSlideOrigin(slideInOrigin);
setMenu(menuId);
onActivateMenu(menuId);
};
const isMountedRef = (0,external_wp_element_namespaceObject.useRef)(false);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!isMountedRef.current) {
isMountedRef.current = true;
}
}, []);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (activeMenu !== menu) {
setActiveMenu(activeMenu);
}
}, [activeMenu]);
const context = {
activeItem,
activeMenu: menu,
setActiveMenu,
navigationTree
};
const classes = dist_clsx("components-navigation", className);
const animateClassName = getAnimateClassName({
type: "slide-in",
origin: slideOrigin
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationUI, {
className: classes,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: animateClassName ? dist_clsx({
[animateClassName]: isMountedRef.current && slideOrigin
}) : void 0,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationContext.Provider, {
value: context,
children
})
}, menu)
});
}
var navigation_default = Navigation;
;// ./node_modules/@wordpress/icons/build-module/library/chevron-right.js
var chevron_right_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M10.6 6L9.4 7l4.6 5-4.6 5 1.2 1 5.4-6z" }) });
;// ./node_modules/@wordpress/icons/build-module/library/chevron-left.js
var chevron_left_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M14.6 7l-1.2-1L8 12l5.4 6 1.2-1-4.6-5z" }) });
;// ./node_modules/@wordpress/components/build-module/navigation/back-button/index.js
function UnforwardedNavigationBackButton({
backButtonLabel,
className,
href,
onClick,
parentMenu
}, ref) {
const {
setActiveMenu,
navigationTree
} = useNavigationContext();
const classes = dist_clsx("components-navigation__back-button", className);
const parentMenuTitle = parentMenu !== void 0 ? navigationTree.getMenu(parentMenu)?.title : void 0;
const handleOnClick = (event) => {
if (typeof onClick === "function") {
onClick(event);
}
const animationDirection = (0,external_wp_i18n_namespaceObject.isRTL)() ? "left" : "right";
if (parentMenu && !event.defaultPrevented) {
setActiveMenu(parentMenu, animationDirection);
}
};
const icon = (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_right_default : chevron_left_default;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(MenuBackButtonUI, {
__next40pxDefaultSize: true,
className: classes,
href,
variant: "tertiary",
ref,
onClick: handleOnClick,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon
}), backButtonLabel || parentMenuTitle || (0,external_wp_i18n_namespaceObject.__)("Back")]
});
}
const NavigationBackButton = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedNavigationBackButton);
var back_button_default = NavigationBackButton;
;// ./node_modules/@wordpress/components/build-module/navigation/group/context.js
const NavigationGroupContext = (0,external_wp_element_namespaceObject.createContext)({
group: void 0
});
NavigationGroupContext.displayName = "NavigationGroupContext";
const useNavigationGroupContext = () => (0,external_wp_element_namespaceObject.useContext)(NavigationGroupContext);
;// ./node_modules/@wordpress/components/build-module/navigation/group/index.js
let uniqueId = 0;
function NavigationGroup({
children,
className,
title
}) {
const [groupId] = (0,external_wp_element_namespaceObject.useState)(`group-${++uniqueId}`);
const {
navigationTree: {
items
}
} = useNavigationContext();
const context = {
group: groupId
};
if (!Object.values(items).some((item) => item.group === groupId && item._isVisible)) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationGroupContext.Provider, {
value: context,
children
});
}
const groupTitleId = `components-navigation__group-title-${groupId}`;
const classes = dist_clsx("components-navigation__group", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationGroupContext.Provider, {
value: context,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("li", {
className: classes,
children: [title && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(GroupTitleUI, {
className: "components-navigation__group-title",
id: groupTitleId,
level: 3,
children: title
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("ul", {
"aria-labelledby": groupTitleId,
role: "group",
children
})]
})
});
}
var group_default = NavigationGroup;
;// ./node_modules/@wordpress/components/build-module/navigation/item/base-content.js
function NavigationItemBaseContent(props) {
const {
badge,
title
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [title && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemTitleUI, {
className: "components-navigation__item-title",
as: "span",
children: title
}), badge && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemBadgeUI, {
className: "components-navigation__item-badge",
children: badge
})]
});
}
;// ./node_modules/@wordpress/components/build-module/navigation/menu/context.js
const NavigationMenuContext = (0,external_wp_element_namespaceObject.createContext)({
menu: void 0,
search: ""
});
NavigationMenuContext.displayName = "NavigationMenuContext";
const useNavigationMenuContext = () => (0,external_wp_element_namespaceObject.useContext)(NavigationMenuContext);
;// ./node_modules/@wordpress/components/build-module/navigation/utils.js
const normalizeInput = (input) => remove_accents_default()(input).replace(/^\//, "").toLowerCase();
const normalizedSearch = (title, search) => -1 !== normalizeInput(title).indexOf(normalizeInput(search));
;// ./node_modules/@wordpress/components/build-module/navigation/item/use-navigation-tree-item.js
const useNavigationTreeItem = (itemId, props) => {
const {
activeMenu,
navigationTree: {
addItem,
removeItem
}
} = useNavigationContext();
const {
group
} = useNavigationGroupContext();
const {
menu,
search
} = useNavigationMenuContext();
(0,external_wp_element_namespaceObject.useEffect)(() => {
const isMenuActive = activeMenu === menu;
const isItemVisible = !search || props.title !== void 0 && normalizedSearch(props.title, search);
addItem(itemId, {
...props,
group,
menu,
_isVisible: isMenuActive && isItemVisible
});
return () => {
removeItem(itemId);
};
}, [activeMenu, search]);
};
;// ./node_modules/@wordpress/components/build-module/navigation/item/base.js
let base_uniqueId = 0;
function NavigationItemBase(props) {
const {
children,
className,
title,
href,
...restProps
} = props;
const [itemId] = (0,external_wp_element_namespaceObject.useState)(`item-${++base_uniqueId}`);
useNavigationTreeItem(itemId, props);
const {
navigationTree
} = useNavigationContext();
if (!navigationTree.getItem(itemId)?._isVisible) {
return null;
}
const classes = dist_clsx("components-navigation__item", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemBaseUI, {
className: classes,
...restProps,
children
});
}
;// ./node_modules/@wordpress/components/build-module/navigation/item/index.js
const item_noop = () => {
};
function NavigationItem(props) {
const {
badge,
children,
className,
href,
item,
navigateToMenu,
onClick = item_noop,
title,
icon,
hideIfTargetMenuEmpty,
isText,
...restProps
} = props;
const {
activeItem,
setActiveMenu,
navigationTree: {
isMenuEmpty
}
} = useNavigationContext();
if (hideIfTargetMenuEmpty && navigateToMenu && isMenuEmpty(navigateToMenu)) {
return null;
}
const isActive = item && activeItem === item;
const classes = dist_clsx(className, {
"is-active": isActive
});
const onItemClick = (event) => {
if (navigateToMenu) {
setActiveMenu(navigateToMenu);
}
onClick(event);
};
const navigationIcon = (0,external_wp_i18n_namespaceObject.isRTL)() ? chevron_left_default : chevron_right_default;
const baseProps = children ? props : {
...props,
onClick: void 0
};
const itemProps = isText ? restProps : {
as: button_default,
__next40pxDefaultSize: "as" in restProps ? restProps.as === void 0 : true,
href,
onClick: onItemClick,
"aria-current": isActive ? "page" : void 0,
...restProps
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationItemBase, {
...baseProps,
className: classes,
children: children || /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ItemUI, {
...itemProps,
children: [icon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemIconUI, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationItemBaseContent, {
title,
badge
}), navigateToMenu && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: navigationIcon
})]
})
});
}
var item_item_default = NavigationItem;
;// ./node_modules/@wordpress/components/build-module/navigation/menu/use-navigation-tree-menu.js
const useNavigationTreeMenu = (props) => {
const {
navigationTree: {
addMenu,
removeMenu
}
} = useNavigationContext();
const key = props.menu || ROOT_MENU;
(0,external_wp_element_namespaceObject.useEffect)(() => {
addMenu(key, {
...props,
menu: key
});
return () => {
removeMenu(key);
};
}, []);
};
;// ./node_modules/@wordpress/icons/build-module/library/search.js
var search_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M13 5c-3.3 0-6 2.7-6 6 0 1.4.5 2.7 1.3 3.7l-3.8 3.8 1.1 1.1 3.8-3.8c1 .8 2.3 1.3 3.7 1.3 3.3 0 6-2.7 6-6S16.3 5 13 5zm0 10.5c-2.5 0-4.5-2-4.5-4.5s2-4.5 4.5-4.5 4.5 2 4.5 4.5-2 4.5-4.5 4.5z" }) });
;// ./node_modules/@wordpress/components/build-module/higher-order/with-spoken-messages/index.js
var with_spoken_messages_default = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((Component) => (props) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
...props,
speak: external_wp_a11y_namespaceObject.speak,
debouncedSpeak: (0,external_wp_compose_namespaceObject.useDebounce)(external_wp_a11y_namespaceObject.speak, 500)
}), "withSpokenMessages");
;// ./node_modules/@wordpress/components/build-module/search-control/styles.js
function search_control_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const StyledInputControl = /* @__PURE__ */ emotion_styled_base_browser_esm(input_control_default, true ? {
target: "effl84m1"
} : 0)( true ? {
name: "37btb2",
styles: "input[type='search']{&::-webkit-search-decoration,&::-webkit-search-cancel-button,&::-webkit-search-results-button,&::-webkit-search-results-decoration{-webkit-appearance:none;}}"
} : 0);
const StyledIcon = /* @__PURE__ */ emotion_styled_base_browser_esm(icon_icon_default, true ? {
target: "effl84m0"
} : 0)( true ? {
name: "1i54h4p",
styles: "&:dir( ltr ){transform:scaleX( -1 );}"
} : 0);
;// ./node_modules/@wordpress/components/build-module/search-control/index.js
function SuffixItem({
searchRef,
value,
onChange,
onClose
}) {
if (!onClose && !value) {
return null;
}
if (onClose) {
external_wp_deprecated_default()("`onClose` prop in wp.components.SearchControl", {
since: "6.8"
});
}
const onReset = () => {
onChange("");
searchRef.current?.focus();
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputControlSuffixWrapper, {
variant: "control",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "small",
icon: close_small_default,
label: onClose ? (0,external_wp_i18n_namespaceObject.__)("Close search") : (0,external_wp_i18n_namespaceObject.__)("Reset search"),
onClick: onClose !== null && onClose !== void 0 ? onClose : onReset
})
});
}
function UnforwardedSearchControl({
__nextHasNoMarginBottom = false,
className,
onChange,
value,
label = (0,external_wp_i18n_namespaceObject.__)("Search"),
placeholder = (0,external_wp_i18n_namespaceObject.__)("Search"),
hideLabelFromVision = true,
onClose,
size = "default",
...restProps
}, forwardedRef) {
const {
disabled,
...filteredRestProps
} = restProps;
const searchRef = (0,external_wp_element_namespaceObject.useRef)(null);
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(SearchControl, "components-search-control");
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
BaseControl: {
// Overrides the underlying BaseControl `__nextHasNoMarginBottom` via the context system
// to provide backwards compatible margin for SearchControl.
// (In a standard InputControl, the BaseControl `__nextHasNoMarginBottom` is always set to true.)
_overrides: {
__nextHasNoMarginBottom
},
__associatedWPComponentName: "SearchControl"
}
}), [__nextHasNoMarginBottom]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ContextSystemProvider, {
value: contextValue,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledInputControl, {
__next40pxDefaultSize: true,
id: instanceId,
hideLabelFromVision,
label,
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([searchRef, forwardedRef]),
type: "search",
size,
className: dist_clsx("components-search-control", className),
onChange: (nextValue) => onChange(nextValue !== null && nextValue !== void 0 ? nextValue : ""),
autoComplete: "off",
placeholder,
value: value !== null && value !== void 0 ? value : "",
prefix: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(InputControlPrefixWrapper, {
variant: "icon",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledIcon, {
icon: search_default,
fill: "currentColor"
})
}),
suffix: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SuffixItem, {
searchRef,
value,
onChange,
onClose
}),
...filteredRestProps
})
});
}
const SearchControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedSearchControl);
var search_control_default = SearchControl;
;// ./node_modules/@wordpress/components/build-module/navigation/menu/menu-title-search.js
function MenuTitleSearch({
debouncedSpeak,
onCloseSearch,
onSearch,
search,
title
}) {
const {
navigationTree: {
items
}
} = useNavigationContext();
const {
menu
} = useNavigationMenuContext();
const inputRef = (0,external_wp_element_namespaceObject.useRef)(null);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const delayedFocus = setTimeout(() => {
inputRef.current?.focus();
}, SEARCH_FOCUS_DELAY);
return () => {
clearTimeout(delayedFocus);
};
}, []);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!search) {
return;
}
const count = Object.values(items).filter((item) => item._isVisible).length;
const resultsFoundMessage = (0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: %d: number of results. */
(0,external_wp_i18n_namespaceObject._n)("%d result found.", "%d results found.", count),
count
);
debouncedSpeak(resultsFoundMessage);
}, [items, search]);
const onClose = () => {
onSearch?.("");
onCloseSearch();
};
const onKeyDown = (event) => {
if (event.code === "Escape" && !event.defaultPrevented) {
event.preventDefault();
onClose();
}
};
const inputId = `components-navigation__menu-title-search-${menu}`;
const placeholder = (0,external_wp_i18n_namespaceObject.sprintf)(
/* translators: placeholder for menu search box. %s: menu title */
(0,external_wp_i18n_namespaceObject.__)("Search %s"),
title?.toLowerCase() || ""
).trim();
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MenuTitleSearchControlWrapper, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(search_control_default, {
__nextHasNoMarginBottom: true,
className: "components-navigation__menu-search-input",
id: inputId,
onChange: (value) => onSearch?.(value),
onKeyDown,
placeholder,
onClose,
ref: inputRef,
value: search
})
});
}
var menu_title_search_default = with_spoken_messages_default(MenuTitleSearch);
;// ./node_modules/@wordpress/components/build-module/navigation/menu/menu-title.js
function NavigationMenuTitle({
hasSearch,
onSearch,
search,
title,
titleAction
}) {
const [isSearching, setIsSearching] = (0,external_wp_element_namespaceObject.useState)(false);
const {
menu
} = useNavigationMenuContext();
const searchButtonRef = (0,external_wp_element_namespaceObject.useRef)(null);
if (!title) {
return null;
}
const onCloseSearch = () => {
setIsSearching(false);
setTimeout(() => {
searchButtonRef.current?.focus();
}, SEARCH_FOCUS_DELAY);
};
const menuTitleId = `components-navigation__menu-title-${menu}`;
const searchButtonLabel = (0,external_wp_i18n_namespaceObject.sprintf)((0,external_wp_i18n_namespaceObject.__)("Search in %s"), title);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(MenuTitleUI, {
className: "components-navigation__menu-title",
children: [!isSearching && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(GroupTitleUI, {
as: "h2",
className: "components-navigation__menu-title-heading",
level: 3,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
id: menuTitleId,
children: title
}), (hasSearch || titleAction) && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(MenuTitleActionsUI, {
children: [titleAction, hasSearch && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "small",
variant: "tertiary",
label: searchButtonLabel,
onClick: () => setIsSearching(true),
ref: searchButtonRef,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: search_default
})
})]
})]
}), isSearching && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: getAnimateClassName({
type: "slide-in",
origin: "left"
}),
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_title_search_default, {
onCloseSearch,
onSearch,
search,
title
})
})]
});
}
;// ./node_modules/@wordpress/components/build-module/navigation/menu/search-no-results-found.js
function NavigationSearchNoResultsFound({
search
}) {
const {
navigationTree: {
items
}
} = useNavigationContext();
const resultsCount = Object.values(items).filter((item) => item._isVisible).length;
if (!search || !!resultsCount) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemBaseUI, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ItemUI, {
children: [(0,external_wp_i18n_namespaceObject.__)("No results found."), " "]
})
});
}
;// ./node_modules/@wordpress/components/build-module/navigation/menu/index.js
function NavigationMenu(props) {
const {
backButtonLabel,
children,
className,
hasSearch,
menu = ROOT_MENU,
onBackButtonClick,
onSearch: setControlledSearch,
parentMenu,
search: controlledSearch,
isSearchDebouncing,
title,
titleAction
} = props;
const [uncontrolledSearch, setUncontrolledSearch] = (0,external_wp_element_namespaceObject.useState)("");
useNavigationTreeMenu(props);
const {
activeMenu
} = useNavigationContext();
const context = {
menu,
search: uncontrolledSearch
};
if (activeMenu !== menu) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationMenuContext.Provider, {
value: context,
children
});
}
const isControlledSearch = !!setControlledSearch;
const search = isControlledSearch ? controlledSearch : uncontrolledSearch;
const onSearch = isControlledSearch ? setControlledSearch : setUncontrolledSearch;
const menuTitleId = `components-navigation__menu-title-${menu}`;
const classes = dist_clsx("components-navigation__menu", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationMenuContext.Provider, {
value: context,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(MenuUI, {
className: classes,
children: [(parentMenu || onBackButtonClick) && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(back_button_default, {
backButtonLabel,
parentMenu,
onClick: onBackButtonClick
}), title && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationMenuTitle, {
hasSearch,
onSearch,
search,
title,
titleAction
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_menu_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("ul", {
"aria-labelledby": menuTitleId,
children: [children, search && !isSearchDebouncing && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigationSearchNoResultsFound, {
search
})]
})
})]
})
});
}
var navigation_menu_menu_default = NavigationMenu;
;// ./node_modules/path-to-regexp/dist.es2015/index.js
/**
* Tokenize input string.
*/
function lexer(str) {
var tokens = [];
var i = 0;
while (i < str.length) {
var char = str[i];
if (char === "*" || char === "+" || char === "?") {
tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
continue;
}
if (char === "\\") {
tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
continue;
}
if (char === "{") {
tokens.push({ type: "OPEN", index: i, value: str[i++] });
continue;
}
if (char === "}") {
tokens.push({ type: "CLOSE", index: i, value: str[i++] });
continue;
}
if (char === ":") {
var name = "";
var j = i + 1;
while (j < str.length) {
var code = str.charCodeAt(j);
if (
// `0-9`
(code >= 48 && code <= 57) ||
// `A-Z`
(code >= 65 && code <= 90) ||
// `a-z`
(code >= 97 && code <= 122) ||
// `_`
code === 95) {
name += str[j++];
continue;
}
break;
}
if (!name)
throw new TypeError("Missing parameter name at ".concat(i));
tokens.push({ type: "NAME", index: i, value: name });
i = j;
continue;
}
if (char === "(") {
var count = 1;
var pattern = "";
var j = i + 1;
if (str[j] === "?") {
throw new TypeError("Pattern cannot start with \"?\" at ".concat(j));
}
while (j < str.length) {
if (str[j] === "\\") {
pattern += str[j++] + str[j++];
continue;
}
if (str[j] === ")") {
count--;
if (count === 0) {
j++;
break;
}
}
else if (str[j] === "(") {
count++;
if (str[j + 1] !== "?") {
throw new TypeError("Capturing groups are not allowed at ".concat(j));
}
}
pattern += str[j++];
}
if (count)
throw new TypeError("Unbalanced pattern at ".concat(i));
if (!pattern)
throw new TypeError("Missing pattern at ".concat(i));
tokens.push({ type: "PATTERN", index: i, value: pattern });
i = j;
continue;
}
tokens.push({ type: "CHAR", index: i, value: str[i++] });
}
tokens.push({ type: "END", index: i, value: "" });
return tokens;
}
/**
* Parse a string for the raw tokens.
*/
function dist_es2015_parse(str, options) {
if (options === void 0) { options = {}; }
var tokens = lexer(str);
var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a, _b = options.delimiter, delimiter = _b === void 0 ? "/#?" : _b;
var result = [];
var key = 0;
var i = 0;
var path = "";
var tryConsume = function (type) {
if (i < tokens.length && tokens[i].type === type)
return tokens[i++].value;
};
var mustConsume = function (type) {
var value = tryConsume(type);
if (value !== undefined)
return value;
var _a = tokens[i], nextType = _a.type, index = _a.index;
throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
};
var consumeText = function () {
var result = "";
var value;
while ((value = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR"))) {
result += value;
}
return result;
};
var isSafe = function (value) {
for (var _i = 0, delimiter_1 = delimiter; _i < delimiter_1.length; _i++) {
var char = delimiter_1[_i];
if (value.indexOf(char) > -1)
return true;
}
return false;
};
var safePattern = function (prefix) {
var prev = result[result.length - 1];
var prevText = prefix || (prev && typeof prev === "string" ? prev : "");
if (prev && !prevText) {
throw new TypeError("Must have text between two parameters, missing text after \"".concat(prev.name, "\""));
}
if (!prevText || isSafe(prevText))
return "[^".concat(escapeString(delimiter), "]+?");
return "(?:(?!".concat(escapeString(prevText), ")[^").concat(escapeString(delimiter), "])+?");
};
while (i < tokens.length) {
var char = tryConsume("CHAR");
var name = tryConsume("NAME");
var pattern = tryConsume("PATTERN");
if (name || pattern) {
var prefix = char || "";
if (prefixes.indexOf(prefix) === -1) {
path += prefix;
prefix = "";
}
if (path) {
result.push(path);
path = "";
}
result.push({
name: name || key++,
prefix: prefix,
suffix: "",
pattern: pattern || safePattern(prefix),
modifier: tryConsume("MODIFIER") || "",
});
continue;
}
var value = char || tryConsume("ESCAPED_CHAR");
if (value) {
path += value;
continue;
}
if (path) {
result.push(path);
path = "";
}
var open = tryConsume("OPEN");
if (open) {
var prefix = consumeText();
var name_1 = tryConsume("NAME") || "";
var pattern_1 = tryConsume("PATTERN") || "";
var suffix = consumeText();
mustConsume("CLOSE");
result.push({
name: name_1 || (pattern_1 ? key++ : ""),
pattern: name_1 && !pattern_1 ? safePattern(prefix) : pattern_1,
prefix: prefix,
suffix: suffix,
modifier: tryConsume("MODIFIER") || "",
});
continue;
}
mustConsume("END");
}
return result;
}
/**
* Compile a string to a template function for the path.
*/
function dist_es2015_compile(str, options) {
return tokensToFunction(dist_es2015_parse(str, options), options);
}
/**
* Expose a method for transforming tokens into the path function.
*/
function tokensToFunction(tokens, options) {
if (options === void 0) { options = {}; }
var reFlags = flags(options);
var _a = options.encode, encode = _a === void 0 ? function (x) { return x; } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
// Compile all the tokens into regexps.
var matches = tokens.map(function (token) {
if (typeof token === "object") {
return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
}
});
return function (data) {
var path = "";
for (var i = 0; i < tokens.length; i++) {
var token = tokens[i];
if (typeof token === "string") {
path += token;
continue;
}
var value = data ? data[token.name] : undefined;
var optional = token.modifier === "?" || token.modifier === "*";
var repeat = token.modifier === "*" || token.modifier === "+";
if (Array.isArray(value)) {
if (!repeat) {
throw new TypeError("Expected \"".concat(token.name, "\" to not repeat, but got an array"));
}
if (value.length === 0) {
if (optional)
continue;
throw new TypeError("Expected \"".concat(token.name, "\" to not be empty"));
}
for (var j = 0; j < value.length; j++) {
var segment = encode(value[j], token);
if (validate && !matches[i].test(segment)) {
throw new TypeError("Expected all \"".concat(token.name, "\" to match \"").concat(token.pattern, "\", but got \"").concat(segment, "\""));
}
path += token.prefix + segment + token.suffix;
}
continue;
}
if (typeof value === "string" || typeof value === "number") {
var segment = encode(String(value), token);
if (validate && !matches[i].test(segment)) {
throw new TypeError("Expected \"".concat(token.name, "\" to match \"").concat(token.pattern, "\", but got \"").concat(segment, "\""));
}
path += token.prefix + segment + token.suffix;
continue;
}
if (optional)
continue;
var typeOfMessage = repeat ? "an array" : "a string";
throw new TypeError("Expected \"".concat(token.name, "\" to be ").concat(typeOfMessage));
}
return path;
};
}
/**
* Create path match function from `path-to-regexp` spec.
*/
function dist_es2015_match(str, options) {
var keys = [];
var re = pathToRegexp(str, keys, options);
return regexpToFunction(re, keys, options);
}
/**
* Create a path match function from `path-to-regexp` output.
*/
function regexpToFunction(re, keys, options) {
if (options === void 0) { options = {}; }
var _a = options.decode, decode = _a === void 0 ? function (x) { return x; } : _a;
return function (pathname) {
var m = re.exec(pathname);
if (!m)
return false;
var path = m[0], index = m.index;
var params = Object.create(null);
var _loop_1 = function (i) {
if (m[i] === undefined)
return "continue";
var key = keys[i - 1];
if (key.modifier === "*" || key.modifier === "+") {
params[key.name] = m[i].split(key.prefix + key.suffix).map(function (value) {
return decode(value, key);
});
}
else {
params[key.name] = decode(m[i], key);
}
};
for (var i = 1; i < m.length; i++) {
_loop_1(i);
}
return { path: path, index: index, params: params };
};
}
/**
* Escape a regular expression string.
*/
function escapeString(str) {
return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
}
/**
* Get the flags for a regexp from the options.
*/
function flags(options) {
return options && options.sensitive ? "" : "i";
}
/**
* Pull out keys from a regexp.
*/
function regexpToRegexp(path, keys) {
if (!keys)
return path;
var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
var index = 0;
var execResult = groupsRegex.exec(path.source);
while (execResult) {
keys.push({
// Use parenthesized substring match if available, index otherwise
name: execResult[1] || index++,
prefix: "",
suffix: "",
modifier: "",
pattern: "",
});
execResult = groupsRegex.exec(path.source);
}
return path;
}
/**
* Transform an array into a regexp.
*/
function arrayToRegexp(paths, keys, options) {
var parts = paths.map(function (path) { return pathToRegexp(path, keys, options).source; });
return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
}
/**
* Create a path regexp from string input.
*/
function stringToRegexp(path, keys, options) {
return tokensToRegexp(dist_es2015_parse(path, options), keys, options);
}
/**
* Expose a function for taking tokens and returning a RegExp.
*/
function tokensToRegexp(tokens, keys, options) {
if (options === void 0) { options = {}; }
var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function (x) { return x; } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
var delimiterRe = "[".concat(escapeString(delimiter), "]");
var route = start ? "^" : "";
// Iterate over the tokens and create our regexp string.
for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
var token = tokens_1[_i];
if (typeof token === "string") {
route += escapeString(encode(token));
}
else {
var prefix = escapeString(encode(token.prefix));
var suffix = escapeString(encode(token.suffix));
if (token.pattern) {
if (keys)
keys.push(token);
if (prefix || suffix) {
if (token.modifier === "+" || token.modifier === "*") {
var mod = token.modifier === "*" ? "?" : "";
route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
}
else {
route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
}
}
else {
if (token.modifier === "+" || token.modifier === "*") {
throw new TypeError("Can not repeat \"".concat(token.name, "\" without a prefix and suffix"));
}
route += "(".concat(token.pattern, ")").concat(token.modifier);
}
}
else {
route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
}
}
}
if (end) {
if (!strict)
route += "".concat(delimiterRe, "?");
route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
}
else {
var endToken = tokens[tokens.length - 1];
var isEndDelimited = typeof endToken === "string"
? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1
: endToken === undefined;
if (!strict) {
route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
}
if (!isEndDelimited) {
route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
}
}
return new RegExp(route, flags(options));
}
/**
* Normalize the given path string, returning a regular expression.
*
* An empty array can be passed in for the keys, which will hold the
* placeholder key descriptions. For example, using `/user/:id`, `keys` will
* contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
*/
function pathToRegexp(path, keys, options) {
if (path instanceof RegExp)
return regexpToRegexp(path, keys);
if (Array.isArray(path))
return arrayToRegexp(path, keys, options);
return stringToRegexp(path, keys, options);
}
;// ./node_modules/@wordpress/components/build-module/navigator/utils/router.js
function matchPath(path, pattern) {
const matchingFunction = dist_es2015_match(pattern, {
decode: decodeURIComponent
});
return matchingFunction(path);
}
function patternMatch(path, screens) {
for (const screen of screens) {
const matched = matchPath(path, screen.path);
if (matched) {
return {
params: matched.params,
id: screen.id
};
}
}
return void 0;
}
function findParent(path, screens) {
if (!path.startsWith("/")) {
return void 0;
}
const pathParts = path.split("/");
let parentPath;
while (pathParts.length > 1 && parentPath === void 0) {
pathParts.pop();
const potentialParentPath = pathParts.join("/") === "" ? "/" : pathParts.join("/");
if (screens.find((screen) => {
return matchPath(potentialParentPath, screen.path) !== false;
})) {
parentPath = potentialParentPath;
}
}
return parentPath;
}
;// ./node_modules/@wordpress/components/build-module/navigator/context.js
const context_initialContextValue = {
location: {},
goTo: () => {
},
goBack: () => {
},
goToParent: () => {
},
addScreen: () => {
},
removeScreen: () => {
},
params: {}
};
const NavigatorContext = (0,external_wp_element_namespaceObject.createContext)(context_initialContextValue);
NavigatorContext.displayName = "NavigatorContext";
;// ./node_modules/@wordpress/components/build-module/navigator/styles.js
function navigator_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const navigatorWrapper = true ? {
name: "1br0vvk",
styles: "position:relative;overflow-x:clip;contain:layout;display:grid;grid-template-columns:1fr;grid-template-rows:1fr;align-items:start"
} : 0;
const fadeIn = emotion_react_browser_esm_keyframes({
from: {
opacity: 0
}
});
const fadeOut = emotion_react_browser_esm_keyframes({
to: {
opacity: 0
}
});
const slideFromRight = emotion_react_browser_esm_keyframes({
from: {
transform: "translateX(100px)"
}
});
const slideToLeft = emotion_react_browser_esm_keyframes({
to: {
transform: "translateX(-80px)"
}
});
const slideFromLeft = emotion_react_browser_esm_keyframes({
from: {
transform: "translateX(-100px)"
}
});
const slideToRight = emotion_react_browser_esm_keyframes({
to: {
transform: "translateX(80px)"
}
});
const FADE = {
DURATION: 70,
EASING: "linear",
DELAY: {
IN: 70,
OUT: 40
}
};
const SLIDE = {
DURATION: 300,
EASING: "cubic-bezier(0.33, 0, 0, 1)"
};
const TOTAL_ANIMATION_DURATION = {
IN: Math.max(FADE.DURATION + FADE.DELAY.IN, SLIDE.DURATION),
OUT: Math.max(FADE.DURATION + FADE.DELAY.OUT, SLIDE.DURATION)
};
const ANIMATION_END_NAMES = {
end: {
in: slideFromRight.name,
out: slideToLeft.name
},
start: {
in: slideFromLeft.name,
out: slideToRight.name
}
};
const ANIMATION = {
end: {
in: /* @__PURE__ */ emotion_react_browser_esm_css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.IN, "ms both ", fadeIn, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideFromRight, ";" + ( true ? "" : 0), true ? "" : 0),
out: /* @__PURE__ */ emotion_react_browser_esm_css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.OUT, "ms both ", fadeOut, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideToLeft, ";" + ( true ? "" : 0), true ? "" : 0)
},
start: {
in: /* @__PURE__ */ emotion_react_browser_esm_css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.IN, "ms both ", fadeIn, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideFromLeft, ";" + ( true ? "" : 0), true ? "" : 0),
out: /* @__PURE__ */ emotion_react_browser_esm_css(FADE.DURATION, "ms ", FADE.EASING, " ", FADE.DELAY.OUT, "ms both ", fadeOut, ",", SLIDE.DURATION, "ms ", SLIDE.EASING, " both ", slideToRight, ";" + ( true ? "" : 0), true ? "" : 0)
}
};
const navigatorScreenAnimation = /* @__PURE__ */ emotion_react_browser_esm_css("z-index:1;&[data-animation-type='out']{z-index:0;}@media not ( prefers-reduced-motion ){&:not( [data-skip-animation] ){", ["start", "end"].map((direction) => ["in", "out"].map((type) => /* @__PURE__ */ emotion_react_browser_esm_css("&[data-animation-direction='", direction, "'][data-animation-type='", type, "']{animation:", ANIMATION[direction][type], ";}" + ( true ? "" : 0), true ? "" : 0))), ";}}" + ( true ? "" : 0), true ? "" : 0);
const navigatorScreen = true ? {
name: "14di7zd",
styles: "overflow-x:auto;max-height:100%;box-sizing:border-box;position:relative;grid-column:1/-1;grid-row:1/-1"
} : 0;
;// ./node_modules/@wordpress/components/build-module/navigator/navigator/component.js
function addScreen({
screens
}, screen) {
if (screens.some((s) => s.path === screen.path)) {
true ? external_wp_warning_default()(`Navigator: a screen with path ${screen.path} already exists.
The screen with id ${screen.id} will not be added.`) : 0;
return screens;
}
return [...screens, screen];
}
function removeScreen({
screens
}, screen) {
return screens.filter((s) => s.id !== screen.id);
}
function goTo(state, path, options = {}) {
var _focusSelectorsCopy2;
const {
focusSelectors
} = state;
const currentLocation = {
...state.currentLocation
};
const {
// Default assignments
isBack = false,
skipFocus = false,
// Extract to avoid forwarding
replace,
focusTargetSelector,
// Rest
...restOptions
} = options;
if (currentLocation.path === path) {
return {
currentLocation,
focusSelectors
};
}
let focusSelectorsCopy;
function getFocusSelectorsCopy() {
var _focusSelectorsCopy;
focusSelectorsCopy = (_focusSelectorsCopy = focusSelectorsCopy) !== null && _focusSelectorsCopy !== void 0 ? _focusSelectorsCopy : new Map(state.focusSelectors);
return focusSelectorsCopy;
}
if (focusTargetSelector && currentLocation.path) {
getFocusSelectorsCopy().set(currentLocation.path, focusTargetSelector);
}
let currentFocusSelector;
if (focusSelectors.get(path)) {
if (isBack) {
currentFocusSelector = focusSelectors.get(path);
}
getFocusSelectorsCopy().delete(path);
}
return {
currentLocation: {
...restOptions,
isInitial: false,
path,
isBack,
hasRestoredFocus: false,
focusTargetSelector: currentFocusSelector,
skipFocus
},
focusSelectors: (_focusSelectorsCopy2 = focusSelectorsCopy) !== null && _focusSelectorsCopy2 !== void 0 ? _focusSelectorsCopy2 : focusSelectors
};
}
function goToParent(state, options = {}) {
const {
screens,
focusSelectors
} = state;
const currentLocation = {
...state.currentLocation
};
const currentPath = currentLocation.path;
if (currentPath === void 0) {
return {
currentLocation,
focusSelectors
};
}
const parentPath = findParent(currentPath, screens);
if (parentPath === void 0) {
return {
currentLocation,
focusSelectors
};
}
return goTo(state, parentPath, {
...options,
isBack: true
});
}
function routerReducer(state, action) {
let {
screens,
currentLocation,
matchedPath,
focusSelectors,
...restState
} = state;
switch (action.type) {
case "add":
screens = addScreen(state, action.screen);
break;
case "remove":
screens = removeScreen(state, action.screen);
break;
case "goto":
({
currentLocation,
focusSelectors
} = goTo(state, action.path, action.options));
break;
case "gotoparent":
({
currentLocation,
focusSelectors
} = goToParent(state, action.options));
break;
}
if (screens === state.screens && currentLocation === state.currentLocation) {
return state;
}
const currentPath = currentLocation.path;
matchedPath = currentPath !== void 0 ? patternMatch(currentPath, screens) : void 0;
if (matchedPath && state.matchedPath && matchedPath.id === state.matchedPath.id && external_wp_isShallowEqual_default()(matchedPath.params, state.matchedPath.params)) {
matchedPath = state.matchedPath;
}
return {
...restState,
screens,
currentLocation,
matchedPath,
focusSelectors
};
}
function UnconnectedNavigator(props, forwardedRef) {
const {
initialPath: initialPathProp,
children,
className,
...otherProps
} = useContextSystem(props, "Navigator");
const [routerState, dispatch] = (0,external_wp_element_namespaceObject.useReducer)(routerReducer, initialPathProp, (path) => ({
screens: [],
currentLocation: {
path,
isInitial: true
},
matchedPath: void 0,
focusSelectors: /* @__PURE__ */ new Map(),
initialPath: initialPathProp
}));
const methods = (0,external_wp_element_namespaceObject.useMemo)(() => ({
// Note: calling goBack calls `goToParent` internally, as it was established
// that `goBack` should behave like `goToParent`, and `goToParent` should
// be marked as deprecated.
goBack: (options) => dispatch({
type: "gotoparent",
options
}),
goTo: (path, options) => dispatch({
type: "goto",
path,
options
}),
goToParent: (options) => {
external_wp_deprecated_default()(`wp.components.useNavigator().goToParent`, {
since: "6.7",
alternative: "wp.components.useNavigator().goBack"
});
dispatch({
type: "gotoparent",
options
});
},
addScreen: (screen) => dispatch({
type: "add",
screen
}),
removeScreen: (screen) => dispatch({
type: "remove",
screen
})
}), []);
const {
currentLocation,
matchedPath
} = routerState;
const navigatorContextValue = (0,external_wp_element_namespaceObject.useMemo)(() => {
var _matchedPath$params;
return {
location: currentLocation,
params: (_matchedPath$params = matchedPath?.params) !== null && _matchedPath$params !== void 0 ? _matchedPath$params : {},
match: matchedPath?.id,
...methods
};
}, [currentLocation, matchedPath, methods]);
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(navigatorWrapper, className), [className, cx]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
ref: forwardedRef,
className: classes,
...otherProps,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigatorContext.Provider, {
value: navigatorContextValue,
children
})
});
}
const component_Navigator = contextConnect(UnconnectedNavigator, "Navigator");
;// external ["wp","escapeHtml"]
const external_wp_escapeHtml_namespaceObject = window["wp"]["escapeHtml"];
;// ./node_modules/@wordpress/components/build-module/navigator/navigator-screen/use-screen-animate-presence.js
const ANIMATION_TIMEOUT_MARGIN = 1.2;
const isEnterAnimation = (animationDirection, animationStatus, animationName) => animationStatus === "ANIMATING_IN" && animationName === ANIMATION_END_NAMES[animationDirection].in;
const isExitAnimation = (animationDirection, animationStatus, animationName) => animationStatus === "ANIMATING_OUT" && animationName === ANIMATION_END_NAMES[animationDirection].out;
function useScreenAnimatePresence({
isMatch,
skipAnimation,
isBack,
onAnimationEnd
}) {
const isRTL = (0,external_wp_i18n_namespaceObject.isRTL)();
const prefersReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
const [animationStatus, setAnimationStatus] = (0,external_wp_element_namespaceObject.useState)("INITIAL");
const becameSelected = animationStatus !== "ANIMATING_IN" && animationStatus !== "IN" && isMatch;
const becameUnselected = animationStatus !== "ANIMATING_OUT" && animationStatus !== "OUT" && !isMatch;
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (becameSelected) {
setAnimationStatus(skipAnimation || prefersReducedMotion ? "IN" : "ANIMATING_IN");
} else if (becameUnselected) {
setAnimationStatus(skipAnimation || prefersReducedMotion ? "OUT" : "ANIMATING_OUT");
}
}, [becameSelected, becameUnselected, skipAnimation, prefersReducedMotion]);
const animationDirection = isRTL && isBack || !isRTL && !isBack ? "end" : "start";
const isAnimatingIn = animationStatus === "ANIMATING_IN";
const isAnimatingOut = animationStatus === "ANIMATING_OUT";
let animationType;
if (isAnimatingIn) {
animationType = "in";
} else if (isAnimatingOut) {
animationType = "out";
}
const onScreenAnimationEnd = (0,external_wp_element_namespaceObject.useCallback)((e) => {
onAnimationEnd?.(e);
if (isExitAnimation(animationDirection, animationStatus, e.animationName)) {
setAnimationStatus("OUT");
} else if (isEnterAnimation(animationDirection, animationStatus, e.animationName)) {
setAnimationStatus("IN");
}
}, [onAnimationEnd, animationStatus, animationDirection]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
let animationTimeout;
if (isAnimatingOut) {
animationTimeout = window.setTimeout(() => {
setAnimationStatus("OUT");
animationTimeout = void 0;
}, TOTAL_ANIMATION_DURATION.OUT * ANIMATION_TIMEOUT_MARGIN);
} else if (isAnimatingIn) {
animationTimeout = window.setTimeout(() => {
setAnimationStatus("IN");
animationTimeout = void 0;
}, TOTAL_ANIMATION_DURATION.IN * ANIMATION_TIMEOUT_MARGIN);
}
return () => {
if (animationTimeout) {
window.clearTimeout(animationTimeout);
animationTimeout = void 0;
}
};
}, [isAnimatingOut, isAnimatingIn]);
return {
animationStyles: navigatorScreenAnimation,
// Render the screen's contents in the DOM not only when the screen is
// selected, but also while it is animating out.
shouldRenderScreen: isMatch || animationStatus === "IN" || animationStatus === "ANIMATING_OUT",
screenProps: {
onAnimationEnd: onScreenAnimationEnd,
"data-animation-direction": animationDirection,
"data-animation-type": animationType,
"data-skip-animation": skipAnimation || void 0
}
};
}
;// ./node_modules/@wordpress/components/build-module/navigator/navigator-screen/component.js
function UnconnectedNavigatorScreen(props, forwardedRef) {
if (!/^\//.test(props.path)) {
true ? external_wp_warning_default()("wp.components.Navigator.Screen: the `path` should follow a URL-like scheme; it should start with and be separated by the `/` character.") : 0;
}
const screenId = (0,external_wp_element_namespaceObject.useId)();
const {
children,
className,
path,
onAnimationEnd: onAnimationEndProp,
...otherProps
} = useContextSystem(props, "Navigator.Screen");
const {
location,
match,
addScreen,
removeScreen
} = (0,external_wp_element_namespaceObject.useContext)(NavigatorContext);
const {
isInitial,
isBack,
focusTargetSelector,
skipFocus
} = location;
const isMatch = match === screenId;
const wrapperRef = (0,external_wp_element_namespaceObject.useRef)(null);
const skipAnimationAndFocusRestoration = !!isInitial && !isBack;
(0,external_wp_element_namespaceObject.useEffect)(() => {
const screen = {
id: screenId,
path: (0,external_wp_escapeHtml_namespaceObject.escapeAttribute)(path)
};
addScreen(screen);
return () => removeScreen(screen);
}, [screenId, path, addScreen, removeScreen]);
const {
animationStyles,
shouldRenderScreen,
screenProps
} = useScreenAnimatePresence({
isMatch,
isBack,
onAnimationEnd: onAnimationEndProp,
skipAnimation: skipAnimationAndFocusRestoration
});
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(navigatorScreen, animationStyles, className), [className, cx, animationStyles]);
const locationRef = (0,external_wp_element_namespaceObject.useRef)(location);
(0,external_wp_element_namespaceObject.useEffect)(() => {
locationRef.current = location;
}, [location]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const wrapperEl = wrapperRef.current;
if (skipAnimationAndFocusRestoration || !isMatch || !wrapperEl || locationRef.current.hasRestoredFocus || skipFocus) {
return;
}
const activeElement = wrapperEl.ownerDocument.activeElement;
if (wrapperEl.contains(activeElement)) {
return;
}
let elementToFocus = null;
if (isBack && focusTargetSelector) {
elementToFocus = wrapperEl.querySelector(focusTargetSelector);
}
if (!elementToFocus) {
const [firstTabbable] = external_wp_dom_namespaceObject.focus.tabbable.find(wrapperEl);
elementToFocus = firstTabbable !== null && firstTabbable !== void 0 ? firstTabbable : wrapperEl;
}
locationRef.current.hasRestoredFocus = true;
elementToFocus.focus();
}, [skipAnimationAndFocusRestoration, isMatch, isBack, focusTargetSelector, skipFocus]);
const mergedWrapperRef = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, wrapperRef]);
return shouldRenderScreen ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
ref: mergedWrapperRef,
className: classes,
...screenProps,
...otherProps,
children
}) : null;
}
const NavigatorScreen = contextConnect(UnconnectedNavigatorScreen, "Navigator.Screen");
;// ./node_modules/@wordpress/components/build-module/navigator/use-navigator.js
function useNavigator() {
const {
location,
params,
goTo,
goBack,
goToParent
} = (0,external_wp_element_namespaceObject.useContext)(NavigatorContext);
return {
location,
goTo,
goBack,
goToParent,
params
};
}
;// ./node_modules/@wordpress/components/build-module/navigator/navigator-button/hook.js
const cssSelectorForAttribute = (attrName, attrValue) => `[${attrName}="${attrValue}"]`;
function useNavigatorButton(props) {
const {
path,
onClick,
as = button_default,
attributeName = "id",
...otherProps
} = useContextSystem(props, "Navigator.Button");
const escapedPath = (0,external_wp_escapeHtml_namespaceObject.escapeAttribute)(path);
const {
goTo
} = useNavigator();
const handleClick = (0,external_wp_element_namespaceObject.useCallback)((e) => {
e.preventDefault();
goTo(escapedPath, {
focusTargetSelector: cssSelectorForAttribute(attributeName, escapedPath)
});
onClick?.(e);
}, [goTo, onClick, attributeName, escapedPath]);
return {
as,
onClick: handleClick,
...otherProps,
[attributeName]: escapedPath
};
}
;// ./node_modules/@wordpress/components/build-module/navigator/navigator-button/component.js
function UnconnectedNavigatorButton(props, forwardedRef) {
const navigatorButtonProps = useNavigatorButton(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
ref: forwardedRef,
...navigatorButtonProps
});
}
const NavigatorButton = contextConnect(UnconnectedNavigatorButton, "Navigator.Button");
;// ./node_modules/@wordpress/components/build-module/navigator/navigator-back-button/hook.js
function useNavigatorBackButton(props) {
const {
onClick,
as = button_default,
...otherProps
} = useContextSystem(props, "Navigator.BackButton");
const {
goBack
} = useNavigator();
const handleClick = (0,external_wp_element_namespaceObject.useCallback)((e) => {
e.preventDefault();
goBack();
onClick?.(e);
}, [goBack, onClick]);
return {
as,
onClick: handleClick,
...otherProps
};
}
;// ./node_modules/@wordpress/components/build-module/navigator/navigator-back-button/component.js
function UnconnectedNavigatorBackButton(props, forwardedRef) {
const navigatorBackButtonProps = useNavigatorBackButton(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
ref: forwardedRef,
...navigatorBackButtonProps
});
}
const NavigatorBackButton = contextConnect(UnconnectedNavigatorBackButton, "Navigator.BackButton");
;// ./node_modules/@wordpress/components/build-module/navigator/navigator-to-parent-button/component.js
function UnconnectedNavigatorToParentButton(props, forwardedRef) {
external_wp_deprecated_default()("wp.components.NavigatorToParentButton", {
since: "6.7",
alternative: "wp.components.Navigator.BackButton"
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(NavigatorBackButton, {
ref: forwardedRef,
...props
});
}
const NavigatorToParentButton = contextConnect(UnconnectedNavigatorToParentButton, "Navigator.ToParentButton");
;// ./node_modules/@wordpress/components/build-module/navigator/legacy.js
const NavigatorProvider = Object.assign(component_Navigator, {
displayName: "NavigatorProvider"
});
const legacy_NavigatorScreen = Object.assign(NavigatorScreen, {
displayName: "NavigatorScreen"
});
const legacy_NavigatorButton = Object.assign(NavigatorButton, {
displayName: "NavigatorButton"
});
const legacy_NavigatorBackButton = Object.assign(NavigatorBackButton, {
displayName: "NavigatorBackButton"
});
const legacy_NavigatorToParentButton = Object.assign(NavigatorToParentButton, {
displayName: "NavigatorToParentButton"
});
;// ./node_modules/@wordpress/components/build-module/navigator/index.js
const navigator_Navigator = Object.assign(component_Navigator, {
/**
* The `Navigator.Screen` component represents a single view/screen/panel and
* should be used in combination with the `Navigator`, the `Navigator.Button`
* and the `Navigator.BackButton` components.
*
* @example
* ```jsx
* import { Navigator } from '@wordpress/components';
*
* const MyNavigation = () => (
* <Navigator initialPath="/">
* <Navigator.Screen path="/">
* <p>This is the home screen.</p>
* <Navigator.Button path="/child">
* Navigate to child screen.
* </Navigator.Button>
* </Navigator.Screen>
*
* <Navigator.Screen path="/child">
* <p>This is the child screen.</p>
* <Navigator.BackButton>
* Go back
* </Navigator.BackButton>
* </Navigator.Screen>
* </Navigator>
* );
* ```
*/
Screen: Object.assign(NavigatorScreen, {
displayName: "Navigator.Screen"
}),
/**
* The `Navigator.Button` component can be used to navigate to a screen and
* should be used in combination with the `Navigator`, the `Navigator.Screen`
* and the `Navigator.BackButton` components.
*
* @example
* ```jsx
* import { Navigator } from '@wordpress/components';
*
* const MyNavigation = () => (
* <Navigator initialPath="/">
* <Navigator.Screen path="/">
* <p>This is the home screen.</p>
* <Navigator.Button path="/child">
* Navigate to child screen.
* </Navigator.Button>
* </Navigator.Screen>
*
* <Navigator.Screen path="/child">
* <p>This is the child screen.</p>
* <Navigator.BackButton>
* Go back
* </Navigator.BackButton>
* </Navigator.Screen>
* </Navigator>
* );
* ```
*/
Button: Object.assign(NavigatorButton, {
displayName: "Navigator.Button"
}),
/**
* The `Navigator.BackButton` component can be used to navigate to a screen and
* should be used in combination with the `Navigator`, the `Navigator.Screen`
* and the `Navigator.Button` components.
*
* @example
* ```jsx
* import { Navigator } from '@wordpress/components';
*
* const MyNavigation = () => (
* <Navigator initialPath="/">
* <Navigator.Screen path="/">
* <p>This is the home screen.</p>
* <Navigator.Button path="/child">
* Navigate to child screen.
* </Navigator.Button>
* </Navigator.Screen>
*
* <Navigator.Screen path="/child">
* <p>This is the child screen.</p>
* <Navigator.BackButton>
* Go back
* </Navigator.BackButton>
* </Navigator.Screen>
* </Navigator>
* );
* ```
*/
BackButton: Object.assign(NavigatorBackButton, {
displayName: "Navigator.BackButton"
})
});
;// ./node_modules/@wordpress/components/build-module/notice/index.js
const notice_noop = () => {
};
function useSpokenMessage(message, politeness) {
const spokenMessage = typeof message === "string" ? message : (0,external_wp_element_namespaceObject.renderToString)(message);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (spokenMessage) {
(0,external_wp_a11y_namespaceObject.speak)(spokenMessage, politeness);
}
}, [spokenMessage, politeness]);
}
function getDefaultPoliteness(status) {
switch (status) {
case "success":
case "warning":
case "info":
return "polite";
// The default will also catch the 'error' status.
default:
return "assertive";
}
}
function getStatusLabel(status) {
switch (status) {
case "warning":
return (0,external_wp_i18n_namespaceObject.__)("Warning notice");
case "info":
return (0,external_wp_i18n_namespaceObject.__)("Information notice");
case "error":
return (0,external_wp_i18n_namespaceObject.__)("Error notice");
// The default will also catch the 'success' status.
default:
return (0,external_wp_i18n_namespaceObject.__)("Notice");
}
}
function Notice({
className,
status = "info",
children,
spokenMessage = children,
onRemove = notice_noop,
isDismissible = true,
actions = [],
politeness = getDefaultPoliteness(status),
__unstableHTML,
// onDismiss is a callback executed when the notice is dismissed.
// It is distinct from onRemove, which _looks_ like a callback but is
// actually the function to call to remove the notice from the UI.
onDismiss = notice_noop
}) {
useSpokenMessage(spokenMessage, politeness);
const classes = dist_clsx(className, "components-notice", "is-" + status, {
"is-dismissible": isDismissible
});
if (__unstableHTML && typeof children === "string") {
children = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_element_namespaceObject.RawHTML, {
children
});
}
const onDismissNotice = () => {
onDismiss();
onRemove();
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: classes,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
children: getStatusLabel(status)
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-notice__content",
children: [children, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-notice__actions",
children: actions.map(({
className: buttonCustomClasses,
label,
isPrimary,
variant,
noDefaultClasses = false,
onClick,
url
}, index) => {
let computedVariant = variant;
if (variant !== "primary" && !noDefaultClasses) {
computedVariant = !url ? "secondary" : "link";
}
if (typeof computedVariant === "undefined" && isPrimary) {
computedVariant = "primary";
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
href: url,
variant: computedVariant,
onClick: url ? void 0 : onClick,
className: dist_clsx("components-notice__action", buttonCustomClasses),
children: label
}, index);
})
})]
}), isDismissible && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "small",
className: "components-notice__dismiss",
icon: close_default,
label: (0,external_wp_i18n_namespaceObject.__)("Close"),
onClick: onDismissNotice
})]
});
}
var notice_default = Notice;
;// ./node_modules/@wordpress/components/build-module/notice/list.js
const list_noop = () => {
};
function NoticeList({
notices,
onRemove = list_noop,
className,
children
}) {
const removeNotice = (id) => () => onRemove(id);
className = dist_clsx("components-notice-list", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className,
children: [children, [...notices].reverse().map((notice) => {
const {
content,
...restNotice
} = notice;
return /* @__PURE__ */ (0,external_React_.createElement)(notice_default, {
...restNotice,
key: notice.id,
onRemove: removeNotice(notice.id)
}, notice.content);
})]
});
}
var list_default = NoticeList;
;// ./node_modules/@wordpress/components/build-module/panel/header.js
function PanelHeader({
label,
children
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-panel__header",
children: [label && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("h2", {
children: label
}), children]
});
}
var header_default = PanelHeader;
;// ./node_modules/@wordpress/components/build-module/panel/index.js
function UnforwardedPanel({
header,
className,
children
}, ref) {
const classNames = dist_clsx(className, "components-panel");
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: classNames,
ref,
children: [header && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(header_default, {
label: header
}), children]
});
}
const Panel = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedPanel);
var panel_default = Panel;
;// ./node_modules/@wordpress/icons/build-module/library/chevron-up.js
var chevron_up_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M6.5 12.4L12 8l5.5 4.4-.9 1.2L12 10l-4.5 3.6-1-1.2z" }) });
;// ./node_modules/@wordpress/components/build-module/panel/body.js
const body_noop = () => {
};
function UnforwardedPanelBody(props, ref) {
const {
buttonProps = {},
children,
className,
icon,
initialOpen,
onToggle = body_noop,
opened,
title,
scrollAfterOpen = true
} = props;
const [isOpened, setIsOpened] = use_controlled_state_default(opened, {
initial: initialOpen === void 0 ? true : initialOpen,
fallback: false
});
const nodeRef = (0,external_wp_element_namespaceObject.useRef)(null);
const scrollBehavior = (0,external_wp_compose_namespaceObject.useReducedMotion)() ? "auto" : "smooth";
const handleOnToggle = (event) => {
event.preventDefault();
const next = !isOpened;
setIsOpened(next);
onToggle(next);
};
const scrollAfterOpenRef = (0,external_wp_element_namespaceObject.useRef)();
scrollAfterOpenRef.current = scrollAfterOpen;
use_update_effect_default(() => {
if (isOpened && scrollAfterOpenRef.current && nodeRef.current?.scrollIntoView) {
nodeRef.current.scrollIntoView({
inline: "nearest",
block: "nearest",
behavior: scrollBehavior
});
}
}, [isOpened, scrollBehavior]);
const classes = dist_clsx("components-panel__body", className, {
"is-opened": isOpened
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: classes,
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([nodeRef, ref]),
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PanelBodyTitle, {
icon,
isOpened: Boolean(isOpened),
onClick: handleOnToggle,
title,
...buttonProps
}), typeof children === "function" ? children({
opened: Boolean(isOpened)
}) : isOpened && children]
});
}
const PanelBodyTitle = (0,external_wp_element_namespaceObject.forwardRef)(({
isOpened,
icon,
title,
...props
}, ref) => {
if (!title) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("h2", {
className: "components-panel__body-title",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(button_default, {
__next40pxDefaultSize: true,
className: "components-panel__body-toggle",
"aria-expanded": isOpened,
ref,
...props,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
"aria-hidden": "true",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
className: "components-panel__arrow",
icon: isOpened ? chevron_up_default : chevron_down_default
})
}), title, icon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon,
className: "components-panel__icon",
size: 20
})]
})
});
});
const PanelBody = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedPanelBody);
var body_default = PanelBody;
;// ./node_modules/@wordpress/components/build-module/panel/row.js
function UnforwardedPanelRow({
className,
children
}, ref) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: dist_clsx("components-panel__row", className),
ref,
children
});
}
const PanelRow = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedPanelRow);
var row_default = PanelRow;
;// ./node_modules/@wordpress/components/build-module/placeholder/index.js
const PlaceholderIllustration = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
className: "components-placeholder__illustration",
fill: "none",
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 60 60",
preserveAspectRatio: "none",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, {
vectorEffect: "non-scaling-stroke",
d: "M60 60 0 0"
})
});
function Placeholder(props) {
const {
icon,
children,
label,
instructions,
className,
notices,
preview,
isColumnLayout,
withIllustration,
...additionalProps
} = props;
const [resizeListener, {
width
}] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
let modifierClassNames;
if (typeof width === "number") {
modifierClassNames = {
"is-large": width >= 480,
"is-medium": width >= 160 && width < 480,
"is-small": width < 160
};
}
const classes = dist_clsx("components-placeholder", className, modifierClassNames, withIllustration ? "has-illustration" : null);
const fieldsetClasses = dist_clsx("components-placeholder__fieldset", {
"is-column-layout": isColumnLayout
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (instructions) {
(0,external_wp_a11y_namespaceObject.speak)(instructions);
}
}, [instructions]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
...additionalProps,
className: classes,
children: [withIllustration ? PlaceholderIllustration : null, resizeListener, notices, preview && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-placeholder__preview",
children: preview
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-placeholder__label",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon
}), label]
}), !!instructions && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-placeholder__instructions",
children: instructions
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: fieldsetClasses,
children
})]
});
}
var placeholder_default = Placeholder;
;// ./node_modules/@wordpress/components/build-module/progress-bar/styles.js
function progress_bar_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
function animateProgressBar(isRtl = false) {
const animationDirection = isRtl ? "right" : "left";
return emotion_react_browser_esm_keyframes({
"0%": {
[animationDirection]: "-50%"
},
"100%": {
[animationDirection]: "100%"
}
});
}
const INDETERMINATE_TRACK_WIDTH = 50;
const styles_Track = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e15u147w2"
} : 0)("position:relative;overflow:hidden;height:", config_values_default.borderWidthFocus, ";background-color:color-mix(\n in srgb,\n ", COLORS.theme.foreground, ",\n transparent 90%\n );border-radius:", config_values_default.radiusFull, ";outline:2px solid transparent;outline-offset:2px;:where( & ){width:160px;}" + ( true ? "" : 0));
var progress_bar_styles_ref = true ? {
name: "152sa26",
styles: "width:var(--indicator-width);transition:width 0.4s ease-in-out"
} : 0;
const Indicator = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e15u147w1"
} : 0)("display:inline-block;position:absolute;top:0;height:100%;border-radius:", config_values_default.radiusFull, ";background-color:color-mix(\n in srgb,\n ", COLORS.theme.foreground, ",\n transparent 10%\n );outline:2px solid transparent;outline-offset:-2px;", ({
isIndeterminate
}) => isIndeterminate ? /* @__PURE__ */ emotion_react_browser_esm_css({
animationDuration: "1.5s",
animationTimingFunction: "ease-in-out",
animationIterationCount: "infinite",
animationName: animateProgressBar((0,external_wp_i18n_namespaceObject.isRTL)()),
width: `${INDETERMINATE_TRACK_WIDTH}%`
}, true ? "" : 0, true ? "" : 0) : progress_bar_styles_ref, ";" + ( true ? "" : 0));
const ProgressElement = /* @__PURE__ */ emotion_styled_base_browser_esm("progress", true ? {
target: "e15u147w0"
} : 0)( true ? {
name: "11fb690",
styles: "position:absolute;top:0;left:0;opacity:0;width:100%;height:100%"
} : 0);
;// ./node_modules/@wordpress/components/build-module/progress-bar/index.js
function UnforwardedProgressBar(props, ref) {
const {
className,
value,
...progressProps
} = props;
const isIndeterminate = !Number.isFinite(value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(styles_Track, {
className,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Indicator, {
style: {
"--indicator-width": !isIndeterminate ? `${value}%` : void 0
},
isIndeterminate
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ProgressElement, {
max: 100,
value,
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Loading \u2026"),
ref,
...progressProps
})]
});
}
const ProgressBar = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedProgressBar);
var progress_bar_default = ProgressBar;
;// ./node_modules/@wordpress/components/build-module/query-controls/terms.js
const ensureParentsAreDefined = (terms) => {
return terms.every((term) => term.parent !== null);
};
function buildTermsTree(flatTerms) {
const flatTermsWithParentAndChildren = flatTerms.map((term) => ({
children: [],
parent: null,
...term,
id: String(term.id)
}));
if (!ensureParentsAreDefined(flatTermsWithParentAndChildren)) {
return flatTermsWithParentAndChildren;
}
const termsByParent = flatTermsWithParentAndChildren.reduce((acc, term) => {
const {
parent
} = term;
if (!acc[parent]) {
acc[parent] = [];
}
acc[parent].push(term);
return acc;
}, {});
const fillWithChildren = (terms) => {
return terms.map((term) => {
const children = termsByParent[term.id];
return {
...term,
children: children && children.length ? fillWithChildren(children) : []
};
});
};
return fillWithChildren(termsByParent["0"] || []);
}
;// external ["wp","htmlEntities"]
const external_wp_htmlEntities_namespaceObject = window["wp"]["htmlEntities"];
;// ./node_modules/@wordpress/components/build-module/tree-select/index.js
const tree_select_CONTEXT_VALUE = {
BaseControl: {
// Temporary during deprecation grace period: Overrides the underlying `__associatedWPComponentName`
// via the context system to override the value set by SelectControl.
_overrides: {
__associatedWPComponentName: "TreeSelect"
}
}
};
function getSelectOptions(tree, level = 0) {
return tree.flatMap((treeNode) => [{
value: treeNode.id,
label: "\xA0".repeat(level * 3) + (0,external_wp_htmlEntities_namespaceObject.decodeEntities)(treeNode.name)
}, ...getSelectOptions(treeNode.children || [], level + 1)]);
}
function TreeSelect(props) {
const {
label,
noOptionLabel,
onChange,
selectedId,
tree = [],
...restProps
} = useDeprecated36pxDefaultSizeProp(props);
const options = (0,external_wp_element_namespaceObject.useMemo)(() => {
return [noOptionLabel && {
value: "",
label: noOptionLabel
}, ...getSelectOptions(tree)].filter((option) => !!option);
}, [noOptionLabel, tree]);
maybeWarnDeprecated36pxSize({
componentName: "TreeSelect",
size: restProps.size,
__next40pxDefaultSize: restProps.__next40pxDefaultSize
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ContextSystemProvider, {
value: tree_select_CONTEXT_VALUE,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SelectControl, {
__shouldNotWarnDeprecated36pxSize: true,
label,
options,
onChange,
value: selectedId,
...restProps
})
});
}
var tree_select_default = TreeSelect;
;// ./node_modules/@wordpress/components/build-module/query-controls/author-select.js
function AuthorSelect({
__next40pxDefaultSize,
label,
noOptionLabel,
authorList,
selectedAuthorId,
onChange: onChangeProp
}) {
if (!authorList) {
return null;
}
const termsTree = buildTermsTree(authorList);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tree_select_default, {
label,
noOptionLabel,
onChange: onChangeProp,
tree: termsTree,
selectedId: selectedAuthorId !== void 0 ? String(selectedAuthorId) : void 0,
__nextHasNoMarginBottom: true,
__next40pxDefaultSize
});
}
;// ./node_modules/@wordpress/components/build-module/query-controls/category-select.js
function CategorySelect({
__next40pxDefaultSize,
label,
noOptionLabel,
categoriesList,
selectedCategoryId,
onChange: onChangeProp,
...props
}) {
const termsTree = (0,external_wp_element_namespaceObject.useMemo)(() => {
return buildTermsTree(categoriesList);
}, [categoriesList]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tree_select_default, {
label,
noOptionLabel,
onChange: onChangeProp,
tree: termsTree,
selectedId: selectedCategoryId !== void 0 ? String(selectedCategoryId) : void 0,
...props,
__nextHasNoMarginBottom: true,
__next40pxDefaultSize
});
}
;// ./node_modules/@wordpress/components/build-module/query-controls/index.js
const DEFAULT_MIN_ITEMS = 1;
const DEFAULT_MAX_ITEMS = 100;
const MAX_CATEGORIES_SUGGESTIONS = 20;
function isSingleCategorySelection(props) {
return "categoriesList" in props;
}
function isMultipleCategorySelection(props) {
return "categorySuggestions" in props;
}
const defaultOrderByOptions = [{
label: (0,external_wp_i18n_namespaceObject.__)("Newest to oldest"),
value: "date/desc"
}, {
label: (0,external_wp_i18n_namespaceObject.__)("Oldest to newest"),
value: "date/asc"
}, {
/* translators: Label for ordering posts by title in ascending order. */
label: (0,external_wp_i18n_namespaceObject.__)("A \u2192 Z"),
value: "title/asc"
}, {
/* translators: Label for ordering posts by title in descending order. */
label: (0,external_wp_i18n_namespaceObject.__)("Z \u2192 A"),
value: "title/desc"
}];
function QueryControls({
authorList,
selectedAuthorId,
numberOfItems,
order,
orderBy,
orderByOptions = defaultOrderByOptions,
maxItems = DEFAULT_MAX_ITEMS,
minItems = DEFAULT_MIN_ITEMS,
onAuthorChange,
onNumberOfItemsChange,
onOrderChange,
onOrderByChange,
// Props for single OR multiple category selection are not destructured here,
// but instead are destructured inline where necessary.
...props
}) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(v_stack_component_component_default, {
spacing: "4",
className: "components-query-controls",
children: [onOrderChange && onOrderByChange && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(select_control_default, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize: true,
label: (0,external_wp_i18n_namespaceObject.__)("Order by"),
value: orderBy === void 0 || order === void 0 ? void 0 : `${orderBy}/${order}`,
options: orderByOptions,
onChange: (value) => {
if (typeof value !== "string") {
return;
}
const [newOrderBy, newOrder] = value.split("/");
if (newOrder !== order) {
onOrderChange(newOrder);
}
if (newOrderBy !== orderBy) {
onOrderByChange(newOrderBy);
}
}
}, "query-controls-order-select"), isSingleCategorySelection(props) && props.categoriesList && props.onCategoryChange && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CategorySelect, {
__next40pxDefaultSize: true,
categoriesList: props.categoriesList,
label: (0,external_wp_i18n_namespaceObject.__)("Category"),
noOptionLabel: (0,external_wp_i18n_namespaceObject._x)("All", "categories"),
selectedCategoryId: props.selectedCategoryId,
onChange: props.onCategoryChange
}, "query-controls-category-select"), isMultipleCategorySelection(props) && props.categorySuggestions && props.onCategoryChange && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(form_token_field_default, {
__next40pxDefaultSize: true,
__nextHasNoMarginBottom: true,
label: (0,external_wp_i18n_namespaceObject.__)("Categories"),
value: props.selectedCategories && props.selectedCategories.map((item) => ({
id: item.id,
// Keeping the fallback to `item.value` for legacy reasons,
// even if items of `selectedCategories` should not have a
// `value` property.
// @ts-expect-error
value: item.name || item.value
})),
suggestions: Object.keys(props.categorySuggestions),
onChange: props.onCategoryChange,
maxSuggestions: MAX_CATEGORIES_SUGGESTIONS
}, "query-controls-categories-select"), onAuthorChange && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(AuthorSelect, {
__next40pxDefaultSize: true,
authorList,
label: (0,external_wp_i18n_namespaceObject.__)("Author"),
noOptionLabel: (0,external_wp_i18n_namespaceObject._x)("All", "authors"),
selectedAuthorId,
onChange: onAuthorChange
}, "query-controls-author-select"), onNumberOfItemsChange && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(range_control_default, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize: true,
label: (0,external_wp_i18n_namespaceObject.__)("Number of items"),
value: numberOfItems,
onChange: onNumberOfItemsChange,
min: minItems,
max: maxItems,
required: true
}, "query-controls-range-control")]
});
}
var query_controls_default = QueryControls;
;// ./node_modules/@wordpress/components/build-module/radio-group/context.js
const RadioGroupContext = (0,external_wp_element_namespaceObject.createContext)({
store: void 0,
disabled: void 0
});
RadioGroupContext.displayName = "RadioGroupContext";
;// ./node_modules/@wordpress/components/build-module/radio-group/radio.js
function UnforwardedRadio({
value,
children,
...props
}, ref) {
const {
store,
disabled
} = (0,external_wp_element_namespaceObject.useContext)(RadioGroupContext);
const selectedValue = useStoreState(store, "value");
const isChecked = selectedValue !== void 0 && selectedValue === value;
maybeWarnDeprecated36pxSize({
componentName: "Radio",
size: void 0,
__next40pxDefaultSize: props.__next40pxDefaultSize
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Radio, {
disabled,
store,
ref,
value,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
variant: isChecked ? "primary" : "secondary",
...props
}),
children: children || value
});
}
const radio_Radio = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedRadio);
var radio_default = radio_Radio;
;// ./node_modules/@wordpress/components/build-module/radio-group/index.js
function UnforwardedRadioGroup({
label,
checked,
defaultChecked,
disabled,
onChange,
children,
...props
}, ref) {
const radioStore = useRadioStore({
value: checked,
defaultValue: defaultChecked,
setValue: (newValue) => {
onChange?.(newValue !== null && newValue !== void 0 ? newValue : void 0);
},
rtl: (0,external_wp_i18n_namespaceObject.isRTL)()
});
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
store: radioStore,
disabled
}), [radioStore, disabled]);
external_wp_deprecated_default()("wp.components.__experimentalRadioGroup", {
alternative: "wp.components.RadioControl or wp.components.__experimentalToggleGroupControl",
since: "6.8"
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RadioGroupContext.Provider, {
value: contextValue,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RadioGroup, {
store: radioStore,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_group_default, {
__shouldNotWarnDeprecated: true,
children
}),
"aria-label": label,
ref,
...props
})
});
}
const radio_group_RadioGroup = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedRadioGroup);
var radio_group_default = radio_group_RadioGroup;
;// ./node_modules/@wordpress/components/build-module/radio-control/index.js
function generateOptionDescriptionId(radioGroupId, index) {
return `${radioGroupId}-${index}-option-description`;
}
function generateOptionId(radioGroupId, index) {
return `${radioGroupId}-${index}`;
}
function generateHelpId(radioGroupId) {
return `${radioGroupId}__help`;
}
function RadioControl(props) {
const {
label,
className,
selected,
help,
onChange,
onClick,
hideLabelFromVision,
options = [],
id: preferredId,
...additionalProps
} = props;
const id = (0,external_wp_compose_namespaceObject.useInstanceId)(RadioControl, "inspector-radio-control", preferredId);
const onChangeValue = (event) => onChange(event.target.value);
if (!options?.length) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("fieldset", {
id,
className: dist_clsx(className, "components-radio-control"),
"aria-describedby": !!help ? generateHelpId(id) : void 0,
children: [hideLabelFromVision ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_component_default, {
as: "legend",
children: label
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default.VisualLabel, {
as: "legend",
children: label
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(v_stack_component_component_default, {
spacing: 3,
className: dist_clsx("components-radio-control__group-wrapper", {
"has-help": !!help
}),
children: options.map((option, index) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-radio-control__option",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
id: generateOptionId(id, index),
className: "components-radio-control__input",
type: "radio",
name: id,
value: option.value,
onChange: onChangeValue,
checked: option.value === selected,
"aria-describedby": !!option.description ? generateOptionDescriptionId(id, index) : void 0,
onClick: (event) => {
event.currentTarget.focus();
onClick?.(event);
},
...additionalProps
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("label", {
className: "components-radio-control__label",
htmlFor: generateOptionId(id, index),
children: option.label
}), !!option.description ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledHelp, {
__nextHasNoMarginBottom: true,
id: generateOptionDescriptionId(id, index),
className: "components-radio-control__option-description",
children: option.description
}) : null]
}, generateOptionId(id, index)))
}), !!help && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledHelp, {
__nextHasNoMarginBottom: true,
id: generateHelpId(id),
className: "components-base-control__help",
children: help
})]
});
}
var radio_control_default = RadioControl;
;// ./node_modules/re-resizable/lib/resizer.js
var resizer_extends = (undefined && undefined.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var resizer_assign = (undefined && undefined.__assign) || function () {
resizer_assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return resizer_assign.apply(this, arguments);
};
var rowSizeBase = {
width: '100%',
height: '10px',
top: '0px',
left: '0px',
cursor: 'row-resize',
};
var colSizeBase = {
width: '10px',
height: '100%',
top: '0px',
left: '0px',
cursor: 'col-resize',
};
var edgeBase = {
width: '20px',
height: '20px',
position: 'absolute',
};
var resizer_styles = {
top: resizer_assign(resizer_assign({}, rowSizeBase), { top: '-5px' }),
right: resizer_assign(resizer_assign({}, colSizeBase), { left: undefined, right: '-5px' }),
bottom: resizer_assign(resizer_assign({}, rowSizeBase), { top: undefined, bottom: '-5px' }),
left: resizer_assign(resizer_assign({}, colSizeBase), { left: '-5px' }),
topRight: resizer_assign(resizer_assign({}, edgeBase), { right: '-10px', top: '-10px', cursor: 'ne-resize' }),
bottomRight: resizer_assign(resizer_assign({}, edgeBase), { right: '-10px', bottom: '-10px', cursor: 'se-resize' }),
bottomLeft: resizer_assign(resizer_assign({}, edgeBase), { left: '-10px', bottom: '-10px', cursor: 'sw-resize' }),
topLeft: resizer_assign(resizer_assign({}, edgeBase), { left: '-10px', top: '-10px', cursor: 'nw-resize' }),
};
var Resizer = /** @class */ (function (_super) {
resizer_extends(Resizer, _super);
function Resizer() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.onMouseDown = function (e) {
_this.props.onResizeStart(e, _this.props.direction);
};
_this.onTouchStart = function (e) {
_this.props.onResizeStart(e, _this.props.direction);
};
return _this;
}
Resizer.prototype.render = function () {
return (external_React_.createElement("div", { className: this.props.className || '', style: resizer_assign(resizer_assign({ position: 'absolute', userSelect: 'none' }, resizer_styles[this.props.direction]), (this.props.replaceStyles || {})), onMouseDown: this.onMouseDown, onTouchStart: this.onTouchStart }, this.props.children));
};
return Resizer;
}(external_React_.PureComponent));
;// ./node_modules/re-resizable/lib/index.js
var lib_extends = (undefined && undefined.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var lib_assign = (undefined && undefined.__assign) || function () {
lib_assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return lib_assign.apply(this, arguments);
};
var DEFAULT_SIZE = {
width: 'auto',
height: 'auto',
};
var lib_clamp = function (n, min, max) { return Math.max(Math.min(n, max), min); };
var snap = function (n, size) { return Math.round(n / size) * size; };
var hasDirection = function (dir, target) {
return new RegExp(dir, 'i').test(target);
};
// INFO: In case of window is a Proxy and does not porxy Events correctly, use isTouchEvent & isMouseEvent to distinguish event type instead of `instanceof`.
var isTouchEvent = function (event) {
return Boolean(event.touches && event.touches.length);
};
var isMouseEvent = function (event) {
return Boolean((event.clientX || event.clientX === 0) &&
(event.clientY || event.clientY === 0));
};
var findClosestSnap = function (n, snapArray, snapGap) {
if (snapGap === void 0) { snapGap = 0; }
var closestGapIndex = snapArray.reduce(function (prev, curr, index) { return (Math.abs(curr - n) < Math.abs(snapArray[prev] - n) ? index : prev); }, 0);
var gap = Math.abs(snapArray[closestGapIndex] - n);
return snapGap === 0 || gap < snapGap ? snapArray[closestGapIndex] : n;
};
var getStringSize = function (n) {
n = n.toString();
if (n === 'auto') {
return n;
}
if (n.endsWith('px')) {
return n;
}
if (n.endsWith('%')) {
return n;
}
if (n.endsWith('vh')) {
return n;
}
if (n.endsWith('vw')) {
return n;
}
if (n.endsWith('vmax')) {
return n;
}
if (n.endsWith('vmin')) {
return n;
}
return n + "px";
};
var getPixelSize = function (size, parentSize, innerWidth, innerHeight) {
if (size && typeof size === 'string') {
if (size.endsWith('px')) {
return Number(size.replace('px', ''));
}
if (size.endsWith('%')) {
var ratio = Number(size.replace('%', '')) / 100;
return parentSize * ratio;
}
if (size.endsWith('vw')) {
var ratio = Number(size.replace('vw', '')) / 100;
return innerWidth * ratio;
}
if (size.endsWith('vh')) {
var ratio = Number(size.replace('vh', '')) / 100;
return innerHeight * ratio;
}
}
return size;
};
var calculateNewMax = function (parentSize, innerWidth, innerHeight, maxWidth, maxHeight, minWidth, minHeight) {
maxWidth = getPixelSize(maxWidth, parentSize.width, innerWidth, innerHeight);
maxHeight = getPixelSize(maxHeight, parentSize.height, innerWidth, innerHeight);
minWidth = getPixelSize(minWidth, parentSize.width, innerWidth, innerHeight);
minHeight = getPixelSize(minHeight, parentSize.height, innerWidth, innerHeight);
return {
maxWidth: typeof maxWidth === 'undefined' ? undefined : Number(maxWidth),
maxHeight: typeof maxHeight === 'undefined' ? undefined : Number(maxHeight),
minWidth: typeof minWidth === 'undefined' ? undefined : Number(minWidth),
minHeight: typeof minHeight === 'undefined' ? undefined : Number(minHeight),
};
};
var definedProps = [
'as',
'style',
'className',
'grid',
'snap',
'bounds',
'boundsByDirection',
'size',
'defaultSize',
'minWidth',
'minHeight',
'maxWidth',
'maxHeight',
'lockAspectRatio',
'lockAspectRatioExtraWidth',
'lockAspectRatioExtraHeight',
'enable',
'handleStyles',
'handleClasses',
'handleWrapperStyle',
'handleWrapperClass',
'children',
'onResizeStart',
'onResize',
'onResizeStop',
'handleComponent',
'scale',
'resizeRatio',
'snapGap',
];
// HACK: This class is used to calculate % size.
var baseClassName = '__resizable_base__';
var Resizable = /** @class */ (function (_super) {
lib_extends(Resizable, _super);
function Resizable(props) {
var _this = _super.call(this, props) || this;
_this.ratio = 1;
_this.resizable = null;
// For parent boundary
_this.parentLeft = 0;
_this.parentTop = 0;
// For boundary
_this.resizableLeft = 0;
_this.resizableRight = 0;
_this.resizableTop = 0;
_this.resizableBottom = 0;
// For target boundary
_this.targetLeft = 0;
_this.targetTop = 0;
_this.appendBase = function () {
if (!_this.resizable || !_this.window) {
return null;
}
var parent = _this.parentNode;
if (!parent) {
return null;
}
var element = _this.window.document.createElement('div');
element.style.width = '100%';
element.style.height = '100%';
element.style.position = 'absolute';
element.style.transform = 'scale(0, 0)';
element.style.left = '0';
element.style.flex = '0 0 100%';
if (element.classList) {
element.classList.add(baseClassName);
}
else {
element.className += baseClassName;
}
parent.appendChild(element);
return element;
};
_this.removeBase = function (base) {
var parent = _this.parentNode;
if (!parent) {
return;
}
parent.removeChild(base);
};
_this.ref = function (c) {
if (c) {
_this.resizable = c;
}
};
_this.state = {
isResizing: false,
width: typeof (_this.propsSize && _this.propsSize.width) === 'undefined'
? 'auto'
: _this.propsSize && _this.propsSize.width,
height: typeof (_this.propsSize && _this.propsSize.height) === 'undefined'
? 'auto'
: _this.propsSize && _this.propsSize.height,
direction: 'right',
original: {
x: 0,
y: 0,
width: 0,
height: 0,
},
backgroundStyle: {
height: '100%',
width: '100%',
backgroundColor: 'rgba(0,0,0,0)',
cursor: 'auto',
opacity: 0,
position: 'fixed',
zIndex: 9999,
top: '0',
left: '0',
bottom: '0',
right: '0',
},
flexBasis: undefined,
};
_this.onResizeStart = _this.onResizeStart.bind(_this);
_this.onMouseMove = _this.onMouseMove.bind(_this);
_this.onMouseUp = _this.onMouseUp.bind(_this);
return _this;
}
Object.defineProperty(Resizable.prototype, "parentNode", {
get: function () {
if (!this.resizable) {
return null;
}
return this.resizable.parentNode;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Resizable.prototype, "window", {
get: function () {
if (!this.resizable) {
return null;
}
if (!this.resizable.ownerDocument) {
return null;
}
return this.resizable.ownerDocument.defaultView;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Resizable.prototype, "propsSize", {
get: function () {
return this.props.size || this.props.defaultSize || DEFAULT_SIZE;
},
enumerable: false,
configurable: true
});
Object.defineProperty(Resizable.prototype, "size", {
get: function () {
var width = 0;
var height = 0;
if (this.resizable && this.window) {
var orgWidth = this.resizable.offsetWidth;
var orgHeight = this.resizable.offsetHeight;
// HACK: Set position `relative` to get parent size.
// This is because when re-resizable set `absolute`, I can not get base width correctly.
var orgPosition = this.resizable.style.position;
if (orgPosition !== 'relative') {
this.resizable.style.position = 'relative';
}
// INFO: Use original width or height if set auto.
width = this.resizable.style.width !== 'auto' ? this.resizable.offsetWidth : orgWidth;
height = this.resizable.style.height !== 'auto' ? this.resizable.offsetHeight : orgHeight;
// Restore original position
this.resizable.style.position = orgPosition;
}
return { width: width, height: height };
},
enumerable: false,
configurable: true
});
Object.defineProperty(Resizable.prototype, "sizeStyle", {
get: function () {
var _this = this;
var size = this.props.size;
var getSize = function (key) {
if (typeof _this.state[key] === 'undefined' || _this.state[key] === 'auto') {
return 'auto';
}
if (_this.propsSize && _this.propsSize[key] && _this.propsSize[key].toString().endsWith('%')) {
if (_this.state[key].toString().endsWith('%')) {
return _this.state[key].toString();
}
var parentSize = _this.getParentSize();
var value = Number(_this.state[key].toString().replace('px', ''));
var percent = (value / parentSize[key]) * 100;
return percent + "%";
}
return getStringSize(_this.state[key]);
};
var width = size && typeof size.width !== 'undefined' && !this.state.isResizing
? getStringSize(size.width)
: getSize('width');
var height = size && typeof size.height !== 'undefined' && !this.state.isResizing
? getStringSize(size.height)
: getSize('height');
return { width: width, height: height };
},
enumerable: false,
configurable: true
});
Resizable.prototype.getParentSize = function () {
if (!this.parentNode) {
if (!this.window) {
return { width: 0, height: 0 };
}
return { width: this.window.innerWidth, height: this.window.innerHeight };
}
var base = this.appendBase();
if (!base) {
return { width: 0, height: 0 };
}
// INFO: To calculate parent width with flex layout
var wrapChanged = false;
var wrap = this.parentNode.style.flexWrap;
if (wrap !== 'wrap') {
wrapChanged = true;
this.parentNode.style.flexWrap = 'wrap';
// HACK: Use relative to get parent padding size
}
base.style.position = 'relative';
base.style.minWidth = '100%';
base.style.minHeight = '100%';
var size = {
width: base.offsetWidth,
height: base.offsetHeight,
};
if (wrapChanged) {
this.parentNode.style.flexWrap = wrap;
}
this.removeBase(base);
return size;
};
Resizable.prototype.bindEvents = function () {
if (this.window) {
this.window.addEventListener('mouseup', this.onMouseUp);
this.window.addEventListener('mousemove', this.onMouseMove);
this.window.addEventListener('mouseleave', this.onMouseUp);
this.window.addEventListener('touchmove', this.onMouseMove, {
capture: true,
passive: false,
});
this.window.addEventListener('touchend', this.onMouseUp);
}
};
Resizable.prototype.unbindEvents = function () {
if (this.window) {
this.window.removeEventListener('mouseup', this.onMouseUp);
this.window.removeEventListener('mousemove', this.onMouseMove);
this.window.removeEventListener('mouseleave', this.onMouseUp);
this.window.removeEventListener('touchmove', this.onMouseMove, true);
this.window.removeEventListener('touchend', this.onMouseUp);
}
};
Resizable.prototype.componentDidMount = function () {
if (!this.resizable || !this.window) {
return;
}
var computedStyle = this.window.getComputedStyle(this.resizable);
this.setState({
width: this.state.width || this.size.width,
height: this.state.height || this.size.height,
flexBasis: computedStyle.flexBasis !== 'auto' ? computedStyle.flexBasis : undefined,
});
};
Resizable.prototype.componentWillUnmount = function () {
if (this.window) {
this.unbindEvents();
}
};
Resizable.prototype.createSizeForCssProperty = function (newSize, kind) {
var propsSize = this.propsSize && this.propsSize[kind];
return this.state[kind] === 'auto' &&
this.state.original[kind] === newSize &&
(typeof propsSize === 'undefined' || propsSize === 'auto')
? 'auto'
: newSize;
};
Resizable.prototype.calculateNewMaxFromBoundary = function (maxWidth, maxHeight) {
var boundsByDirection = this.props.boundsByDirection;
var direction = this.state.direction;
var widthByDirection = boundsByDirection && hasDirection('left', direction);
var heightByDirection = boundsByDirection && hasDirection('top', direction);
var boundWidth;
var boundHeight;
if (this.props.bounds === 'parent') {
var parent_1 = this.parentNode;
if (parent_1) {
boundWidth = widthByDirection
? this.resizableRight - this.parentLeft
: parent_1.offsetWidth + (this.parentLeft - this.resizableLeft);
boundHeight = heightByDirection
? this.resizableBottom - this.parentTop
: parent_1.offsetHeight + (this.parentTop - this.resizableTop);
}
}
else if (this.props.bounds === 'window') {
if (this.window) {
boundWidth = widthByDirection ? this.resizableRight : this.window.innerWidth - this.resizableLeft;
boundHeight = heightByDirection ? this.resizableBottom : this.window.innerHeight - this.resizableTop;
}
}
else if (this.props.bounds) {
boundWidth = widthByDirection
? this.resizableRight - this.targetLeft
: this.props.bounds.offsetWidth + (this.targetLeft - this.resizableLeft);
boundHeight = heightByDirection
? this.resizableBottom - this.targetTop
: this.props.bounds.offsetHeight + (this.targetTop - this.resizableTop);
}
if (boundWidth && Number.isFinite(boundWidth)) {
maxWidth = maxWidth && maxWidth < boundWidth ? maxWidth : boundWidth;
}
if (boundHeight && Number.isFinite(boundHeight)) {
maxHeight = maxHeight && maxHeight < boundHeight ? maxHeight : boundHeight;
}
return { maxWidth: maxWidth, maxHeight: maxHeight };
};
Resizable.prototype.calculateNewSizeFromDirection = function (clientX, clientY) {
var scale = this.props.scale || 1;
var resizeRatio = this.props.resizeRatio || 1;
var _a = this.state, direction = _a.direction, original = _a.original;
var _b = this.props, lockAspectRatio = _b.lockAspectRatio, lockAspectRatioExtraHeight = _b.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _b.lockAspectRatioExtraWidth;
var newWidth = original.width;
var newHeight = original.height;
var extraHeight = lockAspectRatioExtraHeight || 0;
var extraWidth = lockAspectRatioExtraWidth || 0;
if (hasDirection('right', direction)) {
newWidth = original.width + ((clientX - original.x) * resizeRatio) / scale;
if (lockAspectRatio) {
newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;
}
}
if (hasDirection('left', direction)) {
newWidth = original.width - ((clientX - original.x) * resizeRatio) / scale;
if (lockAspectRatio) {
newHeight = (newWidth - extraWidth) / this.ratio + extraHeight;
}
}
if (hasDirection('bottom', direction)) {
newHeight = original.height + ((clientY - original.y) * resizeRatio) / scale;
if (lockAspectRatio) {
newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;
}
}
if (hasDirection('top', direction)) {
newHeight = original.height - ((clientY - original.y) * resizeRatio) / scale;
if (lockAspectRatio) {
newWidth = (newHeight - extraHeight) * this.ratio + extraWidth;
}
}
return { newWidth: newWidth, newHeight: newHeight };
};
Resizable.prototype.calculateNewSizeFromAspectRatio = function (newWidth, newHeight, max, min) {
var _a = this.props, lockAspectRatio = _a.lockAspectRatio, lockAspectRatioExtraHeight = _a.lockAspectRatioExtraHeight, lockAspectRatioExtraWidth = _a.lockAspectRatioExtraWidth;
var computedMinWidth = typeof min.width === 'undefined' ? 10 : min.width;
var computedMaxWidth = typeof max.width === 'undefined' || max.width < 0 ? newWidth : max.width;
var computedMinHeight = typeof min.height === 'undefined' ? 10 : min.height;
var computedMaxHeight = typeof max.height === 'undefined' || max.height < 0 ? newHeight : max.height;
var extraHeight = lockAspectRatioExtraHeight || 0;
var extraWidth = lockAspectRatioExtraWidth || 0;
if (lockAspectRatio) {
var extraMinWidth = (computedMinHeight - extraHeight) * this.ratio + extraWidth;
var extraMaxWidth = (computedMaxHeight - extraHeight) * this.ratio + extraWidth;
var extraMinHeight = (computedMinWidth - extraWidth) / this.ratio + extraHeight;
var extraMaxHeight = (computedMaxWidth - extraWidth) / this.ratio + extraHeight;
var lockedMinWidth = Math.max(computedMinWidth, extraMinWidth);
var lockedMaxWidth = Math.min(computedMaxWidth, extraMaxWidth);
var lockedMinHeight = Math.max(computedMinHeight, extraMinHeight);
var lockedMaxHeight = Math.min(computedMaxHeight, extraMaxHeight);
newWidth = lib_clamp(newWidth, lockedMinWidth, lockedMaxWidth);
newHeight = lib_clamp(newHeight, lockedMinHeight, lockedMaxHeight);
}
else {
newWidth = lib_clamp(newWidth, computedMinWidth, computedMaxWidth);
newHeight = lib_clamp(newHeight, computedMinHeight, computedMaxHeight);
}
return { newWidth: newWidth, newHeight: newHeight };
};
Resizable.prototype.setBoundingClientRect = function () {
// For parent boundary
if (this.props.bounds === 'parent') {
var parent_2 = this.parentNode;
if (parent_2) {
var parentRect = parent_2.getBoundingClientRect();
this.parentLeft = parentRect.left;
this.parentTop = parentRect.top;
}
}
// For target(html element) boundary
if (this.props.bounds && typeof this.props.bounds !== 'string') {
var targetRect = this.props.bounds.getBoundingClientRect();
this.targetLeft = targetRect.left;
this.targetTop = targetRect.top;
}
// For boundary
if (this.resizable) {
var _a = this.resizable.getBoundingClientRect(), left = _a.left, top_1 = _a.top, right = _a.right, bottom = _a.bottom;
this.resizableLeft = left;
this.resizableRight = right;
this.resizableTop = top_1;
this.resizableBottom = bottom;
}
};
Resizable.prototype.onResizeStart = function (event, direction) {
if (!this.resizable || !this.window) {
return;
}
var clientX = 0;
var clientY = 0;
if (event.nativeEvent && isMouseEvent(event.nativeEvent)) {
clientX = event.nativeEvent.clientX;
clientY = event.nativeEvent.clientY;
}
else if (event.nativeEvent && isTouchEvent(event.nativeEvent)) {
clientX = event.nativeEvent.touches[0].clientX;
clientY = event.nativeEvent.touches[0].clientY;
}
if (this.props.onResizeStart) {
if (this.resizable) {
var startResize = this.props.onResizeStart(event, direction, this.resizable);
if (startResize === false) {
return;
}
}
}
// Fix #168
if (this.props.size) {
if (typeof this.props.size.height !== 'undefined' && this.props.size.height !== this.state.height) {
this.setState({ height: this.props.size.height });
}
if (typeof this.props.size.width !== 'undefined' && this.props.size.width !== this.state.width) {
this.setState({ width: this.props.size.width });
}
}
// For lockAspectRatio case
this.ratio =
typeof this.props.lockAspectRatio === 'number' ? this.props.lockAspectRatio : this.size.width / this.size.height;
var flexBasis;
var computedStyle = this.window.getComputedStyle(this.resizable);
if (computedStyle.flexBasis !== 'auto') {
var parent_3 = this.parentNode;
if (parent_3) {
var dir = this.window.getComputedStyle(parent_3).flexDirection;
this.flexDir = dir.startsWith('row') ? 'row' : 'column';
flexBasis = computedStyle.flexBasis;
}
}
// For boundary
this.setBoundingClientRect();
this.bindEvents();
var state = {
original: {
x: clientX,
y: clientY,
width: this.size.width,
height: this.size.height,
},
isResizing: true,
backgroundStyle: lib_assign(lib_assign({}, this.state.backgroundStyle), { cursor: this.window.getComputedStyle(event.target).cursor || 'auto' }),
direction: direction,
flexBasis: flexBasis,
};
this.setState(state);
};
Resizable.prototype.onMouseMove = function (event) {
var _this = this;
if (!this.state.isResizing || !this.resizable || !this.window) {
return;
}
if (this.window.TouchEvent && isTouchEvent(event)) {
try {
event.preventDefault();
event.stopPropagation();
}
catch (e) {
// Ignore on fail
}
}
var _a = this.props, maxWidth = _a.maxWidth, maxHeight = _a.maxHeight, minWidth = _a.minWidth, minHeight = _a.minHeight;
var clientX = isTouchEvent(event) ? event.touches[0].clientX : event.clientX;
var clientY = isTouchEvent(event) ? event.touches[0].clientY : event.clientY;
var _b = this.state, direction = _b.direction, original = _b.original, width = _b.width, height = _b.height;
var parentSize = this.getParentSize();
var max = calculateNewMax(parentSize, this.window.innerWidth, this.window.innerHeight, maxWidth, maxHeight, minWidth, minHeight);
maxWidth = max.maxWidth;
maxHeight = max.maxHeight;
minWidth = max.minWidth;
minHeight = max.minHeight;
// Calculate new size
var _c = this.calculateNewSizeFromDirection(clientX, clientY), newHeight = _c.newHeight, newWidth = _c.newWidth;
// Calculate max size from boundary settings
var boundaryMax = this.calculateNewMaxFromBoundary(maxWidth, maxHeight);
if (this.props.snap && this.props.snap.x) {
newWidth = findClosestSnap(newWidth, this.props.snap.x, this.props.snapGap);
}
if (this.props.snap && this.props.snap.y) {
newHeight = findClosestSnap(newHeight, this.props.snap.y, this.props.snapGap);
}
// Calculate new size from aspect ratio
var newSize = this.calculateNewSizeFromAspectRatio(newWidth, newHeight, { width: boundaryMax.maxWidth, height: boundaryMax.maxHeight }, { width: minWidth, height: minHeight });
newWidth = newSize.newWidth;
newHeight = newSize.newHeight;
if (this.props.grid) {
var newGridWidth = snap(newWidth, this.props.grid[0]);
var newGridHeight = snap(newHeight, this.props.grid[1]);
var gap = this.props.snapGap || 0;
newWidth = gap === 0 || Math.abs(newGridWidth - newWidth) <= gap ? newGridWidth : newWidth;
newHeight = gap === 0 || Math.abs(newGridHeight - newHeight) <= gap ? newGridHeight : newHeight;
}
var delta = {
width: newWidth - original.width,
height: newHeight - original.height,
};
if (width && typeof width === 'string') {
if (width.endsWith('%')) {
var percent = (newWidth / parentSize.width) * 100;
newWidth = percent + "%";
}
else if (width.endsWith('vw')) {
var vw = (newWidth / this.window.innerWidth) * 100;
newWidth = vw + "vw";
}
else if (width.endsWith('vh')) {
var vh = (newWidth / this.window.innerHeight) * 100;
newWidth = vh + "vh";
}
}
if (height && typeof height === 'string') {
if (height.endsWith('%')) {
var percent = (newHeight / parentSize.height) * 100;
newHeight = percent + "%";
}
else if (height.endsWith('vw')) {
var vw = (newHeight / this.window.innerWidth) * 100;
newHeight = vw + "vw";
}
else if (height.endsWith('vh')) {
var vh = (newHeight / this.window.innerHeight) * 100;
newHeight = vh + "vh";
}
}
var newState = {
width: this.createSizeForCssProperty(newWidth, 'width'),
height: this.createSizeForCssProperty(newHeight, 'height'),
};
if (this.flexDir === 'row') {
newState.flexBasis = newState.width;
}
else if (this.flexDir === 'column') {
newState.flexBasis = newState.height;
}
// For v18, update state sync
(0,external_ReactDOM_namespaceObject.flushSync)(function () {
_this.setState(newState);
});
if (this.props.onResize) {
this.props.onResize(event, direction, this.resizable, delta);
}
};
Resizable.prototype.onMouseUp = function (event) {
var _a = this.state, isResizing = _a.isResizing, direction = _a.direction, original = _a.original;
if (!isResizing || !this.resizable) {
return;
}
var delta = {
width: this.size.width - original.width,
height: this.size.height - original.height,
};
if (this.props.onResizeStop) {
this.props.onResizeStop(event, direction, this.resizable, delta);
}
if (this.props.size) {
this.setState(this.props.size);
}
this.unbindEvents();
this.setState({
isResizing: false,
backgroundStyle: lib_assign(lib_assign({}, this.state.backgroundStyle), { cursor: 'auto' }),
});
};
Resizable.prototype.updateSize = function (size) {
this.setState({ width: size.width, height: size.height });
};
Resizable.prototype.renderResizer = function () {
var _this = this;
var _a = this.props, enable = _a.enable, handleStyles = _a.handleStyles, handleClasses = _a.handleClasses, handleWrapperStyle = _a.handleWrapperStyle, handleWrapperClass = _a.handleWrapperClass, handleComponent = _a.handleComponent;
if (!enable) {
return null;
}
var resizers = Object.keys(enable).map(function (dir) {
if (enable[dir] !== false) {
return (external_React_.createElement(Resizer, { key: dir, direction: dir, onResizeStart: _this.onResizeStart, replaceStyles: handleStyles && handleStyles[dir], className: handleClasses && handleClasses[dir] }, handleComponent && handleComponent[dir] ? handleComponent[dir] : null));
}
return null;
});
// #93 Wrap the resize box in span (will not break 100% width/height)
return (external_React_.createElement("div", { className: handleWrapperClass, style: handleWrapperStyle }, resizers));
};
Resizable.prototype.render = function () {
var _this = this;
var extendsProps = Object.keys(this.props).reduce(function (acc, key) {
if (definedProps.indexOf(key) !== -1) {
return acc;
}
acc[key] = _this.props[key];
return acc;
}, {});
var style = lib_assign(lib_assign(lib_assign({ position: 'relative', userSelect: this.state.isResizing ? 'none' : 'auto' }, this.props.style), this.sizeStyle), { maxWidth: this.props.maxWidth, maxHeight: this.props.maxHeight, minWidth: this.props.minWidth, minHeight: this.props.minHeight, boxSizing: 'border-box', flexShrink: 0 });
if (this.state.flexBasis) {
style.flexBasis = this.state.flexBasis;
}
var Wrapper = this.props.as || 'div';
return (external_React_.createElement(Wrapper, lib_assign({ ref: this.ref, style: style, className: this.props.className }, extendsProps),
this.state.isResizing && external_React_.createElement("div", { style: this.state.backgroundStyle }),
this.props.children,
this.renderResizer()));
};
Resizable.defaultProps = {
as: 'div',
onResizeStart: function () { },
onResize: function () { },
onResizeStop: function () { },
enable: {
top: true,
right: true,
bottom: true,
left: true,
topRight: true,
bottomRight: true,
bottomLeft: true,
topLeft: true,
},
style: {},
grid: [1, 1],
lockAspectRatio: false,
lockAspectRatioExtraWidth: 0,
lockAspectRatioExtraHeight: 0,
scale: 1,
resizeRatio: 1,
snapGap: 0,
};
return Resizable;
}(external_React_.PureComponent));
;// ./node_modules/@wordpress/components/build-module/resizable-box/resize-tooltip/utils.js
const utils_noop = () => {
};
const POSITIONS = {
bottom: "bottom",
corner: "corner"
};
function useResizeLabel({
axis,
fadeTimeout = 180,
onResize = utils_noop,
position = POSITIONS.bottom,
showPx = false
}) {
const [resizeListener, sizes] = (0,external_wp_compose_namespaceObject.useResizeObserver)();
const isAxisControlled = !!axis;
const [moveX, setMoveX] = (0,external_wp_element_namespaceObject.useState)(false);
const [moveY, setMoveY] = (0,external_wp_element_namespaceObject.useState)(false);
const {
width,
height
} = sizes;
const heightRef = (0,external_wp_element_namespaceObject.useRef)(height);
const widthRef = (0,external_wp_element_namespaceObject.useRef)(width);
const moveTimeoutRef = (0,external_wp_element_namespaceObject.useRef)();
const debounceUnsetMoveXY = (0,external_wp_element_namespaceObject.useCallback)(() => {
const unsetMoveXY = () => {
if (isAxisControlled) {
return;
}
setMoveX(false);
setMoveY(false);
};
if (moveTimeoutRef.current) {
window.clearTimeout(moveTimeoutRef.current);
}
moveTimeoutRef.current = window.setTimeout(unsetMoveXY, fadeTimeout);
}, [fadeTimeout, isAxisControlled]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const isRendered = width !== null || height !== null;
if (!isRendered) {
return;
}
const didWidthChange = width !== widthRef.current;
const didHeightChange = height !== heightRef.current;
if (!didWidthChange && !didHeightChange) {
return;
}
if (width && !widthRef.current && height && !heightRef.current) {
widthRef.current = width;
heightRef.current = height;
return;
}
if (didWidthChange) {
setMoveX(true);
widthRef.current = width;
}
if (didHeightChange) {
setMoveY(true);
heightRef.current = height;
}
onResize({
width,
height
});
debounceUnsetMoveXY();
}, [width, height, onResize, debounceUnsetMoveXY]);
const label = getSizeLabel({
axis,
height,
moveX,
moveY,
position,
showPx,
width
});
return {
label,
resizeListener
};
}
function getSizeLabel({
axis,
height,
moveX = false,
moveY = false,
position = POSITIONS.bottom,
showPx = false,
width
}) {
if (!moveX && !moveY) {
return void 0;
}
if (position === POSITIONS.corner) {
return `${width} x ${height}`;
}
const labelUnit = showPx ? " px" : "";
if (axis) {
if (axis === "x" && moveX) {
return `${width}${labelUnit}`;
}
if (axis === "y" && moveY) {
return `${height}${labelUnit}`;
}
}
if (moveX && moveY) {
return `${width} x ${height}`;
}
if (moveX) {
return `${width}${labelUnit}`;
}
if (moveY) {
return `${height}${labelUnit}`;
}
return void 0;
}
;// ./node_modules/@wordpress/components/build-module/resizable-box/resize-tooltip/styles/resize-tooltip.styles.js
function resize_tooltip_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const resize_tooltip_styles_Root = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1wq7y4k3"
} : 0)( true ? {
name: "1cd7zoc",
styles: "bottom:0;box-sizing:border-box;left:0;pointer-events:none;position:absolute;right:0;top:0"
} : 0);
const TooltipWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1wq7y4k2"
} : 0)( true ? {
name: "ajymcs",
styles: "align-items:center;box-sizing:border-box;display:inline-flex;justify-content:center;opacity:0;pointer-events:none;transition:opacity 120ms linear"
} : 0);
const resize_tooltip_styles_Tooltip = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1wq7y4k1"
} : 0)("background:", COLORS.theme.foreground, ";border-radius:", config_values_default.radiusSmall, ";box-sizing:border-box;font-family:", font("default.fontFamily"), ";font-size:12px;color:", COLORS.theme.foregroundInverted, ";padding:4px 8px;position:relative;" + ( true ? "" : 0));
const LabelText = /* @__PURE__ */ emotion_styled_base_browser_esm(text_component_component_default, true ? {
target: "e1wq7y4k0"
} : 0)("&&&{color:", COLORS.theme.foregroundInverted, ";display:block;font-size:13px;line-height:1.4;white-space:nowrap;}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/resizable-box/resize-tooltip/label.js
const CORNER_OFFSET = 4;
const CURSOR_OFFSET_TOP = CORNER_OFFSET * 2.5;
function resize_tooltip_label_Label({
label,
position = POSITIONS.corner,
zIndex = 1e3,
...props
}, ref) {
const showLabel = !!label;
const isBottom = position === POSITIONS.bottom;
const isCorner = position === POSITIONS.corner;
if (!showLabel) {
return null;
}
let style = {
opacity: showLabel ? 1 : void 0,
zIndex
};
let labelStyle = {};
if (isBottom) {
style = {
...style,
position: "absolute",
bottom: CURSOR_OFFSET_TOP * -1,
left: "50%",
transform: "translate(-50%, 0)"
};
labelStyle = {
transform: `translate(0, 100%)`
};
}
if (isCorner) {
style = {
...style,
position: "absolute",
top: CORNER_OFFSET,
right: (0,external_wp_i18n_namespaceObject.isRTL)() ? void 0 : CORNER_OFFSET,
left: (0,external_wp_i18n_namespaceObject.isRTL)() ? CORNER_OFFSET : void 0
};
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TooltipWrapper, {
"aria-hidden": "true",
className: "components-resizable-tooltip__tooltip-wrapper",
ref,
style,
...props,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(resize_tooltip_styles_Tooltip, {
className: "components-resizable-tooltip__tooltip",
style: labelStyle,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(LabelText, {
as: "span",
children: label
})
})
});
}
const label_ForwardedComponent = (0,external_wp_element_namespaceObject.forwardRef)(resize_tooltip_label_Label);
var label_default = label_ForwardedComponent;
;// ./node_modules/@wordpress/components/build-module/resizable-box/resize-tooltip/index.js
const resize_tooltip_noop = () => {
};
function ResizeTooltip({
axis,
className,
fadeTimeout = 180,
isVisible = true,
labelRef,
onResize = resize_tooltip_noop,
position = POSITIONS.bottom,
showPx = true,
zIndex = 1e3,
...props
}, ref) {
const {
label,
resizeListener
} = useResizeLabel({
axis,
fadeTimeout,
onResize,
showPx,
position
});
if (!isVisible) {
return null;
}
const classes = dist_clsx("components-resize-tooltip", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(resize_tooltip_styles_Root, {
"aria-hidden": "true",
className: classes,
ref,
...props,
children: [resizeListener, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(label_default, {
"aria-hidden": props["aria-hidden"],
label,
position,
ref: labelRef,
zIndex
})]
});
}
const resize_tooltip_ForwardedComponent = (0,external_wp_element_namespaceObject.forwardRef)(ResizeTooltip);
var resize_tooltip_default = resize_tooltip_ForwardedComponent;
;// ./node_modules/@wordpress/components/build-module/resizable-box/index.js
const HANDLE_CLASS_NAME = "components-resizable-box__handle";
const SIDE_HANDLE_CLASS_NAME = "components-resizable-box__side-handle";
const CORNER_HANDLE_CLASS_NAME = "components-resizable-box__corner-handle";
const HANDLE_CLASSES = {
top: dist_clsx(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-top"),
right: dist_clsx(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-right"),
bottom: dist_clsx(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-bottom"),
left: dist_clsx(HANDLE_CLASS_NAME, SIDE_HANDLE_CLASS_NAME, "components-resizable-box__handle-left"),
topLeft: dist_clsx(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-top", "components-resizable-box__handle-left"),
topRight: dist_clsx(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-top", "components-resizable-box__handle-right"),
bottomRight: dist_clsx(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-bottom", "components-resizable-box__handle-right"),
bottomLeft: dist_clsx(HANDLE_CLASS_NAME, CORNER_HANDLE_CLASS_NAME, "components-resizable-box__handle-bottom", "components-resizable-box__handle-left")
};
const HANDLE_STYLES_OVERRIDES = {
width: void 0,
height: void 0,
top: void 0,
right: void 0,
bottom: void 0,
left: void 0
};
const HANDLE_STYLES = {
top: HANDLE_STYLES_OVERRIDES,
right: HANDLE_STYLES_OVERRIDES,
bottom: HANDLE_STYLES_OVERRIDES,
left: HANDLE_STYLES_OVERRIDES,
topLeft: HANDLE_STYLES_OVERRIDES,
topRight: HANDLE_STYLES_OVERRIDES,
bottomRight: HANDLE_STYLES_OVERRIDES,
bottomLeft: HANDLE_STYLES_OVERRIDES
};
function UnforwardedResizableBox({
className,
children,
showHandle = true,
__experimentalShowTooltip: showTooltip = false,
__experimentalTooltipProps: tooltipProps = {},
...props
}, ref) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(Resizable, {
className: dist_clsx("components-resizable-box__container", showHandle && "has-show-handle", className),
handleComponent: Object.fromEntries(Object.keys(HANDLE_CLASSES).map((key) => [key, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
tabIndex: -1
}, key)])),
handleClasses: HANDLE_CLASSES,
handleStyles: HANDLE_STYLES,
ref,
...props,
children: [children, showTooltip && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(resize_tooltip_default, {
...tooltipProps
})]
});
}
const ResizableBox = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedResizableBox);
var resizable_box_default = ResizableBox;
;// ./node_modules/@wordpress/components/build-module/responsive-wrapper/index.js
function ResponsiveWrapper({
naturalWidth,
naturalHeight,
children,
isInline = false
}) {
if (external_wp_element_namespaceObject.Children.count(children) !== 1) {
return null;
}
const TagName = isInline ? "span" : "div";
let aspectRatio;
if (naturalWidth && naturalHeight) {
aspectRatio = `${naturalWidth} / ${naturalHeight}`;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TagName, {
className: "components-responsive-wrapper",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
children: (0,external_wp_element_namespaceObject.cloneElement)(children, {
className: dist_clsx("components-responsive-wrapper__content", children.props.className),
style: {
...children.props.style,
aspectRatio
}
})
})
});
}
var responsive_wrapper_default = ResponsiveWrapper;
;// ./node_modules/@wordpress/components/build-module/sandbox/index.js
const observeAndResizeJS = function() {
const {
MutationObserver
} = window;
if (!MutationObserver || !document.body || !window.parent) {
return;
}
function sendResize() {
const clientBoundingRect = document.body.getBoundingClientRect();
window.parent.postMessage({
action: "resize",
width: clientBoundingRect.width,
height: clientBoundingRect.height
}, "*");
}
const observer = new MutationObserver(sendResize);
observer.observe(document.body, {
attributes: true,
attributeOldValue: false,
characterData: true,
characterDataOldValue: false,
childList: true,
subtree: true
});
window.addEventListener("load", sendResize, true);
function removeViewportStyles(ruleOrNode) {
if (ruleOrNode.style) {
["width", "height", "minHeight", "maxHeight"].forEach(function(style2) {
if (/^\\d+(vw|vh|svw|lvw|dvw|svh|lvh|dvh|vi|svi|lvi|dvi|vb|svb|lvb|dvb|vmin|svmin|lvmin|dvmin|vmax|svmax|lvmax|dvmax)$/.test(ruleOrNode.style[style2])) {
ruleOrNode.style[style2] = "";
}
});
}
}
Array.prototype.forEach.call(document.querySelectorAll("[style]"), removeViewportStyles);
Array.prototype.forEach.call(document.styleSheets, function(stylesheet) {
Array.prototype.forEach.call(stylesheet.cssRules || stylesheet.rules, removeViewportStyles);
});
document.body.style.position = "absolute";
document.body.style.width = "100%";
document.body.setAttribute("data-resizable-iframe-connected", "");
sendResize();
window.addEventListener("resize", sendResize, true);
};
const sandbox_style = `
body {
margin: 0;
}
html,
body,
body > div {
width: 100%;
}
html.wp-has-aspect-ratio,
body.wp-has-aspect-ratio,
body.wp-has-aspect-ratio > div,
body.wp-has-aspect-ratio > div iframe {
width: 100%;
height: 100%;
overflow: hidden; /* If it has an aspect ratio, it shouldn't scroll. */
}
body > div > * {
margin-top: 0 !important; /* Has to have !important to override inline styles. */
margin-bottom: 0 !important;
}
`;
function SandBox({
html = "",
title = "",
type,
styles = [],
scripts = [],
onFocus,
tabIndex
}) {
const ref = (0,external_wp_element_namespaceObject.useRef)();
const [width, setWidth] = (0,external_wp_element_namespaceObject.useState)(0);
const [height, setHeight] = (0,external_wp_element_namespaceObject.useState)(0);
function isFrameAccessible() {
try {
return !!ref.current?.contentDocument?.body;
} catch (e) {
return false;
}
}
function trySandBox(forceRerender = false) {
if (!isFrameAccessible()) {
return;
}
const {
contentDocument,
ownerDocument
} = ref.current;
if (!forceRerender && null !== contentDocument?.body.getAttribute("data-resizable-iframe-connected")) {
return;
}
const htmlDoc = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("html", {
lang: ownerDocument.documentElement.lang,
className: type,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("head", {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("title", {
children: title
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("style", {
dangerouslySetInnerHTML: {
__html: sandbox_style
}
}), styles.map((rules, i) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("style", {
dangerouslySetInnerHTML: {
__html: rules
}
}, i))]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("body", {
"data-resizable-iframe-connected": "data-resizable-iframe-connected",
className: type,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
dangerouslySetInnerHTML: {
__html: html
}
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("script", {
type: "text/javascript",
dangerouslySetInnerHTML: {
__html: `(${observeAndResizeJS.toString()})();`
}
}), scripts.map((src) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("script", {
src
}, src))]
})]
});
contentDocument.open();
contentDocument.write("<!DOCTYPE html>" + (0,external_wp_element_namespaceObject.renderToString)(htmlDoc));
contentDocument.close();
}
(0,external_wp_element_namespaceObject.useEffect)(() => {
trySandBox();
function tryNoForceSandBox() {
trySandBox(false);
}
function checkMessageForResize(event) {
const iframe2 = ref.current;
if (!iframe2 || iframe2.contentWindow !== event.source) {
return;
}
let data = event.data || {};
if ("string" === typeof data) {
try {
data = JSON.parse(data);
} catch (e) {
}
}
if ("resize" !== data.action) {
return;
}
setWidth(data.width);
setHeight(data.height);
}
const iframe = ref.current;
const defaultView = iframe?.ownerDocument?.defaultView;
iframe?.addEventListener("load", tryNoForceSandBox, false);
defaultView?.addEventListener("message", checkMessageForResize);
return () => {
iframe?.removeEventListener("load", tryNoForceSandBox, false);
defaultView?.removeEventListener("message", checkMessageForResize);
};
}, []);
(0,external_wp_element_namespaceObject.useEffect)(() => {
trySandBox();
}, [title, styles, scripts]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
trySandBox(true);
}, [html, type]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("iframe", {
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, (0,external_wp_compose_namespaceObject.useFocusableIframe)()]),
title,
tabIndex,
className: "components-sandbox",
sandbox: "allow-scripts allow-same-origin allow-presentation",
onFocus,
width: Math.ceil(width),
height: Math.ceil(height)
});
}
var sandbox_default = SandBox;
;// ./node_modules/@wordpress/components/build-module/snackbar/index.js
const NOTICE_TIMEOUT = 1e4;
function snackbar_useSpokenMessage(message, politeness) {
const spokenMessage = typeof message === "string" ? message : (0,external_wp_element_namespaceObject.renderToString)(message);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (spokenMessage) {
(0,external_wp_a11y_namespaceObject.speak)(spokenMessage, politeness);
}
}, [spokenMessage, politeness]);
}
function UnforwardedSnackbar({
className,
children,
spokenMessage = children,
politeness = "polite",
actions = [],
onRemove,
icon = null,
explicitDismiss = false,
// onDismiss is a callback executed when the snackbar is dismissed.
// It is distinct from onRemove, which _looks_ like a callback but is
// actually the function to call to remove the snackbar from the UI.
onDismiss,
listRef
}, ref) {
function dismissMe(event) {
if (event && event.preventDefault) {
event.preventDefault();
}
listRef?.current?.focus();
onDismiss?.();
onRemove?.();
}
function onActionClick(event, onClick) {
event.stopPropagation();
onRemove?.();
if (onClick) {
onClick(event);
}
}
snackbar_useSpokenMessage(spokenMessage, politeness);
const callbacksRef = (0,external_wp_element_namespaceObject.useRef)({
onDismiss,
onRemove
});
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
callbacksRef.current = {
onDismiss,
onRemove
};
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
const timeoutHandle = setTimeout(() => {
if (!explicitDismiss) {
callbacksRef.current.onDismiss?.();
callbacksRef.current.onRemove?.();
}
}, NOTICE_TIMEOUT);
return () => clearTimeout(timeoutHandle);
}, [explicitDismiss]);
const classes = dist_clsx(className, "components-snackbar", {
"components-snackbar-explicit-dismiss": !!explicitDismiss
});
if (actions && actions.length > 1) {
true ? external_wp_warning_default()("Snackbar can only have one action. Use Notice if your message requires many actions.") : 0;
actions = [actions[0]];
}
const snackbarContentClassnames = dist_clsx("components-snackbar__content", {
"components-snackbar__content-with-icon": !!icon
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref,
className: classes,
onClick: !explicitDismiss ? dismissMe : void 0,
tabIndex: 0,
role: !explicitDismiss ? "button" : void 0,
onKeyPress: !explicitDismiss ? dismissMe : void 0,
"aria-label": !explicitDismiss ? (0,external_wp_i18n_namespaceObject.__)("Dismiss this notice") : void 0,
"data-testid": "snackbar",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: snackbarContentClassnames,
children: [icon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-snackbar__icon",
children: icon
}), children, actions.map(({
label,
onClick,
url,
openInNewTab = false
}, index) => url !== void 0 && openInNewTab ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_link_default, {
href: url,
onClick: (event) => onActionClick(event, onClick),
className: "components-snackbar__action",
children: label
}, index) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
href: url,
variant: "link",
onClick: (event) => onActionClick(event, onClick),
className: "components-snackbar__action",
children: label
}, index)), explicitDismiss && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
role: "button",
"aria-label": (0,external_wp_i18n_namespaceObject.__)("Dismiss this notice"),
tabIndex: 0,
className: "components-snackbar__dismiss-button",
onClick: dismissMe,
onKeyPress: dismissMe,
children: "\u2715"
})]
})
});
}
const Snackbar = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedSnackbar);
var snackbar_default = Snackbar;
;// ./node_modules/@wordpress/components/build-module/snackbar/list.js
const SNACKBAR_VARIANTS = {
init: {
height: 0,
opacity: 0
},
open: {
height: "auto",
opacity: 1,
transition: {
height: {
type: "tween",
duration: 0.3,
ease: [0, 0, 0.2, 1]
},
opacity: {
type: "tween",
duration: 0.25,
delay: 0.05,
ease: [0, 0, 0.2, 1]
}
}
},
exit: {
opacity: 0,
transition: {
type: "tween",
duration: 0.1,
ease: [0, 0, 0.2, 1]
}
}
};
function SnackbarList({
notices,
className,
children,
onRemove
}) {
const listRef = (0,external_wp_element_namespaceObject.useRef)(null);
const isReducedMotion = (0,external_wp_compose_namespaceObject.useReducedMotion)();
className = dist_clsx("components-snackbar-list", className);
const removeNotice = (notice) => () => onRemove?.(notice.id);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className,
tabIndex: -1,
ref: listRef,
"data-testid": "snackbar-list",
children: [children, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(AnimatePresence, {
children: notices.map((notice) => {
const {
content,
...restNotice
} = notice;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(motion.div, {
layout: !isReducedMotion,
initial: "init",
animate: "open",
exit: "exit",
variants: isReducedMotion ? void 0 : SNACKBAR_VARIANTS,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className: "components-snackbar-list__notice-container",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(snackbar_default, {
...restNotice,
onRemove: removeNotice(notice),
listRef,
children: notice.content
})
})
}, notice.id);
})
})]
});
}
var list_list_default = SnackbarList;
;// ./node_modules/@wordpress/components/build-module/surface/component.js
function UnconnectedSurface(props, forwardedRef) {
const surfaceProps = useSurface(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...surfaceProps,
ref: forwardedRef
});
}
const component_Surface = contextConnect(UnconnectedSurface, "Surface");
var surface_component_component_default = component_Surface;
;// ./node_modules/@ariakit/core/esm/tab/tab-store.js
"use client";
// src/tab/tab-store.ts
function createTabStore(_a = {}) {
var _b = _a, {
composite: parentComposite,
combobox
} = _b, props = _3YLGPPWQ_objRest(_b, [
"composite",
"combobox"
]);
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(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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, prev) => {
if (!syncActiveId) {
syncActiveId = true;
return;
}
if (parentComposite && state.selectedId === prev.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(
(item) => !item.disabled && !item.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, i) => {
if (panel.tabId) return;
const tabItem = tabs[i];
if (!tabItem) return;
panels.renderItem(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, composite), tab), {
panels,
setSelectedId: (id) => tab.setState("selectedId", id),
select: (id) => {
tab.setState("selectedId", id);
composite.move(id);
}
});
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/PY4NZ6HS.js
"use client";
// src/tab/tab-store.ts
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] = YV4JVR4I_useStore(() => store.panels, {});
useUpdateEffect(updatePanels, [store, updatePanels]);
return Object.assign(
(0,external_React_.useMemo)(() => _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, store), { panels }), [store, panels]),
{ composite: props.composite, combobox: props.combobox }
);
}
function useTabStore(props = {}) {
const combobox = useComboboxContext();
const composite = useSelectContext() || combobox;
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
composite: props.composite !== void 0 ? props.composite : composite,
combobox: props.combobox !== void 0 ? props.combobox : combobox
});
const [store, update] = YV4JVR4I_useStore(createTabStore, props);
return useTabStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/UYGDZTLQ.js
"use client";
// src/tab/tab-context.tsx
var UYGDZTLQ_ctx = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var useTabContext = UYGDZTLQ_ctx.useContext;
var useTabScopedContext = UYGDZTLQ_ctx.useScopedContext;
var useTabProviderContext = UYGDZTLQ_ctx.useProviderContext;
var TabContextProvider = UYGDZTLQ_ctx.ContextProvider;
var TabScopedContextProvider = UYGDZTLQ_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/tab/tab-list.js
"use client";
// src/tab/tab-list.tsx
var tab_list_TagName = "div";
var useTabList = createHook(
function useTabList2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useTabProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const orientation = store.useState(
(state) => state.orientation === "both" ? void 0 : state.orientation
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TabScopedContextProvider, { value: store, children: element }),
[store]
);
if (store.composite) {
props = _3YLGPPWQ_spreadValues({
focusable: false
}, props);
}
props = _3YLGPPWQ_spreadValues({
role: "tablist",
"aria-orientation": orientation
}, props);
props = useComposite(_3YLGPPWQ_spreadValues({ store }, props));
return props;
}
);
var TabList = forwardRef2(function TabList2(props) {
const htmlProps = useTabList(props);
return LMDWO4NN_createElement(tab_list_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/tab/tab.js
"use client";
// src/tab/tab.tsx
var tab_TagName = "button";
var useTab = createHook(function useTab2(_a) {
var _b = _a, {
store,
getItem: getItemProp
} = _b, props = __objRest(_b, [
"store",
"getItem"
]);
var _a2;
const context = useTabScopedContext();
store = store || context;
invariant(
store,
false && 0
);
const defaultId = useId();
const id = props.id || defaultId;
const dimmed = disabledFromProps(props);
const getItem = (0,external_React_.useCallback)(
(item) => {
const nextItem = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, item), { 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(id);
});
const panelId = store.panels.useState(
(state) => {
var _a3;
return (_a3 = state.items.find((item) => item.tabId === id)) == null ? void 0 : _a3.id;
}
);
const shouldRegisterItem = defaultId ? props.shouldRegisterItem : false;
const isActive = store.useState((state) => !!id && state.activeId === id);
const selected = store.useState((state) => !!id && state.selectedId === id);
const hasActiveItem = store.useState((state) => !!store.item(state.activeId));
const canRegisterComposedItem = isActive || selected && !hasActiveItem;
const accessibleWhenDisabled = selected || ((_a2 = props.accessibleWhenDisabled) != null ? _a2 : true);
const isWithinVirtualFocusComposite = useStoreState(
store.combobox || store.composite,
"virtualFocus"
);
if (isWithinVirtualFocusComposite) {
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
tabIndex: -1
});
}
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
role: "tab",
"aria-selected": selected,
"aria-controls": panelId || void 0
}, props), {
onClick
});
if (store.composite) {
const defaultProps = {
id,
accessibleWhenDisabled,
store: store.composite,
shouldRegisterItem: canRegisterComposedItem && shouldRegisterItem,
rowId: props.rowId,
render: props.render
};
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
CompositeItem,
_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, defaultProps), {
render: store.combobox && store.composite !== store.combobox ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(CompositeItem, _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, defaultProps), { store: store.combobox })) : defaultProps.render
})
)
});
}
props = useCompositeItem(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
store
}, props), {
accessibleWhenDisabled,
getItem,
shouldRegisterItem
}));
return props;
});
var Tab = memo2(
forwardRef2(function Tab2(props) {
const htmlProps = useTab(props);
return LMDWO4NN_createElement(tab_TagName, htmlProps);
})
);
;// ./node_modules/@ariakit/react-core/esm/tab/tab-panel.js
"use client";
// src/tab/tab-panel.tsx
var tab_panel_TagName = "div";
var useTabPanel = createHook(
function useTabPanel2(_a) {
var _b = _a, {
store,
unmountOnHide,
tabId: tabIdProp,
getItem: getItemProp,
scrollRestoration,
scrollElement
} = _b, props = __objRest(_b, [
"store",
"unmountOnHide",
"tabId",
"getItem",
"scrollRestoration",
"scrollElement"
]);
const context = useTabProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const ref = (0,external_React_.useRef)(null);
const id = useId(props.id);
const tabId = useStoreState(
store.panels,
() => {
var _a2;
return tabIdProp || ((_a2 = store == null ? void 0 : store.panels.item(id)) == null ? void 0 : _a2.tabId);
}
);
const open = useStoreState(
store,
(state) => !!tabId && state.selectedId === tabId
);
const disclosure = useDisclosureStore({ open });
const mounted = useStoreState(disclosure, "mounted");
const scrollPositionRef = (0,external_React_.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,external_React_.useEffect)(() => {
var _a2, _b2;
if (!scrollRestoration) return;
if (!mounted) return;
const element = getScrollElement();
if (!element) return;
if (scrollRestoration === "reset") {
element.scroll(0, 0);
return;
}
if (!tabId) return;
const position = scrollPositionRef.current.get(tabId);
element.scroll((_a2 = position == null ? void 0 : position.x) != null ? _a2 : 0, (_b2 = position == null ? void 0 : position.y) != null ? _b2 : 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,external_React_.useState)(false);
(0,external_React_.useEffect)(() => {
const element = ref.current;
if (!element) return;
const tabbable = getAllTabbableIn(element);
setHasTabbableChildren(!!tabbable.length);
}, []);
const getItem = (0,external_React_.useCallback)(
(item) => {
const nextItem = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, item), { id: id || item.id, tabId: tabIdProp });
if (getItemProp) {
return getItemProp(nextItem);
}
return nextItem;
},
[id, 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,external_ReactJSXRuntime_namespaceObject.jsx)(TabScopedContextProvider, { value: store, children: element }),
[store]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
role: "tabpanel",
"aria-labelledby": tabId || void 0
}, props), {
children: unmountOnHide && !mounted ? null : props.children,
ref: useMergeRefs(ref, props.ref),
onKeyDown
});
props = useFocusable(_3YLGPPWQ_spreadValues({
// 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(_3YLGPPWQ_spreadValues({ store: disclosure }, props));
props = useCollectionItem(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({ store: store.panels }, props), { getItem }));
return props;
}
);
var TabPanel = forwardRef2(function TabPanel2(props) {
const htmlProps = useTabPanel(props);
return LMDWO4NN_createElement(tab_panel_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/tab-panel/index.js
const extractTabName = (id) => {
if (typeof id === "undefined" || id === null) {
return;
}
return id.match(/^tab-panel-[0-9]*-(.*)/)?.[1];
};
const UnforwardedTabPanel = ({
className,
children,
tabs,
selectOnMove = true,
initialTabName,
orientation = "horizontal",
activeClass = "is-active",
onSelect
}, ref) => {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(tab_panel_TabPanel, "tab-panel");
const prependInstanceId = (0,external_wp_element_namespaceObject.useCallback)((tabName) => {
if (typeof tabName === "undefined") {
return;
}
return `${instanceId}-${tabName}`;
}, [instanceId]);
const tabStore = useTabStore({
setSelectedId: (newTabValue) => {
if (typeof newTabValue === "undefined" || newTabValue === null) {
return;
}
const newTab = tabs.find((t) => prependInstanceId(t.name) === newTabValue);
if (newTab?.disabled || newTab === selectedTab) {
return;
}
const simplifiedTabName = extractTabName(newTabValue);
if (typeof simplifiedTabName === "undefined") {
return;
}
onSelect?.(simplifiedTabName);
},
orientation,
selectOnMove,
defaultSelectedId: prependInstanceId(initialTabName),
rtl: (0,external_wp_i18n_namespaceObject.isRTL)()
});
const selectedTabName = extractTabName(useStoreState(tabStore, "selectedId"));
const setTabStoreSelectedId = (0,external_wp_element_namespaceObject.useCallback)((tabName) => {
tabStore.setState("selectedId", prependInstanceId(tabName));
}, [prependInstanceId, tabStore]);
const selectedTab = tabs.find(({
name
}) => name === selectedTabName);
const previousSelectedTabName = (0,external_wp_compose_namespaceObject.usePrevious)(selectedTabName);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (previousSelectedTabName !== selectedTabName && selectedTabName === initialTabName && !!selectedTabName) {
onSelect?.(selectedTabName);
}
}, [selectedTabName, initialTabName, onSelect, previousSelectedTabName]);
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (selectedTab) {
return;
}
const initialTab = tabs.find((tab) => tab.name === initialTabName);
if (initialTabName && !initialTab) {
return;
}
if (initialTab && !initialTab.disabled) {
setTabStoreSelectedId(initialTab.name);
} else {
const firstEnabledTab = tabs.find((tab) => !tab.disabled);
if (firstEnabledTab) {
setTabStoreSelectedId(firstEnabledTab.name);
}
}
}, [tabs, selectedTab, initialTabName, instanceId, setTabStoreSelectedId]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!selectedTab?.disabled) {
return;
}
const firstEnabledTab = tabs.find((tab) => !tab.disabled);
if (firstEnabledTab) {
setTabStoreSelectedId(firstEnabledTab.name);
}
}, [tabs, selectedTab?.disabled, setTabStoreSelectedId, instanceId]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className,
ref,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TabList, {
store: tabStore,
className: "components-tab-panel__tabs",
children: tabs.map((tab) => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Tab, {
id: prependInstanceId(tab.name),
className: dist_clsx("components-tab-panel__tabs-item", tab.className, {
[activeClass]: tab.name === selectedTabName
}),
disabled: tab.disabled,
"aria-controls": `${prependInstanceId(tab.name)}-view`,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
__next40pxDefaultSize: true,
icon: tab.icon,
label: tab.icon && tab.title,
showTooltip: !!tab.icon
}),
children: !tab.icon && tab.title
}, tab.name);
})
}), selectedTab && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TabPanel, {
id: `${prependInstanceId(selectedTab.name)}-view`,
store: tabStore,
tabId: prependInstanceId(selectedTab.name),
className: "components-tab-panel__tab-content",
children: children(selectedTab)
})]
});
};
const tab_panel_TabPanel = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTabPanel);
var tab_panel_default = tab_panel_TabPanel;
;// ./node_modules/@wordpress/components/build-module/text-control/index.js
function UnforwardedTextControl(props, ref) {
const {
__nextHasNoMarginBottom,
__next40pxDefaultSize = false,
label,
hideLabelFromVision,
value,
help,
id: idProp,
className,
onChange,
type = "text",
...additionalProps
} = props;
const id = (0,external_wp_compose_namespaceObject.useInstanceId)(TextControl, "inspector-text-control", idProp);
const onChangeValue = (event) => onChange(event.target.value);
maybeWarnDeprecated36pxSize({
componentName: "TextControl",
size: void 0,
__next40pxDefaultSize
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
__nextHasNoMarginBottom,
__associatedWPComponentName: "TextControl",
label,
hideLabelFromVision,
id,
help,
className,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
className: dist_clsx("components-text-control__input", {
"is-next-40px-default-size": __next40pxDefaultSize
}),
type,
id,
value,
onChange: onChangeValue,
"aria-describedby": !!help ? id + "__help" : void 0,
ref,
...additionalProps
})
});
}
const TextControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTextControl);
var text_control_default = TextControl;
;// ./node_modules/@wordpress/components/build-module/utils/breakpoint-values.js
var breakpoint_values_default = {
huge: "1440px",
wide: "1280px",
"x-large": "1080px",
large: "960px",
// admin sidebar auto folds
medium: "782px",
// Adminbar goes big.
small: "600px",
mobile: "480px",
"zoomed-in": "280px"
};
;// ./node_modules/@wordpress/components/build-module/utils/breakpoint.js
const breakpoint = (point) => `@media (min-width: ${breakpoint_values_default[point]})`;
;// ./node_modules/@wordpress/components/build-module/textarea-control/styles/textarea-control-styles.js
const inputStyleNeutral = /* @__PURE__ */ emotion_react_browser_esm_css("box-shadow:0 0 0 transparent;border-radius:", config_values_default.radiusSmall, ";border:", config_values_default.borderWidth, " solid ", COLORS.ui.border, ";@media not ( prefers-reduced-motion ){transition:box-shadow 0.1s linear;}" + ( true ? "" : 0), true ? "" : 0);
const inputStyleFocus = /* @__PURE__ */ emotion_react_browser_esm_css("border-color:", COLORS.theme.accent, ";box-shadow:0 0 0 calc( ", config_values_default.borderWidthFocus, " - ", config_values_default.borderWidth, " ) ", COLORS.theme.accent, ";outline:2px solid transparent;" + ( true ? "" : 0), true ? "" : 0);
const StyledTextarea = /* @__PURE__ */ emotion_styled_base_browser_esm("textarea", true ? {
target: "e1w5nnrk0"
} : 0)("width:100%;display:block;font-family:", font("default.fontFamily"), ";line-height:20px;background:", COLORS.theme.background, ";color:", COLORS.theme.foreground, ";resize:vertical;padding:9px 11px;", inputStyleNeutral, ";font-size:", font("mobileTextMinFontSize"), ";", breakpoint("small"), "{font-size:", font("default.fontSize"), ";}&:focus{", inputStyleFocus, ";}&::-webkit-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&::-moz-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}&:-ms-input-placeholder{color:", COLORS.ui.darkGrayPlaceholder, ";}.is-dark-theme &{&::-webkit-input-placeholder{color:", COLORS.ui.lightGrayPlaceholder, ";}&::-moz-placeholder{color:", COLORS.ui.lightGrayPlaceholder, ";}&:-ms-input-placeholder{color:", COLORS.ui.lightGrayPlaceholder, ";}}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/textarea-control/index.js
function UnforwardedTextareaControl(props, ref) {
const {
__nextHasNoMarginBottom,
label,
hideLabelFromVision,
value,
help,
onChange,
rows = 4,
className,
...additionalProps
} = props;
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(TextareaControl);
const id = `inspector-textarea-control-${instanceId}`;
const onChangeValue = (event) => onChange(event.target.value);
const classes = dist_clsx("components-textarea-control", className);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
__nextHasNoMarginBottom,
__associatedWPComponentName: "TextareaControl",
label,
hideLabelFromVision,
id,
help,
className: classes,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledTextarea, {
className: "components-textarea-control__input",
id,
rows,
onChange: onChangeValue,
"aria-describedby": !!help ? id + "__help" : void 0,
value,
ref,
...additionalProps
})
});
}
const TextareaControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTextareaControl);
var textarea_control_default = TextareaControl;
;// ./node_modules/@wordpress/components/build-module/text-highlight/index.js
const TextHighlight = (props) => {
const {
text = "",
highlight = ""
} = props;
const trimmedHighlightText = highlight.trim();
if (!trimmedHighlightText) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: text
});
}
const regex = new RegExp(`(${escapeRegExp(trimmedHighlightText)})`, "gi");
return (0,external_wp_element_namespaceObject.createInterpolateElement)(text.replace(regex, "<mark>$&</mark>"), {
mark: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("mark", {})
});
};
var text_highlight_default = TextHighlight;
;// ./node_modules/@wordpress/icons/build-module/library/tip.js
var tip_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M12 15.8c-3.7 0-6.8-3-6.8-6.8s3-6.8 6.8-6.8c3.7 0 6.8 3 6.8 6.8s-3.1 6.8-6.8 6.8zm0-12C9.1 3.8 6.8 6.1 6.8 9s2.4 5.2 5.2 5.2c2.9 0 5.2-2.4 5.2-5.2S14.9 3.8 12 3.8zM8 17.5h8V19H8zM10 20.5h4V22h-4z" }) });
;// ./node_modules/@wordpress/components/build-module/tip/index.js
function Tip(props) {
const {
children
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-tip",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: tip_default
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("p", {
children
})]
});
}
var tip_tip_default = Tip;
;// ./node_modules/@wordpress/components/build-module/toggle-control/index.js
function UnforwardedToggleControl({
__nextHasNoMarginBottom,
label,
checked,
help,
className,
onChange,
disabled
}, ref) {
function onChangeToggle(event) {
onChange(event.target.checked);
}
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(ToggleControl);
const id = `inspector-toggle-control-${instanceId}`;
const cx = useCx();
const classes = cx("components-toggle-control", className, !__nextHasNoMarginBottom && /* @__PURE__ */ emotion_react_browser_esm_css({
marginBottom: space(3)
}, true ? "" : 0, true ? "" : 0));
if (!__nextHasNoMarginBottom) {
external_wp_deprecated_default()("Bottom margin styles for wp.components.ToggleControl", {
since: "6.7",
version: "7.0",
hint: "Set the `__nextHasNoMarginBottom` prop to true to start opting into the new styles, which will become the default in a future version."
});
}
let describedBy, helpLabel;
if (help) {
if (typeof help === "function") {
if (checked !== void 0) {
helpLabel = help(checked);
}
} else {
helpLabel = help;
}
if (helpLabel) {
describedBy = id + "__help";
}
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(base_control_default, {
id,
help: helpLabel && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-toggle-control__help",
children: helpLabel
}),
className: classes,
__nextHasNoMarginBottom: true,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
justify: "flex-start",
spacing: 2,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(form_toggle_default, {
id,
checked,
onChange: onChangeToggle,
"aria-describedby": describedBy,
disabled,
ref
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(flex_block_component_component_default, {
as: "label",
htmlFor: id,
className: dist_clsx("components-toggle-control__label", {
"is-disabled": disabled
}),
children: label
})]
})
});
}
const ToggleControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToggleControl);
var toggle_control_default = ToggleControl;
;// ./node_modules/@ariakit/react-core/esm/__chunks/A3WPL2ZJ.js
"use client";
// src/toolbar/toolbar-context.tsx
var A3WPL2ZJ_ctx = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var useToolbarContext = A3WPL2ZJ_ctx.useContext;
var useToolbarScopedContext = A3WPL2ZJ_ctx.useScopedContext;
var useToolbarProviderContext = A3WPL2ZJ_ctx.useProviderContext;
var ToolbarContextProvider = A3WPL2ZJ_ctx.ContextProvider;
var ToolbarScopedContextProvider = A3WPL2ZJ_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/__chunks/BOLVLGVE.js
"use client";
// src/toolbar/toolbar-item.tsx
var BOLVLGVE_TagName = "button";
var useToolbarItem = createHook(
function useToolbarItem2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useToolbarContext();
store = store || context;
props = useCompositeItem(_3YLGPPWQ_spreadValues({ store }, props));
return props;
}
);
var ToolbarItem = memo2(
forwardRef2(function ToolbarItem2(props) {
const htmlProps = useToolbarItem(props);
return LMDWO4NN_createElement(BOLVLGVE_TagName, htmlProps);
})
);
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-context/index.js
const ToolbarContext = (0,external_wp_element_namespaceObject.createContext)(void 0);
ToolbarContext.displayName = "ToolbarContext";
var toolbar_context_default = ToolbarContext;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-item/index.js
function UnforwardedToolbarItem({
children,
as: Component,
...props
}, ref) {
const accessibleToolbarStore = (0,external_wp_element_namespaceObject.useContext)(toolbar_context_default);
const isRenderProp = typeof children === "function";
if (!isRenderProp && !Component) {
true ? external_wp_warning_default()("`ToolbarItem` is a generic headless component. You must pass either a `children` prop as a function or an `as` prop as a component. See https://developer.wordpress.org/block-editor/components/toolbar-item/") : 0;
return null;
}
const allProps = {
...props,
ref,
"data-toolbar-item": true
};
if (!accessibleToolbarStore) {
if (Component) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
...allProps,
children
});
}
if (!isRenderProp) {
return null;
}
return children(allProps);
}
const render = isRenderProp ? children : Component && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
children
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ToolbarItem, {
accessibleWhenDisabled: true,
...allProps,
store: accessibleToolbarStore,
render
});
}
const toolbar_item_ToolbarItem = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToolbarItem);
var toolbar_item_default = toolbar_item_ToolbarItem;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-button/toolbar-button-container.js
const ToolbarButtonContainer = ({
children,
className
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className,
children
});
var toolbar_button_container_default = ToolbarButtonContainer;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-button/index.js
function toolbar_button_useDeprecatedProps({
isDisabled,
...otherProps
}) {
return {
disabled: isDisabled,
...otherProps
};
}
function UnforwardedToolbarButton(props, ref) {
const {
children,
className,
containerClassName,
extraProps,
isActive,
title,
...restProps
} = toolbar_button_useDeprecatedProps(props);
const accessibleToolbarState = (0,external_wp_element_namespaceObject.useContext)(toolbar_context_default);
if (!accessibleToolbarState) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_button_container_default, {
className: containerClassName,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
ref,
icon: restProps.icon,
size: "compact",
label: title,
shortcut: restProps.shortcut,
"data-subscript": restProps.subscript,
onClick: (event) => {
event.stopPropagation();
if (restProps.onClick) {
restProps.onClick(event);
}
},
className: dist_clsx("components-toolbar__control", className),
isPressed: isActive,
accessibleWhenDisabled: true,
"data-toolbar-item": true,
...extraProps,
...restProps,
children
})
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_item_default, {
className: dist_clsx("components-toolbar-button", className),
...extraProps,
...restProps,
ref,
children: (toolbarItemProps) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(button_default, {
size: "compact",
label: title,
isPressed: isActive,
...toolbarItemProps,
children
})
});
}
const ToolbarButton = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToolbarButton);
var toolbar_button_default = ToolbarButton;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-group/toolbar-group-container.js
const ToolbarGroupContainer = ({
className,
children,
...props
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
className,
...props,
children
});
var toolbar_group_container_default = ToolbarGroupContainer;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-group/toolbar-group-collapsed.js
function ToolbarGroupCollapsed({
controls = [],
toggleProps,
...props
}) {
const accessibleToolbarState = (0,external_wp_element_namespaceObject.useContext)(toolbar_context_default);
const renderDropdownMenu = (internalToggleProps) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_menu_default, {
controls,
toggleProps: {
...internalToggleProps,
"data-toolbar-item": true
},
...props
});
if (accessibleToolbarState) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_item_default, {
...toggleProps,
children: renderDropdownMenu
});
}
return renderDropdownMenu(toggleProps);
}
var toolbar_group_collapsed_default = ToolbarGroupCollapsed;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-group/index.js
function isNestedArray(arr) {
return Array.isArray(arr) && Array.isArray(arr[0]);
}
function ToolbarGroup({
controls = [],
children,
className,
isCollapsed,
title,
...props
}) {
const accessibleToolbarState = (0,external_wp_element_namespaceObject.useContext)(toolbar_context_default);
if ((!controls || !controls.length) && !children) {
return null;
}
const finalClassName = dist_clsx(
// Unfortunately, there's legacy code referencing to `.components-toolbar`
// So we can't get rid of it
accessibleToolbarState ? "components-toolbar-group" : "components-toolbar",
className
);
let controlSets;
if (isNestedArray(controls)) {
controlSets = controls;
} else {
controlSets = [controls];
}
if (isCollapsed) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_group_collapsed_default, {
label: title,
controls: controlSets,
className: finalClassName,
children,
...props
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(toolbar_group_container_default, {
className: finalClassName,
...props,
children: [controlSets?.flatMap((controlSet, indexOfSet) => controlSet.map((control, indexOfControl) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_button_default, {
containerClassName: indexOfSet > 0 && indexOfControl === 0 ? "has-left-divider" : void 0,
...control
}, [indexOfSet, indexOfControl].join()))), children]
});
}
var toolbar_group_default = ToolbarGroup;
;// ./node_modules/@ariakit/core/esm/toolbar/toolbar-store.js
"use client";
// src/toolbar/toolbar-store.ts
function createToolbarStore(props = {}) {
var _a;
const syncState = (_a = props.store) == null ? void 0 : _a.getState();
return createCompositeStore(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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/7M5THDKH.js
"use client";
// src/toolbar/toolbar-store.ts
function useToolbarStoreProps(store, update, props) {
return useCompositeStoreProps(store, update, props);
}
function useToolbarStore(props = {}) {
const [store, update] = YV4JVR4I_useStore(createToolbarStore, props);
return useToolbarStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/toolbar/toolbar.js
"use client";
// src/toolbar/toolbar.tsx
var toolbar_TagName = "div";
var useToolbar = createHook(
function useToolbar2(_a) {
var _b = _a, {
store: storeProp,
orientation: orientationProp,
virtualFocus,
focusLoop,
rtl
} = _b, props = __objRest(_b, [
"store",
"orientation",
"virtualFocus",
"focusLoop",
"rtl"
]);
const context = useToolbarProviderContext();
storeProp = storeProp || context;
const store = useToolbarStore({
store: storeProp,
orientation: orientationProp,
virtualFocus,
focusLoop,
rtl
});
const orientation = store.useState(
(state) => state.orientation === "both" ? void 0 : state.orientation
);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ToolbarScopedContextProvider, { value: store, children: element }),
[store]
);
props = _3YLGPPWQ_spreadValues({
role: "toolbar",
"aria-orientation": orientation
}, props);
props = useComposite(_3YLGPPWQ_spreadValues({ store }, props));
return props;
}
);
var Toolbar = forwardRef2(function Toolbar2(props) {
const htmlProps = useToolbar(props);
return LMDWO4NN_createElement(toolbar_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar/toolbar-container.js
function UnforwardedToolbarContainer({
label,
...props
}, ref) {
const toolbarStore = useToolbarStore({
focusLoop: true,
rtl: (0,external_wp_i18n_namespaceObject.isRTL)()
});
return (
// This will provide state for `ToolbarButton`'s
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_context_default.Provider, {
value: toolbarStore,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Toolbar, {
ref,
"aria-label": label,
store: toolbarStore,
...props
})
})
);
}
const ToolbarContainer = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToolbarContainer);
var toolbar_container_default = ToolbarContainer;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar/index.js
function UnforwardedToolbar({
className,
label,
variant,
...props
}, ref) {
const isVariantDefined = variant !== void 0;
const contextSystemValue = (0,external_wp_element_namespaceObject.useMemo)(() => {
if (isVariantDefined) {
return {};
}
return {
DropdownMenu: {
variant: "toolbar"
},
Dropdown: {
variant: "toolbar"
},
Menu: {
variant: "toolbar"
}
};
}, [isVariantDefined]);
if (!label) {
external_wp_deprecated_default()("Using Toolbar without label prop", {
since: "5.6",
alternative: "ToolbarGroup component",
link: "https://developer.wordpress.org/block-editor/components/toolbar/"
});
const {
title: _title,
...restProps
} = props;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_group_default, {
isCollapsed: false,
...restProps,
className
});
}
const finalClassName = dist_clsx("components-accessible-toolbar", className, variant && `is-${variant}`);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ContextSystemProvider, {
value: contextSystemValue,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_container_default, {
className: finalClassName,
label,
ref,
...props
})
});
}
const toolbar_Toolbar = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToolbar);
var toolbar_default = toolbar_Toolbar;
;// ./node_modules/@wordpress/components/build-module/toolbar/toolbar-dropdown-menu/index.js
function UnforwardedToolbarDropdownMenu(props, ref) {
const accessibleToolbarState = (0,external_wp_element_namespaceObject.useContext)(toolbar_context_default);
if (!accessibleToolbarState) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_menu_default, {
...props
});
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toolbar_item_default, {
ref,
...props.toggleProps,
children: (toolbarItemProps) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_menu_default, {
...props,
popoverProps: {
...props.popoverProps
},
toggleProps: toolbarItemProps
})
});
}
const ToolbarDropdownMenu = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedToolbarDropdownMenu);
var toolbar_dropdown_menu_default = ToolbarDropdownMenu;
;// ./node_modules/@wordpress/components/build-module/tools-panel/styles.js
function tools_panel_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const toolsPanelGrid = {
columns: (columns) => /* @__PURE__ */ emotion_react_browser_esm_css("grid-template-columns:", `repeat( ${columns}, minmax(0, 1fr) )`, ";" + ( true ? "" : 0), true ? "" : 0),
spacing: /* @__PURE__ */ emotion_react_browser_esm_css("column-gap:", space(4), ";row-gap:", space(4), ";" + ( true ? "" : 0), true ? "" : 0),
item: {
fullWidth: true ? {
name: "18iuzk9",
styles: "grid-column:1/-1"
} : 0
}
};
const ToolsPanel = (columns) => /* @__PURE__ */ emotion_react_browser_esm_css(toolsPanelGrid.columns(columns), " ", toolsPanelGrid.spacing, " border-top:", config_values_default.borderWidth, " solid ", COLORS.gray[300], ";margin-top:-1px;padding:", space(4), ";" + ( true ? "" : 0), true ? "" : 0);
const ToolsPanelWithInnerWrapper = (columns) => {
return /* @__PURE__ */ emotion_react_browser_esm_css(">div:not( :first-of-type ){display:grid;", toolsPanelGrid.columns(columns), " ", toolsPanelGrid.spacing, " ", toolsPanelGrid.item.fullWidth, ";}" + ( true ? "" : 0), true ? "" : 0);
};
const ToolsPanelHiddenInnerWrapper = true ? {
name: "huufmu",
styles: ">div:not( :first-of-type ){display:none;}"
} : 0;
const ToolsPanelHeader = /* @__PURE__ */ emotion_react_browser_esm_css(toolsPanelGrid.item.fullWidth, " gap:", space(2), ";.components-dropdown-menu{margin:", space(-1), " 0;line-height:0;}&&&& .components-dropdown-menu__toggle{padding:0;min-width:", space(6), ";}" + ( true ? "" : 0), true ? "" : 0);
const ToolsPanelHeading = true ? {
name: "1pmxm02",
styles: "font-size:inherit;font-weight:500;line-height:normal;&&{margin:0;}"
} : 0;
const ToolsPanelItem = /* @__PURE__ */ emotion_react_browser_esm_css(toolsPanelGrid.item.fullWidth, "&>div,&>fieldset{padding-bottom:0;margin-bottom:0;max-width:100%;}&& ", Wrapper, "{margin-bottom:0;", StyledField, ":last-child{margin-bottom:0;}}", StyledHelp, "{margin-bottom:0;}&& ", LabelWrapper, "{label{line-height:1.4em;}}" + ( true ? "" : 0), true ? "" : 0);
const ToolsPanelItemPlaceholder = true ? {
name: "eivff4",
styles: "display:none"
} : 0;
const styles_DropdownMenu = true ? {
name: "16gsvie",
styles: "min-width:200px"
} : 0;
const ResetLabel = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "ews648u0"
} : 0)("color:", COLORS.theme.accentDarker10, ";font-size:11px;font-weight:500;line-height:1.4;", rtl({
marginLeft: space(3)
}), " text-transform:uppercase;" + ( true ? "" : 0));
const DefaultControlsItem = /* @__PURE__ */ emotion_react_browser_esm_css("color:", COLORS.gray[900], ";&&[aria-disabled='true']{color:", COLORS.gray[700], ";opacity:1;&:hover{color:", COLORS.gray[700], ";}", ResetLabel, "{opacity:0.3;}}" + ( true ? "" : 0), true ? "" : 0);
;// ./node_modules/@wordpress/components/build-module/tools-panel/context.js
const tools_panel_context_noop = () => void 0;
const ToolsPanelContext = (0,external_wp_element_namespaceObject.createContext)({
menuItems: {
default: {},
optional: {}
},
hasMenuItems: false,
isResetting: false,
shouldRenderPlaceholderItems: false,
registerPanelItem: tools_panel_context_noop,
deregisterPanelItem: tools_panel_context_noop,
flagItemCustomization: tools_panel_context_noop,
registerResetAllFilter: tools_panel_context_noop,
deregisterResetAllFilter: tools_panel_context_noop,
areAllOptionalControlsHidden: true
});
ToolsPanelContext.displayName = "ToolsPanelContext";
const useToolsPanelContext = () => (0,external_wp_element_namespaceObject.useContext)(ToolsPanelContext);
;// ./node_modules/@wordpress/components/build-module/tools-panel/tools-panel-header/hook.js
function useToolsPanelHeader(props) {
const {
className,
headingLevel = 2,
...otherProps
} = useContextSystem(props, "ToolsPanelHeader");
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(ToolsPanelHeader, className);
}, [className, cx]);
const dropdownMenuClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(styles_DropdownMenu);
}, [cx]);
const headingClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(ToolsPanelHeading);
}, [cx]);
const defaultControlsItemClassName = (0,external_wp_element_namespaceObject.useMemo)(() => {
return cx(DefaultControlsItem);
}, [cx]);
const {
menuItems,
hasMenuItems,
areAllOptionalControlsHidden
} = useToolsPanelContext();
return {
...otherProps,
areAllOptionalControlsHidden,
defaultControlsItemClassName,
dropdownMenuClassName,
hasMenuItems,
headingClassName,
headingLevel,
menuItems,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/tools-panel/tools-panel-header/component.js
const DefaultControlsGroup = ({
itemClassName,
items,
toggleItem
}) => {
if (!items.length) {
return null;
}
const resetSuffix = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ResetLabel, {
"aria-hidden": true,
children: (0,external_wp_i18n_namespaceObject.__)("Reset")
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: items.map(([label, hasValue]) => {
if (hasValue) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_item_default, {
className: itemClassName,
role: "menuitem",
label: (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the control being reset e.g. "Padding".
(0,external_wp_i18n_namespaceObject.__)("Reset %s"),
label
),
onClick: () => {
toggleItem(label);
(0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the control being reset e.g. "Padding".
(0,external_wp_i18n_namespaceObject.__)("%s reset to default"),
label
), "assertive");
},
suffix: resetSuffix,
children: label
}, label);
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_item_default, {
icon: check_default,
className: itemClassName,
role: "menuitemcheckbox",
isSelected: true,
"aria-disabled": true,
children: label
}, label);
})
});
};
const OptionalControlsGroup = ({
items,
toggleItem
}) => {
if (!items.length) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: items.map(([label, isSelected]) => {
const itemLabel = isSelected ? (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the control being hidden and reset e.g. "Padding".
(0,external_wp_i18n_namespaceObject.__)("Hide and reset %s"),
label
) : (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the control to display e.g. "Padding".
(0,external_wp_i18n_namespaceObject._x)("Show %s", "input control"),
label
);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_item_default, {
icon: isSelected ? check_default : null,
isSelected,
label: itemLabel,
onClick: () => {
if (isSelected) {
(0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the control being reset e.g. "Padding".
(0,external_wp_i18n_namespaceObject.__)("%s hidden and reset to default"),
label
), "assertive");
} else {
(0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the control being reset e.g. "Padding".
(0,external_wp_i18n_namespaceObject.__)("%s is now visible"),
label
), "assertive");
}
toggleItem(label);
},
role: "menuitemcheckbox",
children: label
}, label);
})
});
};
const component_ToolsPanelHeader = (props, forwardedRef) => {
const {
areAllOptionalControlsHidden,
defaultControlsItemClassName,
dropdownMenuClassName,
hasMenuItems,
headingClassName,
headingLevel = 2,
label: labelText,
menuItems,
resetAll,
toggleItem,
dropdownMenuProps,
...headerProps
} = useToolsPanelHeader(props);
if (!labelText) {
return null;
}
const defaultItems = Object.entries(menuItems?.default || {});
const optionalItems = Object.entries(menuItems?.optional || {});
const dropDownMenuIcon = areAllOptionalControlsHidden ? plus_default : more_vertical_default;
const dropDownMenuLabelText = (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s: The name of the tool e.g. "Color" or "Typography".
(0,external_wp_i18n_namespaceObject._x)("%s options", "Button label to reveal tool panel options"),
labelText
);
const dropdownMenuDescriptionText = areAllOptionalControlsHidden ? (0,external_wp_i18n_namespaceObject.__)("All options are currently hidden") : void 0;
const canResetAll = [...defaultItems, ...optionalItems].some(([, isSelected]) => isSelected);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(h_stack_component_component_default, {
...headerProps,
ref: forwardedRef,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(heading_component_component_default, {
level: headingLevel,
className: headingClassName,
children: labelText
}), hasMenuItems && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(dropdown_menu_default, {
...dropdownMenuProps,
icon: dropDownMenuIcon,
label: dropDownMenuLabelText,
menuProps: {
className: dropdownMenuClassName
},
toggleProps: {
size: "small",
description: dropdownMenuDescriptionText
},
children: () => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(menu_group_default, {
label: labelText,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DefaultControlsGroup, {
items: defaultItems,
toggleItem,
itemClassName: defaultControlsItemClassName
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OptionalControlsGroup, {
items: optionalItems,
toggleItem
})]
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_group_default, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(menu_item_default, {
"aria-disabled": !canResetAll,
variant: "tertiary",
onClick: () => {
if (canResetAll) {
resetAll();
(0,external_wp_a11y_namespaceObject.speak)((0,external_wp_i18n_namespaceObject.__)("All options reset"), "assertive");
}
},
children: (0,external_wp_i18n_namespaceObject.__)("Reset all")
})
})]
})
})]
});
};
const ConnectedToolsPanelHeader = contextConnect(component_ToolsPanelHeader, "ToolsPanelHeader");
var tools_panel_header_component_component_default = ConnectedToolsPanelHeader;
;// ./node_modules/@wordpress/components/build-module/tools-panel/tools-panel/hook.js
const DEFAULT_COLUMNS = 2;
function emptyMenuItems() {
return {
default: {},
optional: {}
};
}
function emptyState() {
return {
panelItems: [],
menuItemOrder: [],
menuItems: emptyMenuItems()
};
}
const generateMenuItems = ({
panelItems,
shouldReset,
currentMenuItems,
menuItemOrder
}) => {
const newMenuItems = emptyMenuItems();
const menuItems = emptyMenuItems();
panelItems.forEach(({
hasValue,
isShownByDefault,
label
}) => {
const group = isShownByDefault ? "default" : "optional";
const existingItemValue = currentMenuItems?.[group]?.[label];
const value = existingItemValue ? existingItemValue : hasValue();
newMenuItems[group][label] = shouldReset ? false : value;
});
menuItemOrder.forEach((key) => {
if (newMenuItems.default.hasOwnProperty(key)) {
menuItems.default[key] = newMenuItems.default[key];
}
if (newMenuItems.optional.hasOwnProperty(key)) {
menuItems.optional[key] = newMenuItems.optional[key];
}
});
Object.keys(newMenuItems.default).forEach((key) => {
if (!menuItems.default.hasOwnProperty(key)) {
menuItems.default[key] = newMenuItems.default[key];
}
});
Object.keys(newMenuItems.optional).forEach((key) => {
if (!menuItems.optional.hasOwnProperty(key)) {
menuItems.optional[key] = newMenuItems.optional[key];
}
});
return menuItems;
};
function panelItemsReducer(panelItems, action) {
switch (action.type) {
case "REGISTER_PANEL": {
const newItems = [...panelItems];
const existingIndex = newItems.findIndex((oldItem) => oldItem.label === action.item.label);
if (existingIndex !== -1) {
newItems.splice(existingIndex, 1);
}
newItems.push(action.item);
return newItems;
}
case "UNREGISTER_PANEL": {
const index = panelItems.findIndex((item) => item.label === action.label);
if (index !== -1) {
const newItems = [...panelItems];
newItems.splice(index, 1);
return newItems;
}
return panelItems;
}
default:
return panelItems;
}
}
function menuItemOrderReducer(menuItemOrder, action) {
switch (action.type) {
case "REGISTER_PANEL": {
if (menuItemOrder.includes(action.item.label)) {
return menuItemOrder;
}
return [...menuItemOrder, action.item.label];
}
default:
return menuItemOrder;
}
}
function menuItemsReducer(state, action) {
switch (action.type) {
case "REGISTER_PANEL":
case "UNREGISTER_PANEL":
return generateMenuItems({
currentMenuItems: state.menuItems,
panelItems: state.panelItems,
menuItemOrder: state.menuItemOrder,
shouldReset: false
});
case "RESET_ALL":
return generateMenuItems({
panelItems: state.panelItems,
menuItemOrder: state.menuItemOrder,
shouldReset: true
});
case "UPDATE_VALUE": {
const oldValue = state.menuItems[action.group][action.label];
if (action.value === oldValue) {
return state.menuItems;
}
return {
...state.menuItems,
[action.group]: {
...state.menuItems[action.group],
[action.label]: action.value
}
};
}
case "TOGGLE_VALUE": {
const currentItem = state.panelItems.find((item) => item.label === action.label);
if (!currentItem) {
return state.menuItems;
}
const menuGroup = currentItem.isShownByDefault ? "default" : "optional";
const newMenuItems = {
...state.menuItems,
[menuGroup]: {
...state.menuItems[menuGroup],
[action.label]: !state.menuItems[menuGroup][action.label]
}
};
return newMenuItems;
}
default:
return state.menuItems;
}
}
function panelReducer(state, action) {
const panelItems = panelItemsReducer(state.panelItems, action);
const menuItemOrder = menuItemOrderReducer(state.menuItemOrder, action);
const menuItems = menuItemsReducer({
panelItems,
menuItemOrder,
menuItems: state.menuItems
}, action);
return {
panelItems,
menuItemOrder,
menuItems
};
}
function resetAllFiltersReducer(filters, action) {
switch (action.type) {
case "REGISTER":
return [...filters, action.filter];
case "UNREGISTER":
return filters.filter((f) => f !== action.filter);
default:
return filters;
}
}
const isMenuItemTypeEmpty = (obj) => Object.keys(obj).length === 0;
function useToolsPanel(props) {
const {
className,
headingLevel = 2,
resetAll,
panelId,
hasInnerWrapper = false,
shouldRenderPlaceholderItems = false,
__experimentalFirstVisibleItemClass,
__experimentalLastVisibleItemClass,
...otherProps
} = useContextSystem(props, "ToolsPanel");
const isResettingRef = (0,external_wp_element_namespaceObject.useRef)(false);
const wasResetting = isResettingRef.current;
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (wasResetting) {
isResettingRef.current = false;
}
}, [wasResetting]);
const [{
panelItems,
menuItems
}, panelDispatch] = (0,external_wp_element_namespaceObject.useReducer)(panelReducer, void 0, emptyState);
const [resetAllFilters, dispatchResetAllFilters] = (0,external_wp_element_namespaceObject.useReducer)(resetAllFiltersReducer, []);
const registerPanelItem = (0,external_wp_element_namespaceObject.useCallback)((item) => {
panelDispatch({
type: "REGISTER_PANEL",
item
});
}, []);
const deregisterPanelItem = (0,external_wp_element_namespaceObject.useCallback)((label) => {
panelDispatch({
type: "UNREGISTER_PANEL",
label
});
}, []);
const registerResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)((filter) => {
dispatchResetAllFilters({
type: "REGISTER",
filter
});
}, []);
const deregisterResetAllFilter = (0,external_wp_element_namespaceObject.useCallback)((filter) => {
dispatchResetAllFilters({
type: "UNREGISTER",
filter
});
}, []);
const flagItemCustomization = (0,external_wp_element_namespaceObject.useCallback)((value, label, group = "default") => {
panelDispatch({
type: "UPDATE_VALUE",
group,
label,
value
});
}, []);
const areAllOptionalControlsHidden = (0,external_wp_element_namespaceObject.useMemo)(() => {
return isMenuItemTypeEmpty(menuItems.default) && !isMenuItemTypeEmpty(menuItems.optional) && Object.values(menuItems.optional).every((isSelected) => !isSelected);
}, [menuItems]);
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
const wrapperStyle = hasInnerWrapper && ToolsPanelWithInnerWrapper(DEFAULT_COLUMNS);
const emptyStyle = areAllOptionalControlsHidden && ToolsPanelHiddenInnerWrapper;
return cx(ToolsPanel(DEFAULT_COLUMNS), wrapperStyle, emptyStyle, className);
}, [areAllOptionalControlsHidden, className, cx, hasInnerWrapper]);
const toggleItem = (0,external_wp_element_namespaceObject.useCallback)((label) => {
panelDispatch({
type: "TOGGLE_VALUE",
label
});
}, []);
const resetAllItems = (0,external_wp_element_namespaceObject.useCallback)(() => {
if (typeof resetAll === "function") {
isResettingRef.current = true;
resetAll(resetAllFilters);
}
panelDispatch({
type: "RESET_ALL"
});
}, [resetAllFilters, resetAll]);
const getFirstVisibleItemLabel = (items) => {
const optionalItems = menuItems.optional || {};
const firstItem = items.find((item) => item.isShownByDefault || optionalItems[item.label]);
return firstItem?.label;
};
const firstDisplayedItem = getFirstVisibleItemLabel(panelItems);
const lastDisplayedItem = getFirstVisibleItemLabel([...panelItems].reverse());
const hasMenuItems = panelItems.length > 0;
const panelContext = (0,external_wp_element_namespaceObject.useMemo)(() => ({
areAllOptionalControlsHidden,
deregisterPanelItem,
deregisterResetAllFilter,
firstDisplayedItem,
flagItemCustomization,
hasMenuItems,
isResetting: isResettingRef.current,
lastDisplayedItem,
menuItems,
panelId,
registerPanelItem,
registerResetAllFilter,
shouldRenderPlaceholderItems,
__experimentalFirstVisibleItemClass,
__experimentalLastVisibleItemClass
}), [areAllOptionalControlsHidden, deregisterPanelItem, deregisterResetAllFilter, firstDisplayedItem, flagItemCustomization, lastDisplayedItem, menuItems, panelId, hasMenuItems, registerResetAllFilter, registerPanelItem, shouldRenderPlaceholderItems, __experimentalFirstVisibleItemClass, __experimentalLastVisibleItemClass]);
return {
...otherProps,
headingLevel,
panelContext,
resetAllItems,
toggleItem,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/tools-panel/tools-panel/component.js
const UnconnectedToolsPanel = (props, forwardedRef) => {
const {
children,
label,
panelContext,
resetAllItems,
toggleItem,
headingLevel,
dropdownMenuProps,
...toolsPanelProps
} = useToolsPanel(props);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(grid_component_component_default, {
...toolsPanelProps,
columns: 2,
ref: forwardedRef,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ToolsPanelContext.Provider, {
value: panelContext,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tools_panel_header_component_component_default, {
label,
resetAll: resetAllItems,
toggleItem,
headingLevel,
dropdownMenuProps
}), children]
})
});
};
const component_ToolsPanel = contextConnect(UnconnectedToolsPanel, "ToolsPanel");
var tools_panel_component_component_default = component_ToolsPanel;
;// ./node_modules/@wordpress/components/build-module/tools-panel/tools-panel-item/hook.js
const hook_noop = () => {
};
function useToolsPanelItem(props) {
const {
className,
hasValue,
isShownByDefault = false,
label,
panelId,
resetAllFilter = hook_noop,
onDeselect,
onSelect,
...otherProps
} = useContextSystem(props, "ToolsPanelItem");
const {
panelId: currentPanelId,
menuItems,
registerResetAllFilter,
deregisterResetAllFilter,
registerPanelItem,
deregisterPanelItem,
flagItemCustomization,
isResetting,
shouldRenderPlaceholderItems: shouldRenderPlaceholder,
firstDisplayedItem,
lastDisplayedItem,
__experimentalFirstVisibleItemClass,
__experimentalLastVisibleItemClass
} = useToolsPanelContext();
const hasValueCallback = (0,external_wp_element_namespaceObject.useCallback)(hasValue, [panelId]);
const resetAllFilterCallback = (0,external_wp_element_namespaceObject.useCallback)(resetAllFilter, [panelId]);
const previousPanelId = (0,external_wp_compose_namespaceObject.usePrevious)(currentPanelId);
const hasMatchingPanel = currentPanelId === panelId || currentPanelId === null;
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (hasMatchingPanel && previousPanelId !== null) {
registerPanelItem({
hasValue: hasValueCallback,
isShownByDefault,
label,
panelId
});
}
return () => {
if (previousPanelId === null && !!currentPanelId || currentPanelId === panelId) {
deregisterPanelItem(label);
}
};
}, [currentPanelId, hasMatchingPanel, isShownByDefault, label, hasValueCallback, panelId, previousPanelId, registerPanelItem, deregisterPanelItem]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (hasMatchingPanel) {
registerResetAllFilter(resetAllFilterCallback);
}
return () => {
if (hasMatchingPanel) {
deregisterResetAllFilter(resetAllFilterCallback);
}
};
}, [registerResetAllFilter, deregisterResetAllFilter, resetAllFilterCallback, hasMatchingPanel]);
const menuGroup = isShownByDefault ? "default" : "optional";
const isMenuItemChecked = menuItems?.[menuGroup]?.[label];
const wasMenuItemChecked = (0,external_wp_compose_namespaceObject.usePrevious)(isMenuItemChecked);
const isRegistered = menuItems?.[menuGroup]?.[label] !== void 0;
const isValueSet = hasValue();
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!isShownByDefault && !isValueSet) {
return;
}
flagItemCustomization(isValueSet, label, menuGroup);
}, [isValueSet, menuGroup, label, flagItemCustomization, isShownByDefault]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!isRegistered || isResetting || !hasMatchingPanel) {
return;
}
if (isMenuItemChecked && !isValueSet && !wasMenuItemChecked) {
onSelect?.();
}
if (!isMenuItemChecked && isValueSet && wasMenuItemChecked) {
onDeselect?.();
}
}, [hasMatchingPanel, isMenuItemChecked, isRegistered, isResetting, isValueSet, wasMenuItemChecked, onSelect, onDeselect]);
const isShown = isShownByDefault ? menuItems?.[menuGroup]?.[label] !== void 0 : isMenuItemChecked;
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => {
const shouldApplyPlaceholderStyles = shouldRenderPlaceholder && !isShown;
const firstItemStyle = firstDisplayedItem === label && __experimentalFirstVisibleItemClass;
const lastItemStyle = lastDisplayedItem === label && __experimentalLastVisibleItemClass;
return cx(ToolsPanelItem, shouldApplyPlaceholderStyles && ToolsPanelItemPlaceholder, !shouldApplyPlaceholderStyles && className, firstItemStyle, lastItemStyle);
}, [isShown, shouldRenderPlaceholder, className, cx, firstDisplayedItem, lastDisplayedItem, __experimentalFirstVisibleItemClass, __experimentalLastVisibleItemClass, label]);
return {
...otherProps,
isShown,
shouldRenderPlaceholder,
className: classes
};
}
;// ./node_modules/@wordpress/components/build-module/tools-panel/tools-panel-item/component.js
const UnconnectedToolsPanelItem = (props, forwardedRef) => {
const {
children,
isShown,
shouldRenderPlaceholder,
...toolsPanelItemProps
} = useToolsPanelItem(props);
if (!isShown) {
return shouldRenderPlaceholder ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...toolsPanelItemProps,
ref: forwardedRef
}) : null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(component_default, {
...toolsPanelItemProps,
ref: forwardedRef,
children
});
};
const component_ToolsPanelItem = contextConnect(UnconnectedToolsPanelItem, "ToolsPanelItem");
var tools_panel_item_component_component_default = component_ToolsPanelItem;
;// ./node_modules/@wordpress/components/build-module/tree-grid/roving-tab-index-context.js
const RovingTabIndexContext = (0,external_wp_element_namespaceObject.createContext)(void 0);
RovingTabIndexContext.displayName = "RovingTabIndexContext";
const useRovingTabIndexContext = () => (0,external_wp_element_namespaceObject.useContext)(RovingTabIndexContext);
const RovingTabIndexProvider = RovingTabIndexContext.Provider;
;// ./node_modules/@wordpress/components/build-module/tree-grid/roving-tab-index.js
function RovingTabIndex({
children
}) {
const [lastFocusedElement, setLastFocusedElement] = (0,external_wp_element_namespaceObject.useState)();
const providerValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
lastFocusedElement,
setLastFocusedElement
}), [lastFocusedElement]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RovingTabIndexProvider, {
value: providerValue,
children
});
}
;// ./node_modules/@wordpress/components/build-module/tree-grid/index.js
function getRowFocusables(rowElement) {
const focusablesInRow = external_wp_dom_namespaceObject.focus.focusable.find(rowElement, {
sequential: true
});
return focusablesInRow.filter((focusable) => {
return focusable.closest('[role="row"]') === rowElement;
});
}
function UnforwardedTreeGrid({
children,
onExpandRow = () => {
},
onCollapseRow = () => {
},
onFocusRow = () => {
},
applicationAriaLabel,
...props
}, ref) {
const onKeyDown = (0,external_wp_element_namespaceObject.useCallback)((event) => {
const {
keyCode,
metaKey,
ctrlKey,
altKey
} = event;
const hasModifierKeyPressed = metaKey || ctrlKey || altKey;
if (hasModifierKeyPressed || ![external_wp_keycodes_namespaceObject.UP, external_wp_keycodes_namespaceObject.DOWN, external_wp_keycodes_namespaceObject.LEFT, external_wp_keycodes_namespaceObject.RIGHT, external_wp_keycodes_namespaceObject.HOME, external_wp_keycodes_namespaceObject.END].includes(keyCode)) {
return;
}
event.stopPropagation();
const {
activeElement
} = document;
const {
currentTarget: treeGridElement
} = event;
if (!activeElement || !treeGridElement.contains(activeElement)) {
return;
}
const activeRow = activeElement.closest('[role="row"]');
if (!activeRow) {
return;
}
const focusablesInRow = getRowFocusables(activeRow);
const currentColumnIndex = focusablesInRow.indexOf(activeElement);
const canExpandCollapse = 0 === currentColumnIndex;
const cannotFocusNextColumn = canExpandCollapse && (activeRow.getAttribute("data-expanded") === "false" || activeRow.getAttribute("aria-expanded") === "false") && keyCode === external_wp_keycodes_namespaceObject.RIGHT;
if ([external_wp_keycodes_namespaceObject.LEFT, external_wp_keycodes_namespaceObject.RIGHT].includes(keyCode)) {
let nextIndex;
if (keyCode === external_wp_keycodes_namespaceObject.LEFT) {
nextIndex = Math.max(0, currentColumnIndex - 1);
} else {
nextIndex = Math.min(currentColumnIndex + 1, focusablesInRow.length - 1);
}
if (canExpandCollapse) {
if (keyCode === external_wp_keycodes_namespaceObject.LEFT) {
var _activeRow$getAttribu;
if (activeRow.getAttribute("data-expanded") === "true" || activeRow.getAttribute("aria-expanded") === "true") {
onCollapseRow(activeRow);
event.preventDefault();
return;
}
const level = Math.max(parseInt((_activeRow$getAttribu = activeRow?.getAttribute("aria-level")) !== null && _activeRow$getAttribu !== void 0 ? _activeRow$getAttribu : "1", 10) - 1, 1);
const rows = Array.from(treeGridElement.querySelectorAll('[role="row"]'));
let parentRow = activeRow;
const currentRowIndex = rows.indexOf(activeRow);
for (let i = currentRowIndex; i >= 0; i--) {
const ariaLevel = rows[i].getAttribute("aria-level");
if (ariaLevel !== null && parseInt(ariaLevel, 10) === level) {
parentRow = rows[i];
break;
}
}
getRowFocusables(parentRow)?.[0]?.focus();
}
if (keyCode === external_wp_keycodes_namespaceObject.RIGHT) {
if (activeRow.getAttribute("data-expanded") === "false" || activeRow.getAttribute("aria-expanded") === "false") {
onExpandRow(activeRow);
event.preventDefault();
return;
}
const focusableItems = getRowFocusables(activeRow);
if (focusableItems.length > 0) {
focusableItems[nextIndex]?.focus();
}
}
event.preventDefault();
return;
}
if (cannotFocusNextColumn) {
return;
}
focusablesInRow[nextIndex].focus();
event.preventDefault();
} else if ([external_wp_keycodes_namespaceObject.UP, external_wp_keycodes_namespaceObject.DOWN].includes(keyCode)) {
const rows = Array.from(treeGridElement.querySelectorAll('[role="row"]'));
const currentRowIndex = rows.indexOf(activeRow);
let nextRowIndex;
if (keyCode === external_wp_keycodes_namespaceObject.UP) {
nextRowIndex = Math.max(0, currentRowIndex - 1);
} else {
nextRowIndex = Math.min(currentRowIndex + 1, rows.length - 1);
}
if (nextRowIndex === currentRowIndex) {
event.preventDefault();
return;
}
const focusablesInNextRow = getRowFocusables(rows[nextRowIndex]);
if (!focusablesInNextRow || !focusablesInNextRow.length) {
event.preventDefault();
return;
}
const nextIndex = Math.min(currentColumnIndex, focusablesInNextRow.length - 1);
focusablesInNextRow[nextIndex].focus();
onFocusRow(event, activeRow, rows[nextRowIndex]);
event.preventDefault();
} else if ([external_wp_keycodes_namespaceObject.HOME, external_wp_keycodes_namespaceObject.END].includes(keyCode)) {
const rows = Array.from(treeGridElement.querySelectorAll('[role="row"]'));
const currentRowIndex = rows.indexOf(activeRow);
let nextRowIndex;
if (keyCode === external_wp_keycodes_namespaceObject.HOME) {
nextRowIndex = 0;
} else {
nextRowIndex = rows.length - 1;
}
if (nextRowIndex === currentRowIndex) {
event.preventDefault();
return;
}
const focusablesInNextRow = getRowFocusables(rows[nextRowIndex]);
if (!focusablesInNextRow || !focusablesInNextRow.length) {
event.preventDefault();
return;
}
const nextIndex = Math.min(currentColumnIndex, focusablesInNextRow.length - 1);
focusablesInNextRow[nextIndex].focus();
onFocusRow(event, activeRow, rows[nextRowIndex]);
event.preventDefault();
}
}, [onExpandRow, onCollapseRow, onFocusRow]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(RovingTabIndex, {
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
role: "application",
"aria-label": applicationAriaLabel,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("table", {
...props,
role: "treegrid",
onKeyDown,
ref,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("tbody", {
children
})
})
})
});
}
const TreeGrid = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTreeGrid);
var tree_grid_default = TreeGrid;
;// ./node_modules/@wordpress/components/build-module/tree-grid/roving-tab-index-item.js
const RovingTabIndexItem = (0,external_wp_element_namespaceObject.forwardRef)(function UnforwardedRovingTabIndexItem({
children,
as: Component,
...props
}, forwardedRef) {
const localRef = (0,external_wp_element_namespaceObject.useRef)();
const ref = forwardedRef || localRef;
const {
lastFocusedElement,
setLastFocusedElement
} = useRovingTabIndexContext();
let tabIndex;
if (lastFocusedElement) {
tabIndex = lastFocusedElement === // TODO: The original implementation simply used `ref.current` here, assuming
// that a forwarded ref would always be an object, which is not necessarily true.
// This workaround maintains the original runtime behavior in a type-safe way,
// but should be revisited.
("current" in ref ? ref.current : void 0) ? 0 : -1;
}
const onFocus = (event) => setLastFocusedElement?.(event.target);
const allProps = {
ref,
tabIndex,
onFocus,
...props
};
if (typeof children === "function") {
return children(allProps);
}
if (!Component) {
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
...allProps,
children
});
});
var roving_tab_index_item_default = RovingTabIndexItem;
;// ./node_modules/@wordpress/components/build-module/tree-grid/item.js
function UnforwardedTreeGridItem({
children,
...props
}, ref) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(roving_tab_index_item_default, {
ref,
...props,
children
});
}
const TreeGridItem = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTreeGridItem);
var tree_grid_item_item_default = TreeGridItem;
;// ./node_modules/@wordpress/components/build-module/tree-grid/cell.js
function UnforwardedTreeGridCell({
children,
withoutGridItem = false,
...props
}, ref) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("td", {
...props,
role: "gridcell",
children: withoutGridItem ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: typeof children === "function" ? children({
...props,
ref
}) : children
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(tree_grid_item_item_default, {
ref,
children
})
});
}
const TreeGridCell = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTreeGridCell);
var cell_default = TreeGridCell;
;// ./node_modules/@wordpress/components/build-module/tree-grid/row.js
function UnforwardedTreeGridRow({
children,
level,
positionInSet,
setSize,
isExpanded,
...props
}, ref) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("tr", {
...props,
ref,
role: "row",
"aria-level": level,
"aria-posinset": positionInSet,
"aria-setsize": setSize,
"aria-expanded": isExpanded,
children
});
}
const TreeGridRow = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedTreeGridRow);
var row_row_default = TreeGridRow;
;// ./node_modules/@wordpress/components/build-module/isolated-event-container/index.js
function stopPropagation(event) {
event.stopPropagation();
}
const IsolatedEventContainer = (0,external_wp_element_namespaceObject.forwardRef)((props, ref) => {
external_wp_deprecated_default()("wp.components.IsolatedEventContainer", {
since: "5.7"
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...props,
ref,
onMouseDown: stopPropagation
});
});
var isolated_event_container_default = IsolatedEventContainer;
;// ./node_modules/@wordpress/components/build-module/slot-fill/bubbles-virtually/use-slot-fills.js
function useSlotFills(name) {
const registry = (0,external_wp_element_namespaceObject.useContext)(slot_fill_context_default);
return (0,external_wp_compose_namespaceObject.useObservableValue)(registry.fills, name);
}
;// ./node_modules/@wordpress/components/build-module/z-stack/styles.js
function z_stack_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const ZStackChildView = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "ebn2ljm1"
} : 0)("&:not( :first-of-type ){", ({
offsetAmount
}) => /* @__PURE__ */ emotion_react_browser_esm_css({
marginInlineStart: offsetAmount
}, true ? "" : 0, true ? "" : 0), ";}", ({
zIndex
}) => /* @__PURE__ */ emotion_react_browser_esm_css({
zIndex
}, true ? "" : 0, true ? "" : 0), ";" + ( true ? "" : 0));
var z_stack_styles_ref = true ? {
name: "rs0gp6",
styles: "grid-row-start:1;grid-column-start:1"
} : 0;
const ZStackView = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "ebn2ljm0"
} : 0)("display:inline-grid;grid-auto-flow:column;position:relative;&>", ZStackChildView, "{position:relative;justify-self:start;", ({
isLayered
}) => isLayered ? (
// When `isLayered` is true, all items overlap in the same grid cell
z_stack_styles_ref
) : void 0, ";}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/z-stack/component.js
function UnconnectedZStack(props, forwardedRef) {
const {
children,
className,
isLayered = true,
isReversed = false,
offset = 0,
...otherProps
} = useContextSystem(props, "ZStack");
const validChildren = getValidChildren(children);
const childrenLastIndex = validChildren.length - 1;
const clonedChildren = validChildren.map((child, index) => {
const zIndex = isReversed ? childrenLastIndex - index : index;
const offsetAmount = isLayered ? offset * index : offset;
const key = (0,external_wp_element_namespaceObject.isValidElement)(child) ? child.key : index;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ZStackChildView, {
offsetAmount,
zIndex,
children: child
}, key);
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ZStackView, {
...otherProps,
className,
isLayered,
ref: forwardedRef,
children: clonedChildren
});
}
const ZStack = contextConnect(UnconnectedZStack, "ZStack");
var z_stack_component_component_default = ZStack;
;// ./node_modules/@wordpress/components/build-module/higher-order/navigate-regions/index.js
const defaultShortcuts = {
previous: [{
modifier: "ctrlShift",
character: "`"
}, {
modifier: "ctrlShift",
character: "~"
}, {
modifier: "access",
character: "p"
}],
next: [{
modifier: "ctrl",
character: "`"
}, {
modifier: "access",
character: "n"
}]
};
function useNavigateRegions(shortcuts = defaultShortcuts) {
const ref = (0,external_wp_element_namespaceObject.useRef)(null);
const [isFocusingRegions, setIsFocusingRegions] = (0,external_wp_element_namespaceObject.useState)(false);
function focusRegion(offset) {
var _ref$current$querySel;
const regions = Array.from((_ref$current$querySel = ref.current?.querySelectorAll('[role="region"][tabindex="-1"]')) !== null && _ref$current$querySel !== void 0 ? _ref$current$querySel : []);
if (!regions.length) {
return;
}
let nextRegion = regions[0];
const wrappingRegion = ref.current?.ownerDocument?.activeElement?.closest('[role="region"][tabindex="-1"]');
const selectedIndex = wrappingRegion ? regions.indexOf(wrappingRegion) : -1;
if (selectedIndex !== -1) {
let nextIndex = selectedIndex + offset;
nextIndex = nextIndex === -1 ? regions.length - 1 : nextIndex;
nextIndex = nextIndex === regions.length ? 0 : nextIndex;
nextRegion = regions[nextIndex];
}
nextRegion.focus();
setIsFocusingRegions(true);
}
const clickRef = (0,external_wp_compose_namespaceObject.useRefEffect)((element) => {
function onClick() {
setIsFocusingRegions(false);
}
element.addEventListener("click", onClick);
return () => {
element.removeEventListener("click", onClick);
};
}, [setIsFocusingRegions]);
return {
ref: (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, clickRef]),
className: isFocusingRegions ? "is-focusing-regions" : "",
onKeyDown(event) {
if (shortcuts.previous.some(({
modifier,
character
}) => {
return external_wp_keycodes_namespaceObject.isKeyboardEvent[modifier](event, character);
})) {
focusRegion(-1);
} else if (shortcuts.next.some(({
modifier,
character
}) => {
return external_wp_keycodes_namespaceObject.isKeyboardEvent[modifier](event, character);
})) {
focusRegion(1);
}
}
};
}
var navigate_regions_default = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((Component) => ({
shortcuts,
...props
}) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...useNavigateRegions(shortcuts),
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Component, {
...props
})
}), "navigateRegions");
;// ./node_modules/@wordpress/components/build-module/higher-order/with-constrained-tabbing/index.js
const withConstrainedTabbing = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((WrappedComponent) => function ComponentWithConstrainedTabbing(props) {
const ref = (0,external_wp_compose_namespaceObject.useConstrainedTabbing)();
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref,
tabIndex: -1,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
...props
})
});
}, "withConstrainedTabbing");
var with_constrained_tabbing_default = withConstrainedTabbing;
;// ./node_modules/@wordpress/components/build-module/higher-order/with-fallback-styles/index.js
var with_fallback_styles_default = (mapNodeToProps) => (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((WrappedComponent) => {
return class extends external_wp_element_namespaceObject.Component {
constructor(props) {
super(props);
this.nodeRef = this.props.node;
this.state = {
fallbackStyles: void 0,
grabStylesCompleted: false
};
this.bindRef = this.bindRef.bind(this);
}
bindRef(node) {
if (!node) {
return;
}
this.nodeRef = node;
}
componentDidMount() {
this.grabFallbackStyles();
}
componentDidUpdate() {
this.grabFallbackStyles();
}
grabFallbackStyles() {
const {
grabStylesCompleted,
fallbackStyles
} = this.state;
if (this.nodeRef && !grabStylesCompleted) {
const newFallbackStyles = mapNodeToProps(this.nodeRef, this.props);
if (!es6_default()(newFallbackStyles, fallbackStyles)) {
this.setState({
fallbackStyles: newFallbackStyles,
grabStylesCompleted: Object.values(newFallbackStyles).every(Boolean)
});
}
}
}
render() {
const wrappedComponent = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
...this.props,
...this.state.fallbackStyles
});
return this.props.node ? wrappedComponent : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
ref: this.bindRef,
children: [" ", wrappedComponent, " "]
});
}
};
}, "withFallbackStyles");
;// external ["wp","hooks"]
const external_wp_hooks_namespaceObject = window["wp"]["hooks"];
;// ./node_modules/@wordpress/components/build-module/higher-order/with-filters/index.js
const ANIMATION_FRAME_PERIOD = 16;
function withFilters(hookName) {
return (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((OriginalComponent) => {
const namespace = "core/with-filters/" + hookName;
let FilteredComponent;
function ensureFilteredComponent() {
if (FilteredComponent === void 0) {
FilteredComponent = (0,external_wp_hooks_namespaceObject.applyFilters)(hookName, OriginalComponent);
}
}
class FilteredComponentRenderer extends external_wp_element_namespaceObject.Component {
constructor(props) {
super(props);
ensureFilteredComponent();
}
componentDidMount() {
FilteredComponentRenderer.instances.push(this);
if (FilteredComponentRenderer.instances.length === 1) {
(0,external_wp_hooks_namespaceObject.addAction)("hookRemoved", namespace, onHooksUpdated);
(0,external_wp_hooks_namespaceObject.addAction)("hookAdded", namespace, onHooksUpdated);
}
}
componentWillUnmount() {
FilteredComponentRenderer.instances = FilteredComponentRenderer.instances.filter((instance) => instance !== this);
if (FilteredComponentRenderer.instances.length === 0) {
(0,external_wp_hooks_namespaceObject.removeAction)("hookRemoved", namespace);
(0,external_wp_hooks_namespaceObject.removeAction)("hookAdded", namespace);
}
}
render() {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FilteredComponent, {
...this.props
});
}
}
FilteredComponentRenderer.instances = [];
const throttledForceUpdate = (0,external_wp_compose_namespaceObject.debounce)(() => {
FilteredComponent = (0,external_wp_hooks_namespaceObject.applyFilters)(hookName, OriginalComponent);
FilteredComponentRenderer.instances.forEach((instance) => {
instance.forceUpdate();
});
}, ANIMATION_FRAME_PERIOD);
function onHooksUpdated(updatedHookName) {
if (updatedHookName === hookName) {
throttledForceUpdate();
}
}
return FilteredComponentRenderer;
}, "withFilters");
}
;// ./node_modules/@wordpress/components/build-module/higher-order/with-focus-return/index.js
function isComponentLike(object) {
return object instanceof external_wp_element_namespaceObject.Component || typeof object === "function";
}
var with_focus_return_default = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)(
// @ts-expect-error TODO: Reconcile with intended `createHigherOrderComponent` types
(options) => {
const HoC = ({
onFocusReturn
} = {}) => (WrappedComponent) => {
const WithFocusReturn = (props) => {
const ref = (0,external_wp_compose_namespaceObject.useFocusReturn)(onFocusReturn);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
ref,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(WrappedComponent, {
...props
})
});
};
return WithFocusReturn;
};
if (isComponentLike(options)) {
const WrappedComponent = options;
return HoC()(WrappedComponent);
}
return HoC(options);
},
"withFocusReturn"
);
const with_focus_return_Provider = ({
children
}) => {
external_wp_deprecated_default()("wp.components.FocusReturnProvider component", {
since: "5.7",
hint: "This provider is not used anymore. You can just remove it from your codebase"
});
return children;
};
;// ./node_modules/@wordpress/components/build-module/higher-order/with-notices/index.js
var with_notices_default = (0,external_wp_compose_namespaceObject.createHigherOrderComponent)((OriginalComponent) => {
function Component(props, ref) {
const [noticeList, setNoticeList] = (0,external_wp_element_namespaceObject.useState)([]);
const noticeOperations = (0,external_wp_element_namespaceObject.useMemo)(() => {
const createNotice = (notice) => {
const noticeToAdd = notice.id ? notice : {
...notice,
id: esm_browser_v4()
};
setNoticeList((current) => [...current, noticeToAdd]);
};
return {
createNotice,
createErrorNotice: (msg) => {
createNotice({
status: "error",
content: msg
});
},
removeNotice: (id) => {
setNoticeList((current) => current.filter((notice) => notice.id !== id));
},
removeAllNotices: () => {
setNoticeList([]);
}
};
}, []);
const propsOut = {
...props,
noticeList,
noticeOperations,
noticeUI: noticeList.length > 0 && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(list_default, {
className: "components-with-notices-ui",
notices: noticeList,
onRemove: noticeOperations.removeNotice
})
};
return isForwardRef ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalComponent, {
...propsOut,
ref
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(OriginalComponent, {
...propsOut
});
}
let isForwardRef;
const {
render
} = OriginalComponent;
if (typeof render === "function") {
isForwardRef = true;
return (0,external_wp_element_namespaceObject.forwardRef)(Component);
}
return Component;
}, "withNotices");
;// ./node_modules/@ariakit/react-core/esm/__chunks/B2J376ND.js
"use client";
// src/menu/menu-context.tsx
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 useMenuBarContext = (/* unused pure expression or super */ null && (useMenubarContext));
var useMenuBarScopedContext = (/* unused pure expression or super */ null && (useMenubarScopedContext));
var useMenuBarProviderContext = (/* unused pure expression or super */ null && (useMenubarProviderContext));
var MenuBarContextProvider = (/* unused pure expression or super */ null && (MenubarContextProvider));
var MenuBarScopedContextProvider = (/* unused pure expression or super */ null && (MenubarScopedContextProvider));
var MenuItemCheckedContext = (0,external_React_.createContext)(
void 0
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/62UHHO2X.js
"use client";
// src/menubar/menubar-context.tsx
var menubar = createStoreContext(
[CompositeContextProvider],
[CompositeScopedContextProvider]
);
var _62UHHO2X_useMenubarContext = menubar.useContext;
var _62UHHO2X_useMenubarScopedContext = menubar.useScopedContext;
var _62UHHO2X_useMenubarProviderContext = menubar.useProviderContext;
var _62UHHO2X_MenubarContextProvider = menubar.ContextProvider;
var _62UHHO2X_MenubarScopedContextProvider = menubar.ScopedContextProvider;
var _62UHHO2X_MenuItemCheckedContext = (0,external_React_.createContext)(
void 0
);
;// ./node_modules/@ariakit/core/esm/menu/menu-store.js
"use client";
// src/menu/menu-store.ts
function createMenuStore(_a = {}) {
var _b = _a, {
combobox,
parent,
menubar
} = _b, props = _3YLGPPWQ_objRest(_b, [
"combobox",
"parent",
"menubar"
]);
const parentIsMenubar = !!menubar && !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(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, props), {
store,
orientation: defaultValue(
props.orientation,
syncState.orientation,
"vertical"
)
}));
const hovercard = createHovercardStore(_chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, 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 = _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, composite.getState()), hovercard.getState()), {
initialFocus: defaultValue(syncState.initialFocus, "container"),
values: defaultValue(
props.values,
syncState.values,
props.defaultValues,
{}
)
});
const menu = createStore(initialState, composite, hovercard, store);
setup(
menu,
() => sync(menu, ["mounted"], (state) => {
if (state.mounted) return;
menu.setState("activeId", null);
})
);
setup(
menu,
() => sync(parent, ["orientation"], (state) => {
menu.setState(
"placement",
state.orientation === "vertical" ? "right-start" : "bottom-start"
);
})
);
return _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues(_chunks_3YLGPPWQ_spreadValues({}, composite), hovercard), menu), {
combobox,
parent,
menubar,
hideAll: () => {
hovercard.hide();
parent == null ? void 0 : parent.hideAll();
},
setInitialFocus: (value) => menu.setState("initialFocus", value),
setValues: (values) => menu.setState("values", values),
setValue: (name, value) => {
if (name === "__proto__") return;
if (name === "constructor") return;
if (Array.isArray(name)) return;
menu.setState("values", (values) => {
const prevValue = values[name];
const nextValue = applyState(value, prevValue);
if (nextValue === prevValue) return values;
return _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, values), {
[name]: nextValue !== void 0 && nextValue
});
});
}
});
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/MRTXKBQF.js
"use client";
// src/menu/menu-store.ts
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 menubar = _62UHHO2X_useMenubarContext();
const combobox = useComboboxProviderContext();
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
parent: props.parent !== void 0 ? props.parent : parent,
menubar: props.menubar !== void 0 ? props.menubar : menubar,
combobox: props.combobox !== void 0 ? props.combobox : combobox
});
const [store, update] = YV4JVR4I_useStore(createMenuStore, props);
return useMenuStoreProps(store, update, props);
}
;// ./node_modules/@wordpress/components/build-module/menu/context.js
const context_Context = (0,external_wp_element_namespaceObject.createContext)(void 0);
context_Context.displayName = "MenuContext";
;// ./node_modules/@ariakit/react-core/esm/__chunks/MVIULMNR.js
"use client";
// src/menu/menu-item.tsx
var MVIULMNR_TagName = "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((item) => {
var _a2;
if (item.element === currentTarget) return false;
return ((_a2 = item.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(_a) {
var _b = _a, {
store,
hideOnClick = true,
preventScrollOnKeyDown = true,
focusOnHover,
blurOnHoverEnd
} = _b, props = __objRest(_b, [
"store",
"hideOnClick",
"preventScrollOnKeyDown",
"focusOnHover",
"blurOnHoverEnd"
]);
const menuContext = useMenuScopedContext(true);
const menubarContext = _62UHHO2X_useMenubarScopedContext();
store = store || menuContext || menubarContext;
invariant(
store,
false && 0
);
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 = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
role
}, props), {
onClick
});
props = useCompositeItem(_3YLGPPWQ_spreadValues({
store,
preventScrollOnKeyDown
}, props));
props = useCompositeHover(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
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 MVIULMNR_MenuItem = memo2(
forwardRef2(function MenuItem2(props) {
const htmlProps = useMenuItem(props);
return LMDWO4NN_createElement(MVIULMNR_TagName, htmlProps);
})
);
;// ./node_modules/@ariakit/react-core/esm/__chunks/RNCDFVMF.js
"use client";
// src/checkbox/checkbox-context.tsx
var RNCDFVMF_ctx = createStoreContext();
var useCheckboxContext = RNCDFVMF_ctx.useContext;
var useCheckboxScopedContext = RNCDFVMF_ctx.useScopedContext;
var useCheckboxProviderContext = RNCDFVMF_ctx.useProviderContext;
var CheckboxContextProvider = RNCDFVMF_ctx.ContextProvider;
var CheckboxScopedContextProvider = RNCDFVMF_ctx.ScopedContextProvider;
;// ./node_modules/@ariakit/react-core/esm/__chunks/ASMQKSDT.js
"use client";
// src/checkbox/checkbox.tsx
var ASMQKSDT_TagName = "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(_a) {
var _b = _a, {
store,
name,
value: valueProp,
checked: checkedProp,
defaultChecked
} = _b, props = __objRest(_b, [
"store",
"name",
"value",
"checked",
"defaultChecked"
]);
const context = useCheckboxContext();
store = store || context;
const [_checked, setChecked] = (0,external_React_.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,external_React_.useRef)(null);
const tagName = useTagName(ref, ASMQKSDT_TagName);
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,external_React_.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((v) => v !== 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,external_ReactJSXRuntime_namespaceObject.jsx)(CheckboxCheckedContext.Provider, { value: isChecked, children: element }),
[isChecked]
);
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
role: !nativeCheckbox ? "checkbox" : void 0,
type: nativeCheckbox ? "checkbox" : void 0,
"aria-checked": checked
}, props), {
ref: useMergeRefs(ref, props.ref),
onChange,
onClick
});
props = useCommand(_3YLGPPWQ_spreadValues({ clickOnEnter: !nativeCheckbox }, props));
return removeUndefinedValues(_3YLGPPWQ_spreadValues({
name: nativeCheckbox ? name : void 0,
value: nativeCheckbox ? valueProp : void 0,
checked: isChecked
}, props));
}
);
var Checkbox = forwardRef2(function Checkbox2(props) {
const htmlProps = useCheckbox(props);
return LMDWO4NN_createElement(ASMQKSDT_TagName, htmlProps);
});
;// ./node_modules/@ariakit/core/esm/checkbox/checkbox-store.js
"use client";
// src/checkbox/checkbox-store.ts
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 _chunks_3YLGPPWQ_spreadProps(_chunks_3YLGPPWQ_spreadValues({}, checkbox), {
setValue: (value) => checkbox.setState("value", value)
});
}
;// ./node_modules/@ariakit/react-core/esm/__chunks/HAVBGUA3.js
"use client";
// src/checkbox/checkbox-store.ts
function useCheckboxStoreProps(store, update, props) {
useUpdateEffect(update, [props.store]);
useStoreProps(store, props, "value", "setValue");
return store;
}
function useCheckboxStore(props = {}) {
const [store, update] = YV4JVR4I_useStore(createCheckboxStore, props);
return useCheckboxStoreProps(store, update, props);
}
;// ./node_modules/@ariakit/react-core/esm/menu/menu-item-checkbox.js
"use client";
// src/menu/menu-item-checkbox.tsx
var menu_item_checkbox_TagName = "div";
function menu_item_checkbox_getPrimitiveValue(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 = menu_item_checkbox_getPrimitiveValue(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((v) => v !== primitiveValue);
}
var useMenuItemCheckbox = createHook(
function useMenuItemCheckbox2(_a) {
var _b = _a, {
store,
name,
value,
checked,
defaultChecked: defaultCheckedProp,
hideOnClick = false
} = _b, props = __objRest(_b, [
"store",
"name",
"value",
"checked",
"defaultChecked",
"hideOnClick"
]);
const context = useMenuScopedContext();
store = store || context;
invariant(
store,
false && 0
);
const defaultChecked = useInitialValue(defaultCheckedProp);
(0,external_React_.useEffect)(() => {
store == null ? void 0 : store.setValue(name, (prevValue = []) => {
if (!defaultChecked) return prevValue;
return getValue(prevValue, value, true);
});
}, [store, name, value, defaultChecked]);
(0,external_React_.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 = _3YLGPPWQ_spreadValues({
role: "menuitemcheckbox"
}, props);
props = useCheckbox(_3YLGPPWQ_spreadValues({
store: checkboxStore,
name,
value,
checked
}, props));
props = useMenuItem(_3YLGPPWQ_spreadValues({ store, hideOnClick }, props));
return props;
}
);
var MenuItemCheckbox = memo2(
forwardRef2(function MenuItemCheckbox2(props) {
const htmlProps = useMenuItemCheckbox(props);
return LMDWO4NN_createElement(menu_item_checkbox_TagName, htmlProps);
})
);
;// ./node_modules/@ariakit/react-core/esm/menu/menu-item-radio.js
"use client";
// src/menu/menu-item-radio.tsx
var menu_item_radio_TagName = "div";
function menu_item_radio_getValue(prevValue, value, checked) {
if (checked === void 0) return prevValue;
if (checked) return value;
return prevValue;
}
var useMenuItemRadio = createHook(
function useMenuItemRadio2(_a) {
var _b = _a, {
store,
name,
value,
checked,
onChange: onChangeProp,
hideOnClick = false
} = _b, props = __objRest(_b, [
"store",
"name",
"value",
"checked",
"onChange",
"hideOnClick"
]);
const context = useMenuScopedContext();
store = store || context;
invariant(
store,
false && 0
);
const defaultChecked = useInitialValue(props.defaultChecked);
(0,external_React_.useEffect)(() => {
store == null ? void 0 : store.setValue(name, (prevValue = false) => {
return menu_item_radio_getValue(prevValue, value, defaultChecked);
});
}, [store, name, value, defaultChecked]);
(0,external_React_.useEffect)(() => {
if (checked === void 0) return;
store == null ? void 0 : store.setValue(name, (prevValue) => {
return menu_item_radio_getValue(prevValue, value, checked);
});
}, [store, name, value, checked]);
const isChecked = store.useState((state) => state.values[name] === value);
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MenuItemCheckedContext.Provider, { value: !!isChecked, children: element }),
[isChecked]
);
props = _3YLGPPWQ_spreadValues({
role: "menuitemradio"
}, props);
props = useRadio(_3YLGPPWQ_spreadValues({
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 menu_item_radio_getValue(prevValue, value, checked != null ? checked : element.checked);
});
}
}, props));
props = useMenuItem(_3YLGPPWQ_spreadValues({ store, hideOnClick }, props));
return props;
}
);
var MenuItemRadio = memo2(
forwardRef2(function MenuItemRadio2(props) {
const htmlProps = useMenuItemRadio(props);
return LMDWO4NN_createElement(menu_item_radio_TagName, htmlProps);
})
);
;// ./node_modules/@ariakit/react-core/esm/menu/menu-group.js
"use client";
// src/menu/menu-group.tsx
var menu_group_TagName = "div";
var useMenuGroup = createHook(
function useMenuGroup2(props) {
props = useCompositeGroup(props);
return props;
}
);
var menu_group_MenuGroup = forwardRef2(function MenuGroup2(props) {
const htmlProps = useMenuGroup(props);
return LMDWO4NN_createElement(menu_group_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/menu/menu-group-label.js
"use client";
// src/menu/menu-group-label.tsx
var menu_group_label_TagName = "div";
var useMenuGroupLabel = createHook(
function useMenuGroupLabel2(props) {
props = useCompositeGroupLabel(props);
return props;
}
);
var MenuGroupLabel = forwardRef2(function MenuGroupLabel2(props) {
const htmlProps = useMenuGroupLabel(props);
return LMDWO4NN_createElement(menu_group_label_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/TP7N7UIH.js
"use client";
// src/composite/composite-separator.tsx
var TP7N7UIH_TagName = "hr";
var useCompositeSeparator = createHook(function useCompositeSeparator2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useCompositeContext();
store = store || context;
invariant(
store,
false && 0
);
const orientation = store.useState(
(state) => state.orientation === "horizontal" ? "vertical" : "horizontal"
);
props = useSeparator(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { orientation }));
return props;
});
var CompositeSeparator = forwardRef2(function CompositeSeparator2(props) {
const htmlProps = useCompositeSeparator(props);
return LMDWO4NN_createElement(TP7N7UIH_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/menu/menu-separator.js
"use client";
// src/menu/menu-separator.tsx
var menu_separator_TagName = "hr";
var useMenuSeparator = createHook(
function useMenuSeparator2(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const context = useMenuContext();
store = store || context;
props = useCompositeSeparator(_3YLGPPWQ_spreadValues({ store }, props));
return props;
}
);
var MenuSeparator = forwardRef2(function MenuSeparator2(props) {
const htmlProps = useMenuSeparator(props);
return LMDWO4NN_createElement(menu_separator_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/menu/styles.js
function menu_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const styles_ANIMATION_PARAMS = {
SCALE_AMOUNT_OUTER: 0.82,
SCALE_AMOUNT_CONTENT: 0.9,
DURATION: {
IN: "400ms",
OUT: "200ms"
},
EASING: "cubic-bezier(0.33, 0, 0, 1)"
};
const CONTENT_WRAPPER_PADDING = space(1);
const ITEM_PADDING_BLOCK = space(2);
const ITEM_PADDING_INLINE = space(3);
const DEFAULT_BORDER_COLOR = COLORS.theme.gray[300];
const DIVIDER_COLOR = COLORS.theme.gray[200];
const LIGHTER_TEXT_COLOR = COLORS.theme.gray[700];
const LIGHT_BACKGROUND_COLOR = COLORS.theme.gray[100];
const TOOLBAR_VARIANT_BORDER_COLOR = COLORS.theme.foreground;
const DEFAULT_BOX_SHADOW = `0 0 0 ${config_values_default.borderWidth} ${DEFAULT_BORDER_COLOR}, ${config_values_default.elevationMedium}`;
const TOOLBAR_VARIANT_BOX_SHADOW = `0 0 0 ${config_values_default.borderWidth} ${TOOLBAR_VARIANT_BORDER_COLOR}`;
const GRID_TEMPLATE_COLS = "minmax( 0, max-content ) 1fr";
const PopoverOuterWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1wg7tti14"
} : 0)("position:relative;background-color:", COLORS.ui.background, ";border-radius:", config_values_default.radiusMedium, ";", (props) => /* @__PURE__ */ emotion_react_browser_esm_css("box-shadow:", props.variant === "toolbar" ? TOOLBAR_VARIANT_BOX_SHADOW : DEFAULT_BOX_SHADOW, ";" + ( true ? "" : 0), true ? "" : 0), " overflow:hidden;@media not ( prefers-reduced-motion ){transition-property:transform,opacity;transition-timing-function:", styles_ANIMATION_PARAMS.EASING, ";transition-duration:", styles_ANIMATION_PARAMS.DURATION.IN, ";will-change:transform,opacity;opacity:0;&:has( [data-enter] ){opacity:1;}&:has( [data-leave] ){transition-duration:", styles_ANIMATION_PARAMS.DURATION.OUT, ";}&:has( [data-side='bottom'] ),&:has( [data-side='top'] ){transform:scaleY( ", styles_ANIMATION_PARAMS.SCALE_AMOUNT_OUTER, " );}&:has( [data-side='bottom'] ){transform-origin:top;}&:has( [data-side='top'] ){transform-origin:bottom;}&:has( [data-enter][data-side='bottom'] ),&:has( [data-enter][data-side='top'] ),&:has( [data-leave][data-side='bottom'] ),&:has( [data-leave][data-side='top'] ){transform:scaleY( 1 );}}" + ( true ? "" : 0));
const PopoverInnerWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1wg7tti13"
} : 0)("position:relative;z-index:1000000;display:grid;grid-template-columns:", GRID_TEMPLATE_COLS, ";grid-template-rows:auto;box-sizing:border-box;min-width:160px;max-width:320px;max-height:var( --popover-available-height );padding:", CONTENT_WRAPPER_PADDING, ";overscroll-behavior:contain;overflow:auto;outline:2px solid transparent!important;@media not ( prefers-reduced-motion ){transition:inherit;transform-origin:inherit;&[data-side='bottom'],&[data-side='top']{transform:scaleY(\n calc(\n 1 / ", styles_ANIMATION_PARAMS.SCALE_AMOUNT_OUTER, " *\n ", styles_ANIMATION_PARAMS.SCALE_AMOUNT_CONTENT, "\n )\n );}&[data-enter][data-side='bottom'],&[data-enter][data-side='top'],&[data-leave][data-side='bottom'],&[data-leave][data-side='top']{transform:scaleY( 1 );}}" + ( true ? "" : 0));
const baseItem = /* @__PURE__ */ emotion_react_browser_esm_css("all:unset;position:relative;min-height:", space(10), ";box-sizing:border-box;grid-column:1/-1;display:grid;grid-template-columns:", GRID_TEMPLATE_COLS, ";align-items:center;@supports ( grid-template-columns: subgrid ){grid-template-columns:subgrid;}font-size:", font("default.fontSize"), ";font-family:inherit;font-weight:normal;line-height:20px;color:", COLORS.theme.foreground, ";border-radius:", config_values_default.radiusSmall, ";padding-block:", ITEM_PADDING_BLOCK, ";padding-inline:", ITEM_PADDING_INLINE, ";scroll-margin:", CONTENT_WRAPPER_PADDING, ";user-select:none;outline:none;&[aria-disabled='true']{color:", COLORS.ui.textDisabled, ";cursor:not-allowed;}&[data-active-item]:not( [data-focus-visible] ):not(\n [aria-disabled='true']\n ){background-color:", COLORS.theme.accent, ";color:", COLORS.theme.accentInverted, ";}&[data-focus-visible]{box-shadow:0 0 0 1.5px ", COLORS.theme.accent, ";outline:2px solid transparent;}&:active,&[data-active]{}", PopoverInnerWrapper, ':not(:focus) &:not(:focus)[aria-expanded="true"]{background-color:', LIGHT_BACKGROUND_COLOR, ";color:", COLORS.theme.foreground, ";}svg{fill:currentColor;}" + ( true ? "" : 0), true ? "" : 0);
const styles_Item = /* @__PURE__ */ emotion_styled_base_browser_esm(MVIULMNR_MenuItem, true ? {
target: "e1wg7tti12"
} : 0)(baseItem, ";" + ( true ? "" : 0));
const CheckboxItem = /* @__PURE__ */ emotion_styled_base_browser_esm(MenuItemCheckbox, true ? {
target: "e1wg7tti11"
} : 0)(baseItem, ";" + ( true ? "" : 0));
const RadioItem = /* @__PURE__ */ emotion_styled_base_browser_esm(MenuItemRadio, true ? {
target: "e1wg7tti10"
} : 0)(baseItem, ";" + ( true ? "" : 0));
const ItemPrefixWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1wg7tti9"
} : 0)("grid-column:1;", CheckboxItem, ">&,", RadioItem, ">&{min-width:", space(6), ";}", CheckboxItem, ">&,", RadioItem, ">&,&:not( :empty ){margin-inline-end:", space(2), ";}display:flex;align-items:center;justify-content:center;color:", LIGHTER_TEXT_COLOR, ";[data-active-item]:not( [data-focus-visible] )>&,[aria-disabled='true']>&{color:inherit;}" + ( true ? "" : 0));
const ItemContentWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1wg7tti8"
} : 0)("grid-column:2;display:flex;align-items:center;justify-content:space-between;gap:", space(3), ";pointer-events:none;" + ( true ? "" : 0));
const ItemChildrenWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1wg7tti7"
} : 0)("flex:1;display:inline-flex;flex-direction:column;gap:", space(1), ";" + ( true ? "" : 0));
const ItemSuffixWrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "e1wg7tti6"
} : 0)("flex:0 1 fit-content;min-width:0;width:fit-content;display:flex;align-items:center;justify-content:center;gap:", space(3), ";color:", LIGHTER_TEXT_COLOR, ";[data-active-item]:not( [data-focus-visible] ) *:not(", PopoverInnerWrapper, ") &,[aria-disabled='true'] *:not(", PopoverInnerWrapper, ") &{color:inherit;}" + ( true ? "" : 0));
const styles_Group = /* @__PURE__ */ emotion_styled_base_browser_esm(menu_group_MenuGroup, true ? {
target: "e1wg7tti5"
} : 0)( true ? {
name: "49aokf",
styles: "display:contents"
} : 0);
const styles_GroupLabel = /* @__PURE__ */ emotion_styled_base_browser_esm(MenuGroupLabel, true ? {
target: "e1wg7tti4"
} : 0)("grid-column:1/-1;padding-block-start:", space(3), ";padding-block-end:", space(2), ";padding-inline:", ITEM_PADDING_INLINE, ";" + ( true ? "" : 0));
const styles_Separator = /* @__PURE__ */ emotion_styled_base_browser_esm(MenuSeparator, true ? {
target: "e1wg7tti3"
} : 0)("grid-column:1/-1;border:none;height:", config_values_default.borderWidth, ";background-color:", (props) => props.variant === "toolbar" ? TOOLBAR_VARIANT_BORDER_COLOR : DIVIDER_COLOR, ";margin-block:", space(2), ";margin-inline:", ITEM_PADDING_INLINE, ";outline:2px solid transparent;" + ( true ? "" : 0));
const SubmenuChevronIcon = /* @__PURE__ */ emotion_styled_base_browser_esm(icon_icon_default, true ? {
target: "e1wg7tti2"
} : 0)("width:", space(1.5), ";", rtl({
transform: `scaleX(1)`
}, {
transform: `scaleX(-1)`
}), ";" + ( true ? "" : 0));
const ItemLabel = /* @__PURE__ */ emotion_styled_base_browser_esm(truncate_component_component_default, true ? {
target: "e1wg7tti1"
} : 0)("font-size:", font("default.fontSize"), ";line-height:20px;color:inherit;" + ( true ? "" : 0));
const ItemHelpText = /* @__PURE__ */ emotion_styled_base_browser_esm(truncate_component_component_default, true ? {
target: "e1wg7tti0"
} : 0)("font-size:", font("helpText.fontSize"), ";line-height:16px;color:", LIGHTER_TEXT_COLOR, ";overflow-wrap:anywhere;[data-active-item]:not( [data-focus-visible] ) *:not( ", PopoverInnerWrapper, " ) &,[aria-disabled='true'] *:not( ", PopoverInnerWrapper, " ) &{color:inherit;}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/menu/item.js
const item_Item = (0,external_wp_element_namespaceObject.forwardRef)(function Item2({
prefix,
suffix,
children,
disabled = false,
hideOnClick = true,
store,
...props
}, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.Item can only be rendered inside a Menu component");
}
const computedStore = store !== null && store !== void 0 ? store : menuContext.store;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(styles_Item, {
ref,
...props,
accessibleWhenDisabled: true,
disabled,
hideOnClick,
store: computedStore,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemPrefixWrapper, {
children: prefix
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ItemContentWrapper, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemChildrenWrapper, {
children
}), suffix && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemSuffixWrapper, {
children: suffix
})]
})]
});
});
;// ./node_modules/@ariakit/react-core/esm/menu/menu-item-check.js
"use client";
// src/menu/menu-item-check.tsx
var menu_item_check_TagName = "span";
var useMenuItemCheck = createHook(
function useMenuItemCheck2(_a) {
var _b = _a, { store, checked } = _b, props = __objRest(_b, ["store", "checked"]);
const context = (0,external_React_.useContext)(MenuItemCheckedContext);
checked = checked != null ? checked : context;
props = useCheckboxCheck(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), { checked }));
return props;
}
);
var MenuItemCheck = forwardRef2(function MenuItemCheck2(props) {
const htmlProps = useMenuItemCheck(props);
return LMDWO4NN_createElement(menu_item_check_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/menu/checkbox-item.js
const checkbox_item_CheckboxItem = (0,external_wp_element_namespaceObject.forwardRef)(function CheckboxItem2({
suffix,
children,
disabled = false,
hideOnClick = false,
...props
}, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.CheckboxItem can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(CheckboxItem, {
ref,
...props,
accessibleWhenDisabled: true,
disabled,
hideOnClick,
store: menuContext.store,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MenuItemCheck, {
store: menuContext.store,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemPrefixWrapper, {}),
style: {
width: "auto",
height: "auto"
},
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: check_default,
size: 24
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ItemContentWrapper, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemChildrenWrapper, {
children
}), suffix && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemSuffixWrapper, {
children: suffix
})]
})]
});
});
;// ./node_modules/@wordpress/components/build-module/menu/radio-item.js
const radioCheck = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, {
xmlns: "http://www.w3.org/2000/svg",
viewBox: "0 0 24 24",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Circle, {
cx: 12,
cy: 12,
r: 3
})
});
const radio_item_RadioItem = (0,external_wp_element_namespaceObject.forwardRef)(function RadioItem2({
suffix,
children,
disabled = false,
hideOnClick = false,
...props
}, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.RadioItem can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(RadioItem, {
ref,
...props,
accessibleWhenDisabled: true,
disabled,
hideOnClick,
store: menuContext.store,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MenuItemCheck, {
store: menuContext.store,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemPrefixWrapper, {}),
style: {
width: "auto",
height: "auto"
},
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(build_module_icon_icon_default, {
icon: radioCheck,
size: 24
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(ItemContentWrapper, {
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemChildrenWrapper, {
children
}), suffix && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemSuffixWrapper, {
children: suffix
})]
})]
});
});
;// ./node_modules/@wordpress/components/build-module/menu/group.js
const group_Group = (0,external_wp_element_namespaceObject.forwardRef)(function Group2(props, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.Group can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_Group, {
ref,
...props,
store: menuContext.store
});
});
;// ./node_modules/@wordpress/components/build-module/menu/group-label.js
const group_label_GroupLabel = (0,external_wp_element_namespaceObject.forwardRef)(function Group(props, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.GroupLabel can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_GroupLabel, {
ref,
render: (
// @ts-expect-error The `children` prop is passed
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(text_component_component_default, {
upperCase: true,
variant: "muted",
size: "11px",
weight: 500,
lineHeight: "16px"
})
),
...props,
store: menuContext.store
});
});
;// ./node_modules/@wordpress/components/build-module/menu/separator.js
const separator_Separator = (0,external_wp_element_namespaceObject.forwardRef)(function Separator2(props, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.Separator can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_Separator, {
ref,
...props,
store: menuContext.store,
variant: menuContext.variant
});
});
;// ./node_modules/@wordpress/components/build-module/menu/item-label.js
const item_label_ItemLabel = (0,external_wp_element_namespaceObject.forwardRef)(function ItemLabel2(props, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.ItemLabel can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemLabel, {
numberOfLines: 1,
ref,
...props
});
});
;// ./node_modules/@wordpress/components/build-module/menu/item-help-text.js
const item_help_text_ItemHelpText = (0,external_wp_element_namespaceObject.forwardRef)(function ItemHelpText2(props, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.ItemHelpText can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ItemHelpText, {
numberOfLines: 2,
ref,
...props
});
});
;// ./node_modules/@ariakit/react-core/esm/menu/menu-button.js
"use client";
// src/menu/menu-button.tsx
var menu_button_TagName = "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((item) => {
if (!item.element) return false;
if (item.element === excludeElement) return false;
return item.element.getAttribute("aria-expanded") === "true";
}));
}
var useMenuButton = createHook(
function useMenuButton2(_a) {
var _b = _a, {
store,
focusable,
accessibleWhenDisabled,
showOnHover
} = _b, props = __objRest(_b, [
"store",
"focusable",
"accessibleWhenDisabled",
"showOnHover"
]);
const context = useMenuProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const ref = (0,external_React_.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,external_ReactJSXRuntime_namespaceObject.jsx)(MenuContextProvider, { value: store, children: element }),
[store]
);
if (hasParentMenu) {
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Role.div, { render: props.render })
});
}
const id = 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 = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
role,
"aria-haspopup": getPopupRole(contentElement, "menu")
}, props), {
ref: useMergeRefs(ref, props.ref),
onFocus,
onKeyDown,
onClick
});
props = useHovercardAnchor(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
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(_3YLGPPWQ_spreadValues({
store,
toggleOnClick: !hasParentMenu,
focusable,
accessibleWhenDisabled
}, props));
props = useCompositeTypeahead(_3YLGPPWQ_spreadValues({
store,
typeahead: parentIsMenubar
}, props));
return props;
}
);
var MenuButton = forwardRef2(function MenuButton2(props) {
const htmlProps = useMenuButton(props);
return LMDWO4NN_createElement(menu_button_TagName, htmlProps);
});
;// ./node_modules/@wordpress/components/build-module/menu/trigger-button.js
const TriggerButton = (0,external_wp_element_namespaceObject.forwardRef)(function TriggerButton2({
children,
disabled = false,
...props
}, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store) {
throw new Error("Menu.TriggerButton can only be rendered inside a Menu component");
}
if (menuContext.store.parent) {
throw new Error("Menu.TriggerButton should not be rendered inside a nested Menu component. Use Menu.SubmenuTriggerItem instead.");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MenuButton, {
ref,
...props,
disabled,
store: menuContext.store,
children
});
});
;// ./node_modules/@wordpress/icons/build-module/library/chevron-right-small.js
var chevron_right_small_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.Path, { d: "M10.8622 8.04053L14.2805 12.0286L10.8622 16.0167L9.72327 15.0405L12.3049 12.0286L9.72327 9.01672L10.8622 8.04053Z" }) });
;// ./node_modules/@wordpress/components/build-module/menu/submenu-trigger-item.js
const SubmenuTriggerItem = (0,external_wp_element_namespaceObject.forwardRef)(function SubmenuTriggerItem2({
suffix,
...otherProps
}, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
if (!menuContext?.store.parent) {
throw new Error("Menu.SubmenuTriggerItem can only be rendered inside a nested Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MenuButton, {
ref,
accessibleWhenDisabled: true,
store: menuContext.store,
render: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(item_Item, {
...otherProps,
// The menu item needs to register and be part of the parent menu.
// Without specifying the store explicitly, the `Item` component
// would otherwise read the store via context and pick up the one from
// the sub-menu `Menu` component.
store: menuContext.store.parent,
suffix: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [suffix, /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(SubmenuChevronIcon, {
"aria-hidden": "true",
icon: chevron_right_small_default,
size: 24,
preserveAspectRatio: "xMidYMid slice"
})]
})
})
});
});
;// ./node_modules/@ariakit/react-core/esm/__chunks/ASGALOAX.js
"use client";
// src/menu/menu-list.tsx
var ASGALOAX_TagName = "div";
function useAriaLabelledBy(_a) {
var _b = _a, { store } = _b, props = __objRest(_b, ["store"]);
const [id, setId] = (0,external_React_.useState)(void 0);
const label = props["aria-label"];
const disclosureElement = useStoreState(store, "disclosureElement");
const contentElement = useStoreState(store, "contentElement");
(0,external_React_.useEffect)(() => {
const disclosure = disclosureElement;
if (!disclosure) return;
const menu = contentElement;
if (!menu) return;
const menuLabel = label || menu.hasAttribute("aria-label");
if (menuLabel) {
setId(void 0);
} else if (disclosure.id) {
setId(disclosure.id);
}
}, [label, disclosureElement, contentElement]);
return id;
}
var useMenuList = createHook(
function useMenuList2(_a) {
var _b = _a, { store, alwaysVisible, composite } = _b, props = __objRest(_b, ["store", "alwaysVisible", "composite"]);
const context = useMenuProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const parentMenu = store.parent;
const parentMenubar = store.menubar;
const hasParentMenu = !!parentMenu;
const id = 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 id2 = action == null ? void 0 : action();
if (id2 !== void 0) {
event.stopPropagation();
event.preventDefault();
parentMenubar.move(id2);
}
}
});
props = useWrapElement(
props,
(element) => /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(MenuScopedContextProvider, { value: store, children: element }),
[store]
);
const ariaLabelledBy = useAriaLabelledBy(_3YLGPPWQ_spreadValues({ store }, props));
const mounted = store.useState("mounted");
const hidden = isHidden(mounted, props.hidden, alwaysVisible);
const style = hidden ? _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props.style), { display: "none" }) : props.style;
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
id,
"aria-labelledby": ariaLabelledBy,
hidden
}, props), {
ref: useMergeRefs(id ? store.setContentElement : null, props.ref),
style,
onKeyDown
});
const hasCombobox = !!store.combobox;
composite = composite != null ? composite : !hasCombobox;
if (composite) {
props = _3YLGPPWQ_spreadValues({
role: "menu",
"aria-orientation": orientation
}, props);
}
props = useComposite(_3YLGPPWQ_spreadValues({ store, composite }, props));
props = useCompositeTypeahead(_3YLGPPWQ_spreadValues({ store, typeahead: !hasCombobox }, props));
return props;
}
);
var MenuList = forwardRef2(function MenuList2(props) {
const htmlProps = useMenuList(props);
return LMDWO4NN_createElement(ASGALOAX_TagName, htmlProps);
});
;// ./node_modules/@ariakit/react-core/esm/menu/menu.js
"use client";
// src/menu/menu.tsx
var menu_TagName = "div";
var useMenu = createHook(function useMenu2(_a) {
var _b = _a, {
store,
modal: modalProp = false,
portal = !!modalProp,
hideOnEscape = true,
autoFocusOnShow = true,
hideOnHoverOutside,
alwaysVisible
} = _b, props = __objRest(_b, [
"store",
"modal",
"portal",
"hideOnEscape",
"autoFocusOnShow",
"hideOnHoverOutside",
"alwaysVisible"
]);
const context = useMenuProviderContext();
store = store || context;
invariant(
store,
false && 0
);
const ref = (0,external_React_.useRef)(null);
const parentMenu = store.parent;
const parentMenubar = store.menubar;
const hasParentMenu = !!parentMenu;
const parentIsMenubar = !!parentMenubar && !hasParentMenu;
props = _3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({}, props), {
ref: useMergeRefs(ref, props.ref)
});
const _a2 = useMenuList(_3YLGPPWQ_spreadValues({
store,
alwaysVisible
}, props)), { "aria-labelledby": ariaLabelledBy } = _a2, menuListProps = __objRest(_a2, ["aria-labelledby"]);
props = menuListProps;
const [initialFocusRef, setInitialFocusRef] = (0,external_React_.useState)();
const autoFocusOnShowState = store.useState("autoFocusOnShow");
const initialFocus = store.useState("initialFocus");
const baseElement = store.useState("baseElement");
const items = store.useState("renderedItems");
(0,external_React_.useEffect)(() => {
let cleaning = false;
setInitialFocusRef((prevInitialFocusRef) => {
var _a3, _b2, _c;
if (cleaning) return;
if (!autoFocusOnShowState) return;
if ((_a3 = prevInitialFocusRef == null ? void 0 : prevInitialFocusRef.current) == null ? void 0 : _a3.isConnected) return prevInitialFocusRef;
const ref2 = (0,external_React_.createRef)();
switch (initialFocus) {
case "first":
ref2.current = ((_b2 = items.find((item) => !item.disabled && item.element)) == null ? void 0 : _b2.element) || null;
break;
case "last":
ref2.current = ((_c = [...items].reverse().find((item) => !item.disabled && item.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,external_React_.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 = _3YLGPPWQ_spreadValues({
preserveTabOrderAnchor
}, props);
}
props = useHovercard(_3YLGPPWQ_spreadProps(_3YLGPPWQ_spreadValues({
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 = _3YLGPPWQ_spreadValues({
"aria-labelledby": ariaLabelledBy
}, props);
return props;
});
var Menu = createDialogComponent(
forwardRef2(function Menu2(props) {
const htmlProps = useMenu(props);
return LMDWO4NN_createElement(menu_TagName, htmlProps);
}),
useMenuProviderContext
);
;// ./node_modules/@wordpress/components/build-module/menu/popover.js
const menu_popover_Popover = (0,external_wp_element_namespaceObject.forwardRef)(function Popover2({
gutter,
children,
shift,
modal = true,
...otherProps
}, ref) {
const menuContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
const appliedPlacementSide = useStoreState(menuContext?.store, "currentPlacement")?.split("-")[0];
const hideOnEscape = (0,external_wp_element_namespaceObject.useCallback)((event) => {
event.preventDefault();
return true;
}, []);
const computedDirection = useStoreState(menuContext?.store, "rtl") ? "rtl" : "ltr";
const wrapperProps = (0,external_wp_element_namespaceObject.useMemo)(() => ({
dir: computedDirection,
style: {
direction: computedDirection
}
}), [computedDirection]);
if (!menuContext?.store) {
throw new Error("Menu.Popover can only be rendered inside a Menu component");
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(Menu, {
...otherProps,
ref,
modal,
store: menuContext.store,
gutter: gutter !== null && gutter !== void 0 ? gutter : menuContext.store.parent ? 0 : 8,
shift: shift !== null && shift !== void 0 ? shift : menuContext.store.parent ? -4 : 0,
hideOnHoverOutside: false,
"data-side": appliedPlacementSide,
wrapperProps,
hideOnEscape,
unmountOnHide: true,
render: (renderProps) => (
// Two wrappers are needed for the entry animation, where the menu
// container scales with a different factor than its contents.
// The {...renderProps} are passed to the inner wrapper, so that the
// menu element is the direct parent of the menu item elements.
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PopoverOuterWrapper, {
variant: menuContext.variant,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PopoverInnerWrapper, {
...renderProps
})
})
),
children
});
});
;// ./node_modules/@wordpress/components/build-module/menu/index.js
const UnconnectedMenu = (props) => {
const {
children,
defaultOpen = false,
open,
onOpenChange,
placement,
// From internal components context
variant
} = useContextSystem(props, "Menu");
const parentContext = (0,external_wp_element_namespaceObject.useContext)(context_Context);
const rtl = (0,external_wp_i18n_namespaceObject.isRTL)();
let computedPlacement = placement !== null && placement !== void 0 ? placement : parentContext?.store ? "right-start" : "bottom-start";
if (rtl) {
if (/right/.test(computedPlacement)) {
computedPlacement = computedPlacement.replace("right", "left");
} else if (/left/.test(computedPlacement)) {
computedPlacement = computedPlacement.replace("left", "right");
}
}
const menuStore = useMenuStore({
parent: parentContext?.store,
open,
defaultOpen,
placement: computedPlacement,
focusLoop: true,
setOpen(willBeOpen) {
onOpenChange?.(willBeOpen);
},
rtl
});
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
store: menuStore,
variant
}), [menuStore, variant]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(context_Context.Provider, {
value: contextValue,
children
});
};
const menu_Menu = Object.assign(contextConnectWithoutRef(UnconnectedMenu, "Menu"), {
Context: Object.assign(context_Context, {
displayName: "Menu.Context"
}),
/**
* Renders a menu item inside the `Menu.Popover` or `Menu.Group` components.
*
* It can optionally contain one instance of the `Menu.ItemLabel` component
* and one instance of the `Menu.ItemHelpText` component.
*/
Item: Object.assign(item_Item, {
displayName: "Menu.Item"
}),
/**
* Renders a radio menu item inside the `Menu.Popover` or `Menu.Group`
* components.
*
* It can optionally contain one instance of the `Menu.ItemLabel` component
* and one instance of the `Menu.ItemHelpText` component.
*/
RadioItem: Object.assign(radio_item_RadioItem, {
displayName: "Menu.RadioItem"
}),
/**
* Renders a checkbox menu item inside the `Menu.Popover` or `Menu.Group`
* components.
*
* It can optionally contain one instance of the `Menu.ItemLabel` component
* and one instance of the `Menu.ItemHelpText` component.
*/
CheckboxItem: Object.assign(checkbox_item_CheckboxItem, {
displayName: "Menu.CheckboxItem"
}),
/**
* Renders a group for menu items.
*
* It should contain one instance of `Menu.GroupLabel` and one or more
* instances of `Menu.Item`, `Menu.RadioItem`, or `Menu.CheckboxItem`.
*/
Group: Object.assign(group_Group, {
displayName: "Menu.Group"
}),
/**
* Renders a label in a menu group.
*
* This component should be wrapped with `Menu.Group` so the
* `aria-labelledby` is correctly set on the group element.
*/
GroupLabel: Object.assign(group_label_GroupLabel, {
displayName: "Menu.GroupLabel"
}),
/**
* Renders a divider between menu items or menu groups.
*/
Separator: Object.assign(separator_Separator, {
displayName: "Menu.Separator"
}),
/**
* Renders a menu item's label text. It should be wrapped with `Menu.Item`,
* `Menu.RadioItem`, or `Menu.CheckboxItem`.
*/
ItemLabel: Object.assign(item_label_ItemLabel, {
displayName: "Menu.ItemLabel"
}),
/**
* Renders a menu item's help text. It should be wrapped with `Menu.Item`,
* `Menu.RadioItem`, or `Menu.CheckboxItem`.
*/
ItemHelpText: Object.assign(item_help_text_ItemHelpText, {
displayName: "Menu.ItemHelpText"
}),
/**
* Renders a dropdown menu element that's controlled by a sibling
* `Menu.TriggerButton` component. It renders a popover and automatically
* focuses on items when the menu is shown.
*
* The only valid children of `Menu.Popover` are `Menu.Item`,
* `Menu.RadioItem`, `Menu.CheckboxItem`, `Menu.Group`, `Menu.Separator`,
* and `Menu` (for nested dropdown menus).
*/
Popover: Object.assign(menu_popover_Popover, {
displayName: "Menu.Popover"
}),
/**
* Renders a menu button that toggles the visibility of a sibling
* `Menu.Popover` component when clicked or when using arrow keys.
*/
TriggerButton: Object.assign(TriggerButton, {
displayName: "Menu.TriggerButton"
}),
/**
* Renders a menu item that toggles the visibility of a sibling
* `Menu.Popover` component when clicked or when using arrow keys.
*
* This component is used to create a nested dropdown menu.
*/
SubmenuTriggerItem: Object.assign(SubmenuTriggerItem, {
displayName: "Menu.SubmenuTriggerItem"
})
});
var build_module_menu_menu_default = (/* unused pure expression or super */ null && (menu_Menu));
;// ./node_modules/@wordpress/components/build-module/theme/styles.js
function theme_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const colorVariables = ({
colors
}) => {
const shades = Object.entries(colors.gray || {}).map(([k, v]) => `--wp-components-color-gray-${k}: ${v};`).join("");
return [/* @__PURE__ */ emotion_react_browser_esm_css("--wp-components-color-accent:", colors.accent, ";--wp-components-color-accent-darker-10:", colors.accentDarker10, ";--wp-components-color-accent-darker-20:", colors.accentDarker20, ";--wp-components-color-accent-inverted:", colors.accentInverted, ";--wp-components-color-background:", colors.background, ";--wp-components-color-foreground:", colors.foreground, ";--wp-components-color-foreground-inverted:", colors.foregroundInverted, ";", shades, ";" + ( true ? "" : 0), true ? "" : 0)];
};
const theme_styles_Wrapper = /* @__PURE__ */ emotion_styled_base_browser_esm("div", true ? {
target: "e1krjpvb0"
} : 0)( true ? {
name: "1a3idx0",
styles: "color:var( --wp-components-color-foreground, currentColor )"
} : 0);
;// ./node_modules/@wordpress/components/build-module/theme/color-algorithms.js
k([names, a11y]);
function generateThemeVariables(inputs) {
validateInputs(inputs);
const generatedColors = {
...generateAccentDependentColors(inputs.accent),
...generateBackgroundDependentColors(inputs.background)
};
warnContrastIssues(checkContrasts(inputs, generatedColors));
return {
colors: generatedColors
};
}
function validateInputs(inputs) {
for (const [key, value] of Object.entries(inputs)) {
if (typeof value !== "undefined" && !w(value).isValid()) {
true ? external_wp_warning_default()(`wp.components.Theme: "${value}" is not a valid color value for the '${key}' prop.`) : 0;
}
}
}
function checkContrasts(inputs, outputs) {
const background = inputs.background || COLORS.white;
const accent = inputs.accent || "#3858e9";
const foreground = outputs.foreground || COLORS.gray[900];
const gray = outputs.gray || COLORS.gray;
return {
accent: w(background).isReadable(accent) ? void 0 : `The background color ("${background}") does not have sufficient contrast against the accent color ("${accent}").`,
foreground: w(background).isReadable(foreground) ? void 0 : `The background color provided ("${background}") does not have sufficient contrast against the standard foreground colors.`,
grays: w(background).contrast(gray[600]) >= 3 && w(background).contrast(gray[700]) >= 4.5 ? void 0 : `The background color provided ("${background}") cannot generate a set of grayscale foreground colors with sufficient contrast. Try adjusting the color to be lighter or darker.`
};
}
function warnContrastIssues(issues) {
for (const error of Object.values(issues)) {
if (error) {
true ? external_wp_warning_default()("wp.components.Theme: " + error) : 0;
}
}
}
function generateAccentDependentColors(accent) {
if (!accent) {
return {};
}
return {
accent,
accentDarker10: w(accent).darken(0.1).toHex(),
accentDarker20: w(accent).darken(0.2).toHex(),
accentInverted: getForegroundForColor(accent)
};
}
function generateBackgroundDependentColors(background) {
if (!background) {
return {};
}
const foreground = getForegroundForColor(background);
return {
background,
foreground,
foregroundInverted: getForegroundForColor(foreground),
gray: generateShades(background, foreground)
};
}
function getForegroundForColor(color) {
return w(color).isDark() ? COLORS.white : COLORS.gray[900];
}
function generateShades(background, foreground) {
const SHADES = {
100: 0.06,
200: 0.121,
300: 0.132,
400: 0.2,
600: 0.42,
700: 0.543,
800: 0.821
};
const limit = 0.884;
const direction = w(background).isDark() ? "lighten" : "darken";
const range = Math.abs(w(background).toHsl().l - w(foreground).toHsl().l) / 100;
const result = {};
Object.entries(SHADES).forEach(([key, value]) => {
result[parseInt(key)] = w(background)[direction](value / limit * range).toHex();
});
return result;
}
;// ./node_modules/@wordpress/components/build-module/theme/index.js
function Theme({
accent,
background,
className,
...props
}) {
const cx = useCx();
const classes = (0,external_wp_element_namespaceObject.useMemo)(() => cx(...colorVariables(generateThemeVariables({
accent,
background
})), className), [accent, background, className, cx]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(theme_styles_Wrapper, {
className: classes,
...props
});
}
var theme_default = Theme;
;// ./node_modules/@wordpress/components/build-module/tabs/context.js
const TabsContext = (0,external_wp_element_namespaceObject.createContext)(void 0);
TabsContext.displayName = "TabsContext";
const useTabsContext = () => (0,external_wp_element_namespaceObject.useContext)(TabsContext);
;// ./node_modules/@wordpress/components/build-module/tabs/styles.js
function tabs_styles_EMOTION_STRINGIFIED_CSS_ERROR_() {
return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
}
const StyledTabList = /* @__PURE__ */ emotion_styled_base_browser_esm(TabList, true ? {
target: "enfox0g4"
} : 0)("display:flex;align-items:stretch;overflow-x:auto;&[aria-orientation='vertical']{flex-direction:column;}:where( [aria-orientation='horizontal'] ){width:fit-content;}--direction-factor:1;--direction-start:left;--direction-end:right;--selected-start:var( --selected-left, 0 );&:dir( rtl ){--direction-factor:-1;--direction-start:right;--direction-end:left;--selected-start:var( --selected-right, 0 );}@media not ( prefers-reduced-motion ){&[data-indicator-animated]::before{transition-property:transform,border-radius,border-block;transition-duration:0.2s;transition-timing-function:ease-out;}}position:relative;&::before{content:'';position:absolute;pointer-events:none;transform-origin:var( --direction-start ) top;outline:2px solid transparent;outline-offset:-1px;}--antialiasing-factor:100;&[aria-orientation='horizontal']{--fade-width:4rem;--fade-gradient-base:transparent 0%,black var( --fade-width );--fade-gradient-composed:var( --fade-gradient-base ),black 60%,transparent 50%;&.is-overflowing-first{mask-image:linear-gradient(\n to var( --direction-end ),\n var( --fade-gradient-base )\n );}&.is-overflowing-last{mask-image:linear-gradient(\n to var( --direction-start ),\n var( --fade-gradient-base )\n );}&.is-overflowing-first.is-overflowing-last{mask-image:linear-gradient(\n to right,\n var( --fade-gradient-composed )\n ),linear-gradient( to left, var( --fade-gradient-composed ) );}&::before{bottom:0;height:0;width:calc( var( --antialiasing-factor ) * 1px );transform:translateX(\n calc(\n var( --selected-start ) * var( --direction-factor ) *\n 1px\n )\n ) scaleX(\n calc(\n var( --selected-width, 0 ) /\n var( --antialiasing-factor )\n )\n );border-bottom:var( --wp-admin-border-width-focus ) solid ", COLORS.theme.accent, ";}}&[aria-orientation='vertical']{&::before{border-radius:", config_values_default.radiusSmall, "/calc(\n ", config_values_default.radiusSmall, " /\n (\n var( --selected-height, 0 ) /\n var( --antialiasing-factor )\n )\n );top:0;left:0;width:100%;height:calc( var( --antialiasing-factor ) * 1px );transform:translateY( calc( var( --selected-top, 0 ) * 1px ) ) scaleY(\n calc(\n var( --selected-height, 0 ) /\n var( --antialiasing-factor )\n )\n );background-color:color-mix(\n in srgb,\n ", COLORS.theme.accent, ",\n transparent 96%\n );}&[data-select-on-move='true']:has(\n :is( :focus-visible, [data-focus-visible] )\n )::before{box-sizing:border-box;border:var( --wp-admin-border-width-focus ) solid ", COLORS.theme.accent, ";border-block-width:calc(\n var( --wp-admin-border-width-focus, 1px ) /\n (\n var( --selected-height, 0 ) /\n var( --antialiasing-factor )\n )\n );}}" + ( true ? "" : 0));
const styles_Tab = /* @__PURE__ */ emotion_styled_base_browser_esm(Tab, true ? {
target: "enfox0g3"
} : 0)("&{border-radius:0;background:transparent;border:none;box-shadow:none;flex:1 0 auto;white-space:nowrap;display:flex;align-items:center;cursor:pointer;line-height:1.2;font-weight:400;font-size:", font("default.fontSize"), ";color:", COLORS.theme.foreground, ";position:relative;&[aria-disabled='true']{cursor:default;color:", COLORS.ui.textDisabled, ";}&:not( [aria-disabled='true'] ):is( :hover, [data-focus-visible] ){color:", COLORS.theme.accent, ";}&:focus:not( :disabled ){box-shadow:none;outline:none;}&::after{position:absolute;pointer-events:none;outline:var( --wp-admin-border-width-focus ) solid ", COLORS.theme.accent, ";border-radius:", config_values_default.radiusSmall, ";opacity:0;@media not ( prefers-reduced-motion ){transition:opacity 0.1s linear;}}&[data-focus-visible]::after{opacity:1;}}[aria-orientation='horizontal'] &{padding-inline:", space(4), ";height:", space(12), ";scroll-margin:24px;&::after{content:'';inset:", space(3), ";}}[aria-orientation='vertical'] &{padding:", space(2), " ", space(3), ";min-height:", space(10), ";&[aria-selected='true']{color:", COLORS.theme.accent, ";fill:currentColor;}}[aria-orientation='vertical'][data-select-on-move='false'] &::after{content:'';inset:var( --wp-admin-border-width-focus );}" + ( true ? "" : 0));
const TabChildren = /* @__PURE__ */ emotion_styled_base_browser_esm("span", true ? {
target: "enfox0g2"
} : 0)( true ? {
name: "9at4z3",
styles: "flex-grow:1;display:flex;align-items:center;[aria-orientation='horizontal'] &{justify-content:center;}[aria-orientation='vertical'] &{justify-content:start;}"
} : 0);
const TabChevron = /* @__PURE__ */ emotion_styled_base_browser_esm(icon_icon_default, true ? {
target: "enfox0g1"
} : 0)("flex-shrink:0;margin-inline-end:", space(-1), ";[aria-orientation='horizontal'] &{display:none;}opacity:0;[role='tab']:is( [aria-selected='true'], [data-focus-visible], :hover ) &{opacity:1;}@media not ( prefers-reduced-motion ){[data-select-on-move='true'] [role='tab']:is( [aria-selected='true'], ) &{transition:opacity 0.15s 0.15s linear;}}&:dir( rtl ){rotate:180deg;}" + ( true ? "" : 0));
const styles_TabPanel = /* @__PURE__ */ emotion_styled_base_browser_esm(TabPanel, true ? {
target: "enfox0g0"
} : 0)("&:focus{box-shadow:none;outline:none;}&[data-focus-visible]{box-shadow:0 0 0 var( --wp-admin-border-width-focus ) ", COLORS.theme.accent, ";outline:2px solid transparent;outline-offset:0;}" + ( true ? "" : 0));
;// ./node_modules/@wordpress/components/build-module/tabs/tab.js
const tab_Tab = (0,external_wp_element_namespaceObject.forwardRef)(function Tab2({
children,
tabId,
disabled,
render,
...otherProps
}, ref) {
var _useTabsContext;
const {
store,
instanceId
} = (_useTabsContext = useTabsContext()) !== null && _useTabsContext !== void 0 ? _useTabsContext : {};
if (!store) {
true ? external_wp_warning_default()("`Tabs.Tab` must be wrapped in a `Tabs` component.") : 0;
return null;
}
const instancedTabId = `${instanceId}-${tabId}`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(styles_Tab, {
ref,
store,
id: instancedTabId,
disabled,
render,
...otherProps,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TabChildren, {
children
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TabChevron, {
icon: chevron_right_default
})]
});
});
;// ./node_modules/@wordpress/components/build-module/tabs/use-track-overflow.js
function useTrackOverflow(parent, children) {
const [first, setFirst] = (0,external_wp_element_namespaceObject.useState)(false);
const [last, setLast] = (0,external_wp_element_namespaceObject.useState)(false);
const [observer, setObserver] = (0,external_wp_element_namespaceObject.useState)();
const callback = (0,external_wp_compose_namespaceObject.useEvent)((entries) => {
for (const entry of entries) {
if (entry.target === children.first) {
setFirst(!entry.isIntersecting);
}
if (entry.target === children.last) {
setLast(!entry.isIntersecting);
}
}
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!parent || !window.IntersectionObserver) {
return;
}
const newObserver = new IntersectionObserver(callback, {
root: parent,
threshold: 0.9
});
setObserver(newObserver);
return () => newObserver.disconnect();
}, [callback, parent]);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!observer) {
return;
}
if (children.first) {
observer.observe(children.first);
}
if (children.last) {
observer.observe(children.last);
}
return () => {
if (children.first) {
observer.unobserve(children.first);
}
if (children.last) {
observer.unobserve(children.last);
}
};
}, [children.first, children.last, observer]);
return {
first,
last
};
}
;// ./node_modules/@wordpress/components/build-module/tabs/tablist.js
const DEFAULT_SCROLL_MARGIN = 24;
function useScrollRectIntoView(parent, rect, {
margin = DEFAULT_SCROLL_MARGIN
} = {}) {
(0,external_wp_element_namespaceObject.useLayoutEffect)(() => {
if (!parent || !rect) {
return;
}
const {
scrollLeft: parentScroll
} = parent;
const parentWidth = parent.getBoundingClientRect().width;
const {
left: childLeft,
width: childWidth
} = rect;
const parentRightEdge = parentScroll + parentWidth;
const childRightEdge = childLeft + childWidth;
const rightOverflow = childRightEdge + margin - parentRightEdge;
const leftOverflow = parentScroll - (childLeft - margin);
let scrollLeft = null;
if (leftOverflow > 0) {
scrollLeft = parentScroll - leftOverflow;
} else if (rightOverflow > 0) {
scrollLeft = parentScroll + rightOverflow;
}
if (scrollLeft !== null) {
parent.scroll?.({
left: scrollLeft
});
}
}, [margin, parent, rect]);
}
const tablist_TabList = (0,external_wp_element_namespaceObject.forwardRef)(function TabList2({
children,
...otherProps
}, ref) {
var _useTabsContext;
const {
store
} = (_useTabsContext = useTabsContext()) !== null && _useTabsContext !== void 0 ? _useTabsContext : {};
const selectedId = useStoreState(store, "selectedId");
const activeId = useStoreState(store, "activeId");
const selectOnMove = useStoreState(store, "selectOnMove");
const items = useStoreState(store, "items");
const [parent, setParent] = (0,external_wp_element_namespaceObject.useState)();
const refs = (0,external_wp_compose_namespaceObject.useMergeRefs)([ref, setParent]);
const selectedItem = store?.item(selectedId);
const renderedItems = useStoreState(store, "renderedItems");
const selectedItemIndex = renderedItems && selectedItem ? renderedItems.indexOf(selectedItem) : -1;
const selectedRect = useTrackElementOffsetRect(selectedItem?.element, [selectedItemIndex]);
const overflow = useTrackOverflow(parent, {
first: items?.at(0)?.element,
last: items?.at(-1)?.element
});
useAnimatedOffsetRect(parent, selectedRect, {
prefix: "selected",
dataAttribute: "indicator-animated",
transitionEndFilter: (event) => event.pseudoElement === "::before",
roundRect: true
});
useScrollRectIntoView(parent, selectedRect);
const onBlur = () => {
if (!selectOnMove) {
return;
}
if (selectedId !== activeId) {
store?.setActiveId(selectedId);
}
};
if (!store) {
true ? external_wp_warning_default()("`Tabs.TabList` must be wrapped in a `Tabs` component.") : 0;
return null;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(StyledTabList, {
ref: refs,
store,
render: (props) => {
var _props$tabIndex;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("div", {
...props,
// Fallback to -1 to prevent browsers from making the tablist
// tabbable when it is a scrolling container.
tabIndex: (_props$tabIndex = props.tabIndex) !== null && _props$tabIndex !== void 0 ? _props$tabIndex : -1
});
},
onBlur,
"data-select-on-move": selectOnMove ? "true" : "false",
...otherProps,
className: dist_clsx(overflow.first && "is-overflowing-first", overflow.last && "is-overflowing-last", otherProps.className),
children
});
});
;// ./node_modules/@wordpress/components/build-module/tabs/tabpanel.js
const tabpanel_TabPanel = (0,external_wp_element_namespaceObject.forwardRef)(function TabPanel2({
children,
tabId,
focusable = true,
...otherProps
}, ref) {
const context = useTabsContext();
const selectedId = useStoreState(context?.store, "selectedId");
if (!context) {
true ? external_wp_warning_default()("`Tabs.TabPanel` must be wrapped in a `Tabs` component.") : 0;
return null;
}
const {
store,
instanceId
} = context;
const instancedTabId = `${instanceId}-${tabId}`;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(styles_TabPanel, {
ref,
store,
id: `${instancedTabId}-view`,
tabId: instancedTabId,
focusable,
...otherProps,
children: selectedId === instancedTabId && children
});
});
;// ./node_modules/@wordpress/components/build-module/tabs/index.js
function externalToInternalTabId(externalId, instanceId) {
return externalId && `${instanceId}-${externalId}`;
}
function internalToExternalTabId(internalId, instanceId) {
return typeof internalId === "string" ? internalId.replace(`${instanceId}-`, "") : internalId;
}
const Tabs = Object.assign(function Tabs2({
selectOnMove = true,
defaultTabId,
orientation = "horizontal",
onSelect,
children,
selectedTabId,
activeTabId,
defaultActiveTabId,
onActiveTabIdChange
}) {
const instanceId = (0,external_wp_compose_namespaceObject.useInstanceId)(Tabs2, "tabs");
const store = useTabStore({
selectOnMove,
orientation,
defaultSelectedId: externalToInternalTabId(defaultTabId, instanceId),
setSelectedId: (newSelectedId) => {
onSelect?.(internalToExternalTabId(newSelectedId, instanceId));
},
selectedId: externalToInternalTabId(selectedTabId, instanceId),
defaultActiveId: externalToInternalTabId(defaultActiveTabId, instanceId),
setActiveId: (newActiveId) => {
onActiveTabIdChange?.(internalToExternalTabId(newActiveId, instanceId));
},
activeId: externalToInternalTabId(activeTabId, instanceId),
rtl: (0,external_wp_i18n_namespaceObject.isRTL)()
});
const {
items,
activeId
} = useStoreState(store);
const {
setActiveId
} = store;
(0,external_wp_element_namespaceObject.useEffect)(() => {
requestAnimationFrame(() => {
const focusedElement = items?.[0]?.element?.ownerDocument.activeElement;
if (!focusedElement || !items.some((item) => focusedElement === item.element)) {
return;
}
if (activeId !== focusedElement.id) {
setActiveId(focusedElement.id);
}
});
}, [activeId, items, setActiveId]);
const contextValue = (0,external_wp_element_namespaceObject.useMemo)(() => ({
store,
instanceId
}), [store, instanceId]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(TabsContext.Provider, {
value: contextValue,
children
});
}, {
/**
* Renders a single tab.
*
* The currently active tab receives default styling that can be
* overridden with CSS targeting `[aria-selected="true"]`.
*/
Tab: Object.assign(tab_Tab, {
displayName: "Tabs.Tab"
}),
/**
* A wrapper component for the `Tab` components.
*
* It is responsible for rendering the list of tabs.
*/
TabList: Object.assign(tablist_TabList, {
displayName: "Tabs.TabList"
}),
/**
* Renders the content to display for a single tab once that tab is selected.
*/
TabPanel: Object.assign(tabpanel_TabPanel, {
displayName: "Tabs.TabPanel"
}),
Context: Object.assign(TabsContext, {
displayName: "Tabs.Context"
})
});
;// external ["wp","privateApis"]
const external_wp_privateApis_namespaceObject = window["wp"]["privateApis"];
;// ./node_modules/@wordpress/components/build-module/lock-unlock.js
const {
lock,
unlock
} = (0,external_wp_privateApis_namespaceObject.__dangerousOptInToUnstableAPIsOnlyForCoreModules)("I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.", "@wordpress/components");
;// ./node_modules/@wordpress/icons/build-module/library/info.js
var info_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
external_wp_primitives_namespaceObject.Path,
{
fillRule: "evenodd",
clipRule: "evenodd",
d: "M5.5 12a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0ZM12 4a8 8 0 1 0 0 16 8 8 0 0 0 0-16Zm.75 4v1.5h-1.5V8h1.5Zm0 8v-5h-1.5v5h1.5Z"
}
) });
;// ./node_modules/@wordpress/icons/build-module/library/published.js
var published_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
external_wp_primitives_namespaceObject.Path,
{
fillRule: "evenodd",
clipRule: "evenodd",
d: "M12 18.5a6.5 6.5 0 1 1 0-13 6.5 6.5 0 0 1 0 13ZM4 12a8 8 0 1 1 16 0 8 8 0 0 1-16 0Zm11.53-1.47-1.06-1.06L11 12.94l-1.47-1.47-1.06 1.06L11 15.06l4.53-4.53Z"
}
) });
;// ./node_modules/@wordpress/icons/build-module/library/caution.js
var caution_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
external_wp_primitives_namespaceObject.Path,
{
fillRule: "evenodd",
clipRule: "evenodd",
d: "M5.5 12a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0ZM12 4a8 8 0 1 0 0 16 8 8 0 0 0 0-16Zm-.75 12v-1.5h1.5V16h-1.5Zm0-8v5h1.5V8h-1.5Z"
}
) });
;// ./node_modules/@wordpress/icons/build-module/library/error.js
var error_default = /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(external_wp_primitives_namespaceObject.SVG, { viewBox: "0 0 24 24", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(
external_wp_primitives_namespaceObject.Path,
{
fillRule: "evenodd",
clipRule: "evenodd",
d: "M12.218 5.377a.25.25 0 0 0-.436 0l-7.29 12.96a.25.25 0 0 0 .218.373h14.58a.25.25 0 0 0 .218-.372l-7.29-12.96Zm-1.743-.735c.669-1.19 2.381-1.19 3.05 0l7.29 12.96a1.75 1.75 0 0 1-1.525 2.608H4.71a1.75 1.75 0 0 1-1.525-2.608l7.29-12.96ZM12.75 17.46h-1.5v-1.5h1.5v1.5Zm-1.5-3h1.5v-5h-1.5v5Z"
}
) });
;// ./node_modules/@wordpress/components/build-module/badge/index.js
function contextBasedIcon(intent = "default") {
switch (intent) {
case "info":
return info_default;
case "success":
return published_default;
case "warning":
return caution_default;
case "error":
return error_default;
default:
return null;
}
}
function Badge({
className,
intent = "default",
children,
...props
}) {
const icon = contextBasedIcon(intent);
const hasIcon = !!icon;
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: dist_clsx("components-badge", className, {
[`is-${intent}`]: intent,
"has-icon": hasIcon
}),
...props,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("span", {
className: "components-badge__flex-wrapper",
children: [hasIcon && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
icon,
size: 16,
fill: "currentColor",
className: "components-badge__icon"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("span", {
className: "components-badge__content",
children
})]
})
});
}
var badge_default = Badge;
;// ./node_modules/@date-fns/tz/constants/index.js
/**
* The symbol to access the `TZDate`'s function to construct a new instance from
* the provided value. It helps date-fns to inherit the time zone.
*/
const constructFromSymbol = Symbol.for("constructDateFrom");
;// ./node_modules/@date-fns/tz/tzName/index.js
/**
* Time zone name format.
*/
/**
* The function returns the time zone name for the given date in the specified
* time zone.
*
* It uses the `Intl.DateTimeFormat` API and by default outputs the time zone
* name in a long format, e.g. "Pacific Standard Time" or
* "Singapore Standard Time".
*
* It is possible to specify the format as the third argument using one of the following options
*
* - "short": e.g. "EDT" or "GMT+8".
* - "long": e.g. "Eastern Daylight Time".
* - "shortGeneric": e.g. "ET" or "Singapore Time".
* - "longGeneric": e.g. "Eastern Time" or "Singapore Standard Time".
*
* These options correspond to TR35 tokens `z..zzz`, `zzzz`, `v`, and `vvvv` respectively: https://www.unicode.org/reports/tr35/tr35-dates.html#dfst-zone
*
* @param timeZone - Time zone name (IANA or UTC offset)
* @param date - Date object to get the time zone name for
* @param format - Optional format of the time zone name. Defaults to "long". Can be "short", "long", "shortGeneric", or "longGeneric".
*
* @returns Time zone name (e.g. "Singapore Standard Time")
*/
function tzName(timeZone, date, format = "long") {
return new Intl.DateTimeFormat("en-US", {
// Enforces engine to render the time. Without the option JavaScriptCore omits it.
hour: "numeric",
timeZone: timeZone,
timeZoneName: format
}).format(date).split(/\s/g) // Format.JS uses non-breaking spaces
.slice(2) // Skip the hour and AM/PM parts
.join(" ");
}
;// ./node_modules/@date-fns/tz/tzOffset/index.js
const offsetFormatCache = {};
const offsetCache = {};
/**
* The function extracts UTC offset in minutes from the given date in specified
* time zone.
*
* Unlike `Date.prototype.getTimezoneOffset`, this function returns the value
* mirrored to the sign of the offset in the time zone. For Asia/Singapore
* (UTC+8), `tzOffset` returns 480, while `getTimezoneOffset` returns -480.
*
* @param timeZone - Time zone name (IANA or UTC offset)
* @param date - Date to check the offset for
*
* @returns UTC offset in minutes
*/
function tzOffset_tzOffset(timeZone, date) {
try {
const format = offsetFormatCache[timeZone] ||= new Intl.DateTimeFormat("en-US", {
timeZone,
timeZoneName: "longOffset"
}).format;
const offsetStr = format(date).split("GMT")[1];
if (offsetStr in offsetCache) return offsetCache[offsetStr];
return calcOffset(offsetStr, offsetStr.split(":"));
} catch {
// Fallback to manual parsing if the runtime doesn't support ±HH:MM/±HHMM/±HH
// See: https://github.com/nodejs/node/issues/53419
if (timeZone in offsetCache) return offsetCache[timeZone];
const captures = timeZone?.match(offsetRe);
if (captures) return calcOffset(timeZone, captures.slice(1));
return NaN;
}
}
const offsetRe = /([+-]\d\d):?(\d\d)?/;
function calcOffset(cacheStr, values) {
const hours = +(values[0] || 0);
const minutes = +(values[1] || 0);
// Convert seconds to minutes by dividing by 60 to keep the function return in minutes.
const seconds = +(values[2] || 0) / 60;
return offsetCache[cacheStr] = hours * 60 + minutes > 0 ? hours * 60 + minutes + seconds : hours * 60 - minutes - seconds;
}
;// ./node_modules/@date-fns/tz/date/mini.js
class TZDateMini extends Date {
//#region static
constructor(...args) {
super();
if (args.length > 1 && typeof args[args.length - 1] === "string") {
this.timeZone = args.pop();
}
this.internal = new Date();
if (isNaN(tzOffset_tzOffset(this.timeZone, this))) {
this.setTime(NaN);
} else {
if (!args.length) {
this.setTime(Date.now());
} else if (typeof args[0] === "number" && (args.length === 1 || args.length === 2 && typeof args[1] !== "number")) {
this.setTime(args[0]);
} else if (typeof args[0] === "string") {
this.setTime(+new Date(args[0]));
} else if (args[0] instanceof Date) {
this.setTime(+args[0]);
} else {
this.setTime(+new Date(...args));
adjustToSystemTZ(this, NaN);
syncToInternal(this);
}
}
}
static tz(tz, ...args) {
return args.length ? new TZDateMini(...args, tz) : new TZDateMini(Date.now(), tz);
}
//#endregion
//#region time zone
withTimeZone(timeZone) {
return new TZDateMini(+this, timeZone);
}
getTimezoneOffset() {
const offset = -tzOffset_tzOffset(this.timeZone, this);
// Remove the seconds offset
// use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
return offset > 0 ? Math.floor(offset) : Math.ceil(offset);
}
//#endregion
//#region time
setTime(time) {
Date.prototype.setTime.apply(this, arguments);
syncToInternal(this);
return +this;
}
//#endregion
//#region date-fns integration
[Symbol.for("constructDateFrom")](date) {
return new TZDateMini(+new Date(date), this.timeZone);
}
//#endregion
}
// Assign getters and setters
const mini_re = /^(get|set)(?!UTC)/;
Object.getOwnPropertyNames(Date.prototype).forEach(method => {
if (!mini_re.test(method)) return;
const utcMethod = method.replace(mini_re, "$1UTC");
// Filter out methods without UTC counterparts
if (!TZDateMini.prototype[utcMethod]) return;
if (method.startsWith("get")) {
// Delegate to internal date's UTC method
TZDateMini.prototype[method] = function () {
return this.internal[utcMethod]();
};
} else {
// Assign regular setter
TZDateMini.prototype[method] = function () {
Date.prototype[utcMethod].apply(this.internal, arguments);
syncFromInternal(this);
return +this;
};
// Assign UTC setter
TZDateMini.prototype[utcMethod] = function () {
Date.prototype[utcMethod].apply(this, arguments);
syncToInternal(this);
return +this;
};
}
});
/**
* Function syncs time to internal date, applying the time zone offset.
*
* @param {Date} date - Date to sync
*/
function syncToInternal(date) {
date.internal.setTime(+date);
date.internal.setUTCSeconds(date.internal.getUTCSeconds() - Math.round(-tzOffset_tzOffset(date.timeZone, date) * 60));
}
/**
* Function syncs the internal date UTC values to the date. It allows to get
* accurate timestamp value.
*
* @param {Date} date - The date to sync
*/
function syncFromInternal(date) {
// First we transpose the internal values
Date.prototype.setFullYear.call(date, date.internal.getUTCFullYear(), date.internal.getUTCMonth(), date.internal.getUTCDate());
Date.prototype.setHours.call(date, date.internal.getUTCHours(), date.internal.getUTCMinutes(), date.internal.getUTCSeconds(), date.internal.getUTCMilliseconds());
// Now we have to adjust the date to the system time zone
adjustToSystemTZ(date);
}
/**
* Function adjusts the date to the system time zone. It uses the time zone
* differences to calculate the offset and adjust the date.
*
* @param {Date} date - Date to adjust
*/
function adjustToSystemTZ(date) {
// Save the time zone offset before all the adjustments
const baseOffset = tzOffset_tzOffset(date.timeZone, date);
// Remove the seconds offset
// use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
const offset = baseOffset > 0 ? Math.floor(baseOffset) : Math.ceil(baseOffset);
//#region System DST adjustment
// The biggest problem with using the system time zone is that when we create
// a date from internal values stored in UTC, the system time zone might end
// up on the DST hour:
//
// $ TZ=America/New_York node
// > new Date(2020, 2, 8, 1).toString()
// 'Sun Mar 08 2020 01:00:00 GMT-0500 (Eastern Standard Time)'
// > new Date(2020, 2, 8, 2).toString()
// 'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
// > new Date(2020, 2, 8, 3).toString()
// 'Sun Mar 08 2020 03:00:00 GMT-0400 (Eastern Daylight Time)'
// > new Date(2020, 2, 8, 4).toString()
// 'Sun Mar 08 2020 04:00:00 GMT-0400 (Eastern Daylight Time)'
//
// Here we get the same hour for both 2 and 3, because the system time zone
// has DST beginning at 8 March 2020, 2 a.m. and jumps to 3 a.m. So we have
// to adjust the internal date to reflect that.
//
// However we want to adjust only if that's the DST hour the change happenes,
// not the hour where DST moves to.
// We calculate the previous hour to see if the time zone offset has changed
// and we have landed on the DST hour.
const prevHour = new Date(+date);
// We use UTC methods here as we don't want to land on the same hour again
// in case of DST.
prevHour.setUTCHours(prevHour.getUTCHours() - 1);
// Calculate if we are on the system DST hour.
const systemOffset = -new Date(+date).getTimezoneOffset();
const prevHourSystemOffset = -new Date(+prevHour).getTimezoneOffset();
const systemDSTChange = systemOffset - prevHourSystemOffset;
// Detect the DST shift. System DST change will occur both on
const dstShift = Date.prototype.getHours.apply(date) !== date.internal.getUTCHours();
// Move the internal date when we are on the system DST hour.
if (systemDSTChange && dstShift) date.internal.setUTCMinutes(date.internal.getUTCMinutes() + systemDSTChange);
//#endregion
//#region System diff adjustment
// Now we need to adjust the date, since we just applied internal values.
// We need to calculate the difference between the system and date time zones
// and apply it to the date.
const offsetDiff = systemOffset - offset;
if (offsetDiff) Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetDiff);
//#endregion
//#region Seconds System diff adjustment
const systemDate = new Date(+date);
// Set the UTC seconds to 0 to isolate the timezone offset in seconds.
systemDate.setUTCSeconds(0);
// For negative systemOffset, invert the seconds.
const systemSecondsOffset = systemOffset > 0 ? systemDate.getSeconds() : (systemDate.getSeconds() - 60) % 60;
// Calculate the seconds offset based on the timezone offset.
const secondsOffset = Math.round(-(tzOffset_tzOffset(date.timeZone, date) * 60)) % 60;
if (secondsOffset || systemSecondsOffset) {
date.internal.setUTCSeconds(date.internal.getUTCSeconds() + secondsOffset);
Date.prototype.setUTCSeconds.call(date, Date.prototype.getUTCSeconds.call(date) + secondsOffset + systemSecondsOffset);
}
//#endregion
//#region Post-adjustment DST fix
const postBaseOffset = tzOffset_tzOffset(date.timeZone, date);
// Remove the seconds offset
// use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
const postOffset = postBaseOffset > 0 ? Math.floor(postBaseOffset) : Math.ceil(postBaseOffset);
const postSystemOffset = -new Date(+date).getTimezoneOffset();
const postOffsetDiff = postSystemOffset - postOffset;
const offsetChanged = postOffset !== offset;
const postDiff = postOffsetDiff - offsetDiff;
if (offsetChanged && postDiff) {
Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + postDiff);
// Now we need to check if got offset change during the post-adjustment.
// If so, we also need both dates to reflect that.
const newBaseOffset = tzOffset_tzOffset(date.timeZone, date);
// Remove the seconds offset
// use Math.floor for negative GMT timezones and Math.ceil for positive GMT timezones.
const newOffset = newBaseOffset > 0 ? Math.floor(newBaseOffset) : Math.ceil(newBaseOffset);
const offsetChange = postOffset - newOffset;
if (offsetChange) {
date.internal.setUTCMinutes(date.internal.getUTCMinutes() + offsetChange);
Date.prototype.setUTCMinutes.call(date, Date.prototype.getUTCMinutes.call(date) + offsetChange);
}
}
//#endregion
}
;// ./node_modules/@date-fns/tz/date/index.js
class date_TZDate extends TZDateMini {
//#region static
static tz(tz, ...args) {
return args.length ? new date_TZDate(...args, tz) : new date_TZDate(Date.now(), tz);
}
//#endregion
//#region representation
toISOString() {
const [sign, hours, minutes] = this.tzComponents();
const tz = `${sign}${hours}:${minutes}`;
return this.internal.toISOString().slice(0, -1) + tz;
}
toString() {
// "Tue Aug 13 2024 07:50:19 GMT+0800 (Singapore Standard Time)";
return `${this.toDateString()} ${this.toTimeString()}`;
}
toDateString() {
// toUTCString returns RFC 7231 ("Mon, 12 Aug 2024 23:36:08 GMT")
const [day, date, month, year] = this.internal.toUTCString().split(" ");
// "Tue Aug 13 2024"
return `${day?.slice(0, -1) /* Remove "," */} ${month} ${date} ${year}`;
}
toTimeString() {
// toUTCString returns RFC 7231 ("Mon, 12 Aug 2024 23:36:08 GMT")
const time = this.internal.toUTCString().split(" ")[4];
const [sign, hours, minutes] = this.tzComponents();
// "07:42:23 GMT+0800 (Singapore Standard Time)"
return `${time} GMT${sign}${hours}${minutes} (${tzName(this.timeZone, this)})`;
}
toLocaleString(locales, options) {
return Date.prototype.toLocaleString.call(this, locales, {
...options,
timeZone: options?.timeZone || this.timeZone
});
}
toLocaleDateString(locales, options) {
return Date.prototype.toLocaleDateString.call(this, locales, {
...options,
timeZone: options?.timeZone || this.timeZone
});
}
toLocaleTimeString(locales, options) {
return Date.prototype.toLocaleTimeString.call(this, locales, {
...options,
timeZone: options?.timeZone || this.timeZone
});
}
//#endregion
//#region private
tzComponents() {
const offset = this.getTimezoneOffset();
const sign = offset > 0 ? "-" : "+";
const hours = String(Math.floor(Math.abs(offset) / 60)).padStart(2, "0");
const minutes = String(Math.abs(offset) % 60).padStart(2, "0");
return [sign, hours, minutes];
}
//#endregion
withTimeZone(timeZone) {
return new date_TZDate(+this, timeZone);
}
//#region date-fns integration
[Symbol.for("constructDateFrom")](date) {
return new date_TZDate(+new Date(date), this.timeZone);
}
//#endregion
}
;// ./node_modules/@date-fns/tz/tz/index.js
/**
* The function creates accepts a time zone and returns a function that creates
* a new `TZDate` instance in the time zone from the provided value. Use it to
* provide the context for the date-fns functions, via the `in` option.
*
* @param timeZone - Time zone name (IANA or UTC offset)
*
* @returns Function that creates a new `TZDate` instance in the time zone
*/
const tz = timeZone => value => TZDate.tz(timeZone, +new Date(value));
;// ./node_modules/@date-fns/tz/tzScan/index.js
/**
* Time interval.
*/
/**
* Time zone change record.
*/
/**
* The function scans the time zone for changes in the given interval.
*
* @param timeZone - Time zone name (IANA or UTC offset)
* @param interval - Time interval to scan for changes
*
* @returns Array of time zone changes
*/
function tzScan(timeZone, interval) {
const changes = [];
const monthDate = new Date(interval.start);
monthDate.setUTCSeconds(0, 0);
const endDate = new Date(interval.end);
endDate.setUTCSeconds(0, 0);
const endMonthTime = +endDate;
let lastOffset = tzOffset(timeZone, monthDate);
while (+monthDate < endMonthTime) {
// Month forward
monthDate.setUTCMonth(monthDate.getUTCMonth() + 1);
// Find the month where the offset changes
const offset = tzOffset(timeZone, monthDate);
if (offset != lastOffset) {
// Rewind a month back to find the day where the offset changes
const dayDate = new Date(monthDate);
dayDate.setUTCMonth(dayDate.getUTCMonth() - 1);
const endDayTime = +monthDate;
lastOffset = tzOffset(timeZone, dayDate);
while (+dayDate < endDayTime) {
// Day forward
dayDate.setUTCDate(dayDate.getUTCDate() + 1);
// Find the day where the offset changes
const offset = tzOffset(timeZone, dayDate);
if (offset != lastOffset) {
// Rewind a day back to find the time where the offset changes
const hourDate = new Date(dayDate);
hourDate.setUTCDate(hourDate.getUTCDate() - 1);
const endHourTime = +dayDate;
lastOffset = tzOffset(timeZone, hourDate);
while (+hourDate < endHourTime) {
// Hour forward
hourDate.setUTCHours(hourDate.getUTCHours() + 1);
// Find the hour where the offset changes
const hourOffset = tzOffset(timeZone, hourDate);
if (hourOffset !== lastOffset) {
changes.push({
date: new Date(hourDate),
change: hourOffset - lastOffset,
offset: hourOffset
});
}
lastOffset = hourOffset;
}
}
lastOffset = offset;
}
}
lastOffset = offset;
}
return changes;
}
;// ./node_modules/@date-fns/tz/index.js
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/en-US/_lib/formatDistance.js
const formatDistance_formatDistanceLocale = {
lessThanXSeconds: {
one: "less than a second",
other: "less than {{count}} seconds",
},
xSeconds: {
one: "1 second",
other: "{{count}} seconds",
},
halfAMinute: "half a minute",
lessThanXMinutes: {
one: "less than a minute",
other: "less than {{count}} minutes",
},
xMinutes: {
one: "1 minute",
other: "{{count}} minutes",
},
aboutXHours: {
one: "about 1 hour",
other: "about {{count}} hours",
},
xHours: {
one: "1 hour",
other: "{{count}} hours",
},
xDays: {
one: "1 day",
other: "{{count}} days",
},
aboutXWeeks: {
one: "about 1 week",
other: "about {{count}} weeks",
},
xWeeks: {
one: "1 week",
other: "{{count}} weeks",
},
aboutXMonths: {
one: "about 1 month",
other: "about {{count}} months",
},
xMonths: {
one: "1 month",
other: "{{count}} months",
},
aboutXYears: {
one: "about 1 year",
other: "about {{count}} years",
},
xYears: {
one: "1 year",
other: "{{count}} years",
},
overXYears: {
one: "over 1 year",
other: "over {{count}} years",
},
almostXYears: {
one: "almost 1 year",
other: "almost {{count}} years",
},
};
const formatDistance_formatDistance = (token, count, options) => {
let result;
const tokenValue = formatDistance_formatDistanceLocale[token];
if (typeof tokenValue === "string") {
result = tokenValue;
} else if (count === 1) {
result = tokenValue.one;
} else {
result = tokenValue.other.replace("{{count}}", count.toString());
}
if (options?.addSuffix) {
if (options.comparison && options.comparison > 0) {
return "in " + result;
} else {
return result + " ago";
}
}
return result;
};
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/_lib/buildFormatLongFn.js
function buildFormatLongFn_buildFormatLongFn(args) {
return (options = {}) => {
// TODO: Remove String()
const width = options.width ? String(options.width) : args.defaultWidth;
const format = args.formats[width] || args.formats[args.defaultWidth];
return format;
};
}
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/en-US/_lib/formatLong.js
const formatLong_dateFormats = {
full: "EEEE, MMMM do, y",
long: "MMMM do, y",
medium: "MMM d, y",
short: "MM/dd/yyyy",
};
const formatLong_timeFormats = {
full: "h:mm:ss a zzzz",
long: "h:mm:ss a z",
medium: "h:mm:ss a",
short: "h:mm a",
};
const formatLong_dateTimeFormats = {
full: "{{date}} 'at' {{time}}",
long: "{{date}} 'at' {{time}}",
medium: "{{date}}, {{time}}",
short: "{{date}}, {{time}}",
};
const formatLong_formatLong = {
date: buildFormatLongFn_buildFormatLongFn({
formats: formatLong_dateFormats,
defaultWidth: "full",
}),
time: buildFormatLongFn_buildFormatLongFn({
formats: formatLong_timeFormats,
defaultWidth: "full",
}),
dateTime: buildFormatLongFn_buildFormatLongFn({
formats: formatLong_dateTimeFormats,
defaultWidth: "full",
}),
};
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/en-US/_lib/formatRelative.js
const formatRelative_formatRelativeLocale = {
lastWeek: "'last' eeee 'at' p",
yesterday: "'yesterday at' p",
today: "'today at' p",
tomorrow: "'tomorrow at' p",
nextWeek: "eeee 'at' p",
other: "P",
};
const formatRelative_formatRelative = (token, _date, _baseDate, _options) =>
formatRelative_formatRelativeLocale[token];
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/_lib/buildLocalizeFn.js
/**
* The localize function argument callback which allows to convert raw value to
* the actual type.
*
* @param value - The value to convert
*
* @returns The converted value
*/
/**
* The map of localized values for each width.
*/
/**
* The index type of the locale unit value. It types conversion of units of
* values that don't start at 0 (i.e. quarters).
*/
/**
* Converts the unit value to the tuple of values.
*/
/**
* The tuple of localized era values. The first element represents BC,
* the second element represents AD.
*/
/**
* The tuple of localized quarter values. The first element represents Q1.
*/
/**
* The tuple of localized day values. The first element represents Sunday.
*/
/**
* The tuple of localized month values. The first element represents January.
*/
function buildLocalizeFn_buildLocalizeFn(args) {
return (value, options) => {
const context = options?.context ? String(options.context) : "standalone";
let valuesArray;
if (context === "formatting" && args.formattingValues) {
const defaultWidth = args.defaultFormattingWidth || args.defaultWidth;
const width = options?.width ? String(options.width) : defaultWidth;
valuesArray =
args.formattingValues[width] || args.formattingValues[defaultWidth];
} else {
const defaultWidth = args.defaultWidth;
const width = options?.width ? String(options.width) : args.defaultWidth;
valuesArray = args.values[width] || args.values[defaultWidth];
}
const index = args.argumentCallback ? args.argumentCallback(value) : value;
// @ts-expect-error - For some reason TypeScript just don't want to match it, no matter how hard we try. I challenge you to try to remove it!
return valuesArray[index];
};
}
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/en-US/_lib/localize.js
const localize_eraValues = {
narrow: ["B", "A"],
abbreviated: ["BC", "AD"],
wide: ["Before Christ", "Anno Domini"],
};
const localize_quarterValues = {
narrow: ["1", "2", "3", "4"],
abbreviated: ["Q1", "Q2", "Q3", "Q4"],
wide: ["1st quarter", "2nd quarter", "3rd quarter", "4th quarter"],
};
// Note: in English, the names of days of the week and months are capitalized.
// If you are making a new locale based on this one, check if the same is true for the language you're working on.
// Generally, formatted dates should look like they are in the middle of a sentence,
// e.g. in Spanish language the weekdays and months should be in the lowercase.
const localize_monthValues = {
narrow: ["J", "F", "M", "A", "M", "J", "J", "A", "S", "O", "N", "D"],
abbreviated: [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec",
],
wide: [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
],
};
const localize_dayValues = {
narrow: ["S", "M", "T", "W", "T", "F", "S"],
short: ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"],
abbreviated: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
wide: [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
],
};
const localize_dayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
},
};
const localize_formattingDayPeriodValues = {
narrow: {
am: "a",
pm: "p",
midnight: "mi",
noon: "n",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
abbreviated: {
am: "AM",
pm: "PM",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
wide: {
am: "a.m.",
pm: "p.m.",
midnight: "midnight",
noon: "noon",
morning: "in the morning",
afternoon: "in the afternoon",
evening: "in the evening",
night: "at night",
},
};
const localize_ordinalNumber = (dirtyNumber, _options) => {
const number = Number(dirtyNumber);
// If ordinal numbers depend on context, for example,
// if they are different for different grammatical genders,
// use `options.unit`.
//
// `unit` can be 'year', 'quarter', 'month', 'week', 'date', 'dayOfYear',
// 'day', 'hour', 'minute', 'second'.
const rem100 = number % 100;
if (rem100 > 20 || rem100 < 10) {
switch (rem100 % 10) {
case 1:
return number + "st";
case 2:
return number + "nd";
case 3:
return number + "rd";
}
}
return number + "th";
};
const localize_localize = {
ordinalNumber: localize_ordinalNumber,
era: buildLocalizeFn_buildLocalizeFn({
values: localize_eraValues,
defaultWidth: "wide",
}),
quarter: buildLocalizeFn_buildLocalizeFn({
values: localize_quarterValues,
defaultWidth: "wide",
argumentCallback: (quarter) => quarter - 1,
}),
month: buildLocalizeFn_buildLocalizeFn({
values: localize_monthValues,
defaultWidth: "wide",
}),
day: buildLocalizeFn_buildLocalizeFn({
values: localize_dayValues,
defaultWidth: "wide",
}),
dayPeriod: buildLocalizeFn_buildLocalizeFn({
values: localize_dayPeriodValues,
defaultWidth: "wide",
formattingValues: localize_formattingDayPeriodValues,
defaultFormattingWidth: "wide",
}),
};
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/_lib/buildMatchFn.js
function buildMatchFn_buildMatchFn(args) {
return (string, options = {}) => {
const width = options.width;
const matchPattern =
(width && args.matchPatterns[width]) ||
args.matchPatterns[args.defaultMatchWidth];
const matchResult = string.match(matchPattern);
if (!matchResult) {
return null;
}
const matchedString = matchResult[0];
const parsePatterns =
(width && args.parsePatterns[width]) ||
args.parsePatterns[args.defaultParseWidth];
const key = Array.isArray(parsePatterns)
? buildMatchFn_findIndex(parsePatterns, (pattern) => pattern.test(matchedString))
: // [TODO] -- I challenge you to fix the type
buildMatchFn_findKey(parsePatterns, (pattern) => pattern.test(matchedString));
let value;
value = args.valueCallback ? args.valueCallback(key) : key;
value = options.valueCallback
? // [TODO] -- I challenge you to fix the type
options.valueCallback(value)
: value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
function buildMatchFn_findKey(object, predicate) {
for (const key in object) {
if (
Object.prototype.hasOwnProperty.call(object, key) &&
predicate(object[key])
) {
return key;
}
}
return undefined;
}
function buildMatchFn_findIndex(array, predicate) {
for (let key = 0; key < array.length; key++) {
if (predicate(array[key])) {
return key;
}
}
return undefined;
}
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/_lib/buildMatchPatternFn.js
function buildMatchPatternFn_buildMatchPatternFn(args) {
return (string, options = {}) => {
const matchResult = string.match(args.matchPattern);
if (!matchResult) return null;
const matchedString = matchResult[0];
const parseResult = string.match(args.parsePattern);
if (!parseResult) return null;
let value = args.valueCallback
? args.valueCallback(parseResult[0])
: parseResult[0];
// [TODO] I challenge you to fix the type
value = options.valueCallback ? options.valueCallback(value) : value;
const rest = string.slice(matchedString.length);
return { value, rest };
};
}
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/en-US/_lib/match.js
const match_matchOrdinalNumberPattern = /^(\d+)(th|st|nd|rd)?/i;
const match_parseOrdinalNumberPattern = /\d+/i;
const match_matchEraPatterns = {
narrow: /^(b|a)/i,
abbreviated: /^(b\.?\s?c\.?|b\.?\s?c\.?\s?e\.?|a\.?\s?d\.?|c\.?\s?e\.?)/i,
wide: /^(before christ|before common era|anno domini|common era)/i,
};
const match_parseEraPatterns = {
any: [/^b/i, /^(a|c)/i],
};
const match_matchQuarterPatterns = {
narrow: /^[1234]/i,
abbreviated: /^q[1234]/i,
wide: /^[1234](th|st|nd|rd)? quarter/i,
};
const match_parseQuarterPatterns = {
any: [/1/i, /2/i, /3/i, /4/i],
};
const match_matchMonthPatterns = {
narrow: /^[jfmasond]/i,
abbreviated: /^(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i,
wide: /^(january|february|march|april|may|june|july|august|september|october|november|december)/i,
};
const match_parseMonthPatterns = {
narrow: [
/^j/i,
/^f/i,
/^m/i,
/^a/i,
/^m/i,
/^j/i,
/^j/i,
/^a/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i,
],
any: [
/^ja/i,
/^f/i,
/^mar/i,
/^ap/i,
/^may/i,
/^jun/i,
/^jul/i,
/^au/i,
/^s/i,
/^o/i,
/^n/i,
/^d/i,
],
};
const match_matchDayPatterns = {
narrow: /^[smtwf]/i,
short: /^(su|mo|tu|we|th|fr|sa)/i,
abbreviated: /^(sun|mon|tue|wed|thu|fri|sat)/i,
wide: /^(sunday|monday|tuesday|wednesday|thursday|friday|saturday)/i,
};
const match_parseDayPatterns = {
narrow: [/^s/i, /^m/i, /^t/i, /^w/i, /^t/i, /^f/i, /^s/i],
any: [/^su/i, /^m/i, /^tu/i, /^w/i, /^th/i, /^f/i, /^sa/i],
};
const match_matchDayPeriodPatterns = {
narrow: /^(a|p|mi|n|(in the|at) (morning|afternoon|evening|night))/i,
any: /^([ap]\.?\s?m\.?|midnight|noon|(in the|at) (morning|afternoon|evening|night))/i,
};
const match_parseDayPeriodPatterns = {
any: {
am: /^a/i,
pm: /^p/i,
midnight: /^mi/i,
noon: /^no/i,
morning: /morning/i,
afternoon: /afternoon/i,
evening: /evening/i,
night: /night/i,
},
};
const _lib_match_match = {
ordinalNumber: buildMatchPatternFn_buildMatchPatternFn({
matchPattern: match_matchOrdinalNumberPattern,
parsePattern: match_parseOrdinalNumberPattern,
valueCallback: (value) => parseInt(value, 10),
}),
era: buildMatchFn_buildMatchFn({
matchPatterns: match_matchEraPatterns,
defaultMatchWidth: "wide",
parsePatterns: match_parseEraPatterns,
defaultParseWidth: "any",
}),
quarter: buildMatchFn_buildMatchFn({
matchPatterns: match_matchQuarterPatterns,
defaultMatchWidth: "wide",
parsePatterns: match_parseQuarterPatterns,
defaultParseWidth: "any",
valueCallback: (index) => index + 1,
}),
month: buildMatchFn_buildMatchFn({
matchPatterns: match_matchMonthPatterns,
defaultMatchWidth: "wide",
parsePatterns: match_parseMonthPatterns,
defaultParseWidth: "any",
}),
day: buildMatchFn_buildMatchFn({
matchPatterns: match_matchDayPatterns,
defaultMatchWidth: "wide",
parsePatterns: match_parseDayPatterns,
defaultParseWidth: "any",
}),
dayPeriod: buildMatchFn_buildMatchFn({
matchPatterns: match_matchDayPeriodPatterns,
defaultMatchWidth: "any",
parsePatterns: match_parseDayPeriodPatterns,
defaultParseWidth: "any",
}),
};
;// ./node_modules/react-day-picker/node_modules/date-fns/locale/en-US.js
/**
* @category Locales
* @summary English locale (United States).
* @language English
* @iso-639-2 eng
* @author Sasha Koss [@kossnocorp](https://github.com/kossnocorp)
* @author Lesha Koss [@leshakoss](https://github.com/leshakoss)
*/
const en_US_enUS = {
code: "en-US",
formatDistance: formatDistance_formatDistance,
formatLong: formatLong_formatLong,
formatRelative: formatRelative_formatRelative,
localize: localize_localize,
match: _lib_match_match,
options: {
weekStartsOn: 0 /* Sunday */,
firstWeekContainsDate: 1,
},
};
// Fallback for modularized imports:
/* harmony default export */ const locale_en_US = ((/* unused pure expression or super */ null && (en_US_enUS)));
;// ./node_modules/react-day-picker/node_modules/date-fns/constants.js
/**
* @module constants
* @summary Useful constants
* @description
* Collection of useful date constants.
*
* The constants could be imported from `date-fns/constants`:
*
* ```ts
* import { maxTime, minTime } from "./constants/date-fns/constants";
*
* function isAllowedTime(time) {
* return time <= maxTime && time >= minTime;
* }
* ```
*/
/**
* @constant
* @name daysInWeek
* @summary Days in 1 week.
*/
const constants_daysInWeek = 7;
/**
* @constant
* @name daysInYear
* @summary Days in 1 year.
*
* @description
* How many days in a year.
*
* One years equals 365.2425 days according to the formula:
*
* > Leap year occurs every 4 years, except for years that are divisible by 100 and not divisible by 400.
* > 1 mean year = (365+1/4-1/100+1/400) days = 365.2425 days
*/
const constants_daysInYear = 365.2425;
/**
* @constant
* @name maxTime
* @summary Maximum allowed time.
*
* @example
* import { maxTime } from "./constants/date-fns/constants";
*
* const isValid = 8640000000000001 <= maxTime;
* //=> false
*
* new Date(8640000000000001);
* //=> Invalid Date
*/
const constants_maxTime = Math.pow(10, 8) * 24 * 60 * 60 * 1000;
/**
* @constant
* @name minTime
* @summary Minimum allowed time.
*
* @example
* import { minTime } from "./constants/date-fns/constants";
*
* const isValid = -8640000000000001 >= minTime;
* //=> false
*
* new Date(-8640000000000001)
* //=> Invalid Date
*/
const constants_minTime = -constants_maxTime;
/**
* @constant
* @name millisecondsInWeek
* @summary Milliseconds in 1 week.
*/
const constants_millisecondsInWeek = 604800000;
/**
* @constant
* @name millisecondsInDay
* @summary Milliseconds in 1 day.
*/
const constants_millisecondsInDay = 86400000;
/**
* @constant
* @name millisecondsInMinute
* @summary Milliseconds in 1 minute
*/
const constants_millisecondsInMinute = 60000;
/**
* @constant
* @name millisecondsInHour
* @summary Milliseconds in 1 hour
*/
const constants_millisecondsInHour = 3600000;
/**
* @constant
* @name millisecondsInSecond
* @summary Milliseconds in 1 second
*/
const constants_millisecondsInSecond = 1000;
/**
* @constant
* @name minutesInYear
* @summary Minutes in 1 year.
*/
const constants_minutesInYear = 525600;
/**
* @constant
* @name minutesInMonth
* @summary Minutes in 1 month.
*/
const constants_minutesInMonth = 43200;
/**
* @constant
* @name minutesInDay
* @summary Minutes in 1 day.
*/
const constants_minutesInDay = 1440;
/**
* @constant
* @name minutesInHour
* @summary Minutes in 1 hour.
*/
const constants_minutesInHour = 60;
/**
* @constant
* @name monthsInQuarter
* @summary Months in 1 quarter.
*/
const constants_monthsInQuarter = 3;
/**
* @constant
* @name monthsInYear
* @summary Months in 1 year.
*/
const constants_monthsInYear = 12;
/**
* @constant
* @name quartersInYear
* @summary Quarters in 1 year
*/
const constants_quartersInYear = 4;
/**
* @constant
* @name secondsInHour
* @summary Seconds in 1 hour.
*/
const constants_secondsInHour = 3600;
/**
* @constant
* @name secondsInMinute
* @summary Seconds in 1 minute.
*/
const constants_secondsInMinute = 60;
/**
* @constant
* @name secondsInDay
* @summary Seconds in 1 day.
*/
const constants_secondsInDay = constants_secondsInHour * 24;
/**
* @constant
* @name secondsInWeek
* @summary Seconds in 1 week.
*/
const constants_secondsInWeek = constants_secondsInDay * 7;
/**
* @constant
* @name secondsInYear
* @summary Seconds in 1 year.
*/
const constants_secondsInYear = constants_secondsInDay * constants_daysInYear;
/**
* @constant
* @name secondsInMonth
* @summary Seconds in 1 month
*/
const constants_secondsInMonth = constants_secondsInYear / 12;
/**
* @constant
* @name secondsInQuarter
* @summary Seconds in 1 quarter.
*/
const constants_secondsInQuarter = constants_secondsInMonth * 3;
/**
* @constant
* @name constructFromSymbol
* @summary Symbol enabling Date extensions to inherit properties from the reference date.
*
* The symbol is used to enable the `constructFrom` function to construct a date
* using a reference date and a value. It allows to transfer extra properties
* from the reference date to the new date. It's useful for extensions like
* [`TZDate`](https://github.com/date-fns/tz) that accept a time zone as
* a constructor argument.
*/
const constants_constructFromSymbol = Symbol.for("constructDateFrom");
;// ./node_modules/react-day-picker/node_modules/date-fns/constructFrom.js
/**
* @name constructFrom
* @category Generic Helpers
* @summary Constructs a date using the reference date and the value
*
* @description
* The function constructs a new date using the constructor from the reference
* date and the given value. It helps to build generic functions that accept
* date extensions.
*
* It defaults to `Date` if the passed reference date is a number or a string.
*
* Starting from v3.7.0, it allows to construct a date using `[Symbol.for("constructDateFrom")]`
* enabling to transfer extra properties from the reference date to the new date.
* It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
* that accept a time zone as a constructor argument.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
*
* @param date - The reference date to take constructor from
* @param value - The value to create the date
*
* @returns Date initialized using the given date and value
*
* @example
* import { constructFrom } from "./constructFrom/date-fns";
*
* // A function that clones a date preserving the original type
* function cloneDate<DateType extends Date>(date: DateType): DateType {
* return constructFrom(
* date, // Use constructor from the given date
* date.getTime() // Use the date value to create a new date
* );
* }
*/
function constructFrom_constructFrom(date, value) {
if (typeof date === "function") return date(value);
if (date && typeof date === "object" && constants_constructFromSymbol in date)
return date[constants_constructFromSymbol](value);
if (date instanceof Date) return new date.constructor(value);
return new Date(value);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_constructFrom = ((/* unused pure expression or super */ null && (constructFrom_constructFrom)));
;// ./node_modules/react-day-picker/node_modules/date-fns/toDate.js
/**
* @name toDate
* @category Common Helpers
* @summary Convert the given argument to an instance of Date.
*
* @description
* Convert the given argument to an instance of Date.
*
* If the argument is an instance of Date, the function returns its clone.
*
* If the argument is a number, it is treated as a timestamp.
*
* If the argument is none of the above, the function returns Invalid Date.
*
* Starting from v3.7.0, it clones a date using `[Symbol.for("constructDateFrom")]`
* enabling to transfer extra properties from the reference date to the new date.
* It's useful for extensions like [`TZDate`](https://github.com/date-fns/tz)
* that accept a time zone as a constructor argument.
*
* **Note**: *all* Date arguments passed to any *date-fns* function is processed by `toDate`.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param argument - The value to convert
*
* @returns The parsed date in the local time zone
*
* @example
* // Clone the date:
* const result = toDate(new Date(2014, 1, 11, 11, 30, 30))
* //=> Tue Feb 11 2014 11:30:30
*
* @example
* // Convert the timestamp to date:
* const result = toDate(1392098430000)
* //=> Tue Feb 11 2014 11:30:30
*/
function toDate_toDate(argument, context) {
// [TODO] Get rid of `toDate` or `constructFrom`?
return constructFrom_constructFrom(context || argument, argument);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_toDate = ((/* unused pure expression or super */ null && (toDate_toDate)));
;// ./node_modules/react-day-picker/node_modules/date-fns/addDays.js
/**
* The {@link addDays} function options.
*/
/**
* @name addDays
* @category Day Helpers
* @summary Add the specified number of days to the given date.
*
* @description
* Add the specified number of days to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param amount - The amount of days to be added.
* @param options - An object with options
*
* @returns The new date with the days added
*
* @example
* // Add 10 days to 1 September 2014:
* const result = addDays(new Date(2014, 8, 1), 10)
* //=> Thu Sep 11 2014 00:00:00
*/
function addDays_addDays(date, amount, options) {
const _date = toDate_toDate(date, options?.in);
if (isNaN(amount)) return constructFrom_constructFrom(options?.in || date, NaN);
// If 0 days, no-op to avoid changing times in the hour before end of DST
if (!amount) return _date;
_date.setDate(_date.getDate() + amount);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_addDays = ((/* unused pure expression or super */ null && (addDays_addDays)));
;// ./node_modules/react-day-picker/node_modules/date-fns/addMonths.js
/**
* The {@link addMonths} function options.
*/
/**
* @name addMonths
* @category Month Helpers
* @summary Add the specified number of months to the given date.
*
* @description
* Add the specified number of months to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param amount - The amount of months to be added.
* @param options - The options object
*
* @returns The new date with the months added
*
* @example
* // Add 5 months to 1 September 2014:
* const result = addMonths(new Date(2014, 8, 1), 5)
* //=> Sun Feb 01 2015 00:00:00
*
* // Add one month to 30 January 2023:
* const result = addMonths(new Date(2023, 0, 30), 1)
* //=> Tue Feb 28 2023 00:00:00
*/
function addMonths_addMonths(date, amount, options) {
const _date = toDate_toDate(date, options?.in);
if (isNaN(amount)) return constructFrom_constructFrom(options?.in || date, NaN);
if (!amount) {
// If 0 months, no-op to avoid changing times in the hour before end of DST
return _date;
}
const dayOfMonth = _date.getDate();
// The JS Date object supports date math by accepting out-of-bounds values for
// month, day, etc. For example, new Date(2020, 0, 0) returns 31 Dec 2019 and
// new Date(2020, 13, 1) returns 1 Feb 2021. This is *almost* the behavior we
// want except that dates will wrap around the end of a month, meaning that
// new Date(2020, 13, 31) will return 3 Mar 2021 not 28 Feb 2021 as desired. So
// we'll default to the end of the desired month by adding 1 to the desired
// month and using a date of 0 to back up one day to the end of the desired
// month.
const endOfDesiredMonth = constructFrom_constructFrom(options?.in || date, _date.getTime());
endOfDesiredMonth.setMonth(_date.getMonth() + amount + 1, 0);
const daysInMonth = endOfDesiredMonth.getDate();
if (dayOfMonth >= daysInMonth) {
// If we're already at the end of the month, then this is the correct date
// and we're done.
return endOfDesiredMonth;
} else {
// Otherwise, we now know that setting the original day-of-month value won't
// cause an overflow, so set the desired day-of-month. Note that we can't
// just set the date of `endOfDesiredMonth` because that object may have had
// its time changed in the unusual case where where a DST transition was on
// the last day of the month and its local time was in the hour skipped or
// repeated next to a DST transition. So we use `date` instead which is
// guaranteed to still have the original time.
_date.setFullYear(
endOfDesiredMonth.getFullYear(),
endOfDesiredMonth.getMonth(),
dayOfMonth,
);
return _date;
}
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_addMonths = ((/* unused pure expression or super */ null && (addMonths_addMonths)));
;// ./node_modules/react-day-picker/node_modules/date-fns/addWeeks.js
/**
* The {@link addWeeks} function options.
*/
/**
* @name addWeeks
* @category Week Helpers
* @summary Add the specified number of weeks to the given date.
*
* @description
* Add the specified number of weeks to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param amount - The amount of weeks to be added.
* @param options - An object with options
*
* @returns The new date with the weeks added
*
* @example
* // Add 4 weeks to 1 September 2014:
* const result = addWeeks(new Date(2014, 8, 1), 4)
* //=> Mon Sep 29 2014 00:00:00
*/
function addWeeks_addWeeks(date, amount, options) {
return addDays_addDays(date, amount * 7, options);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_addWeeks = ((/* unused pure expression or super */ null && (addWeeks_addWeeks)));
;// ./node_modules/react-day-picker/node_modules/date-fns/addYears.js
/**
* The {@link addYears} function options.
*/
/**
* @name addYears
* @category Year Helpers
* @summary Add the specified number of years to the given date.
*
* @description
* Add the specified number of years to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type.
*
* @param date - The date to be changed
* @param amount - The amount of years to be added.
* @param options - The options
*
* @returns The new date with the years added
*
* @example
* // Add 5 years to 1 September 2014:
* const result = addYears(new Date(2014, 8, 1), 5)
* //=> Sun Sep 01 2019 00:00:00
*/
function addYears_addYears(date, amount, options) {
return addMonths_addMonths(date, amount * 12, options);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_addYears = ((/* unused pure expression or super */ null && (addYears_addYears)));
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds.js
/**
* Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.
* They usually appear for dates that denote time before the timezones were introduced
* (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891
* and GMT+01:00:00 after that date)
*
* Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,
* which would lead to incorrect calculations.
*
* This function returns the timezone offset in milliseconds that takes seconds in account.
*/
function getTimezoneOffsetInMilliseconds_getTimezoneOffsetInMilliseconds(date) {
const _date = toDate_toDate(date);
const utcDate = new Date(
Date.UTC(
_date.getFullYear(),
_date.getMonth(),
_date.getDate(),
_date.getHours(),
_date.getMinutes(),
_date.getSeconds(),
_date.getMilliseconds(),
),
);
utcDate.setUTCFullYear(_date.getFullYear());
return +date - +utcDate;
}
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/normalizeDates.js
function normalizeDates(context, ...dates) {
const normalize = constructFrom_constructFrom.bind(
null,
context || dates.find((date) => typeof date === "object"),
);
return dates.map(normalize);
}
;// ./node_modules/react-day-picker/node_modules/date-fns/startOfDay.js
/**
* The {@link startOfDay} function options.
*/
/**
* @name startOfDay
* @category Day Helpers
* @summary Return the start of a day for the given date.
*
* @description
* Return the start of a day for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - The options
*
* @returns The start of a day
*
* @example
* // The start of a day for 2 September 2014 11:55:00:
* const result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))
* //=> Tue Sep 02 2014 00:00:00
*/
function startOfDay_startOfDay(date, options) {
const _date = toDate_toDate(date, options?.in);
_date.setHours(0, 0, 0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_startOfDay = ((/* unused pure expression or super */ null && (startOfDay_startOfDay)));
;// ./node_modules/react-day-picker/node_modules/date-fns/differenceInCalendarDays.js
/**
* The {@link differenceInCalendarDays} function options.
*/
/**
* @name differenceInCalendarDays
* @category Day Helpers
* @summary Get the number of calendar days between the given dates.
*
* @description
* Get the number of calendar days between the given dates. This means that the times are removed
* from the dates and then the difference in days is calculated.
*
* @param laterDate - The later date
* @param earlierDate - The earlier date
* @param options - The options object
*
* @returns The number of calendar days
*
* @example
* // How many calendar days are between
* // 2 July 2011 23:00:00 and 2 July 2012 00:00:00?
* const result = differenceInCalendarDays(
* new Date(2012, 6, 2, 0, 0),
* new Date(2011, 6, 2, 23, 0)
* )
* //=> 366
* // How many calendar days are between
* // 2 July 2011 23:59:00 and 3 July 2011 00:01:00?
* const result = differenceInCalendarDays(
* new Date(2011, 6, 3, 0, 1),
* new Date(2011, 6, 2, 23, 59)
* )
* //=> 1
*/
function differenceInCalendarDays_differenceInCalendarDays(laterDate, earlierDate, options) {
const [laterDate_, earlierDate_] = normalizeDates(
options?.in,
laterDate,
earlierDate,
);
const laterStartOfDay = startOfDay_startOfDay(laterDate_);
const earlierStartOfDay = startOfDay_startOfDay(earlierDate_);
const laterTimestamp =
+laterStartOfDay - getTimezoneOffsetInMilliseconds_getTimezoneOffsetInMilliseconds(laterStartOfDay);
const earlierTimestamp =
+earlierStartOfDay - getTimezoneOffsetInMilliseconds_getTimezoneOffsetInMilliseconds(earlierStartOfDay);
// Round the number of days to the nearest integer because the number of
// milliseconds in a day is not constant (e.g. it's different in the week of
// the daylight saving time clock shift).
return Math.round((laterTimestamp - earlierTimestamp) / constants_millisecondsInDay);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_differenceInCalendarDays = ((/* unused pure expression or super */ null && (differenceInCalendarDays_differenceInCalendarDays)));
;// ./node_modules/react-day-picker/node_modules/date-fns/differenceInCalendarMonths.js
/**
* The {@link differenceInCalendarMonths} function options.
*/
/**
* @name differenceInCalendarMonths
* @category Month Helpers
* @summary Get the number of calendar months between the given dates.
*
* @description
* Get the number of calendar months between the given dates.
*
* @param laterDate - The later date
* @param earlierDate - The earlier date
* @param options - An object with options
*
* @returns The number of calendar months
*
* @example
* // How many calendar months are between 31 January 2014 and 1 September 2014?
* const result = differenceInCalendarMonths(
* new Date(2014, 8, 1),
* new Date(2014, 0, 31)
* )
* //=> 8
*/
function differenceInCalendarMonths(laterDate, earlierDate, options) {
const [laterDate_, earlierDate_] = normalizeDates(
options?.in,
laterDate,
earlierDate,
);
const yearsDiff = laterDate_.getFullYear() - earlierDate_.getFullYear();
const monthsDiff = laterDate_.getMonth() - earlierDate_.getMonth();
return yearsDiff * 12 + monthsDiff;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_differenceInCalendarMonths = ((/* unused pure expression or super */ null && (differenceInCalendarMonths)));
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/normalizeInterval.js
function normalizeInterval(context, interval) {
const [start, end] = normalizeDates(context, interval.start, interval.end);
return { start, end };
}
;// ./node_modules/react-day-picker/node_modules/date-fns/eachMonthOfInterval.js
/**
* The {@link eachMonthOfInterval} function options.
*/
/**
* The {@link eachMonthOfInterval} function result type. It resolves the proper data type.
*/
/**
* @name eachMonthOfInterval
* @category Interval Helpers
* @summary Return the array of months within the specified time interval.
*
* @description
* Return the array of months within the specified time interval.
*
* @typeParam IntervalType - Interval type.
* @typeParam Options - Options type.
*
* @param interval - The interval.
* @param options - An object with options.
*
* @returns The array with starts of months from the month of the interval start to the month of the interval end
*
* @example
* // Each month between 6 February 2014 and 10 August 2014:
* const result = eachMonthOfInterval({
* start: new Date(2014, 1, 6),
* end: new Date(2014, 7, 10)
* })
* //=> [
* // Sat Feb 01 2014 00:00:00,
* // Sat Mar 01 2014 00:00:00,
* // Tue Apr 01 2014 00:00:00,
* // Thu May 01 2014 00:00:00,
* // Sun Jun 01 2014 00:00:00,
* // Tue Jul 01 2014 00:00:00,
* // Fri Aug 01 2014 00:00:00
* // ]
*/
function eachMonthOfInterval_eachMonthOfInterval(interval, options) {
const { start, end } = normalizeInterval(options?.in, interval);
let reversed = +start > +end;
const endTime = reversed ? +start : +end;
const date = reversed ? end : start;
date.setHours(0, 0, 0, 0);
date.setDate(1);
let step = options?.step ?? 1;
if (!step) return [];
if (step < 0) {
step = -step;
reversed = !reversed;
}
const dates = [];
while (+date <= endTime) {
dates.push(constructFrom_constructFrom(start, date));
date.setMonth(date.getMonth() + step);
}
return reversed ? dates.reverse() : dates;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_eachMonthOfInterval = ((/* unused pure expression or super */ null && (eachMonthOfInterval_eachMonthOfInterval)));
;// ./node_modules/react-day-picker/node_modules/date-fns/eachYearOfInterval.js
/**
* The {@link eachYearOfInterval} function options.
*/
/**
* The {@link eachYearOfInterval} function result type. It resolves the proper data type.
* It uses the first argument date object type, starting from the date argument,
* then the start interval date, and finally the end interval date. If
* a context function is passed, it uses the context function return type.
*/
/**
* @name eachYearOfInterval
* @category Interval Helpers
* @summary Return the array of yearly timestamps within the specified time interval.
*
* @description
* Return the array of yearly timestamps within the specified time interval.
*
* @typeParam IntervalType - Interval type.
* @typeParam Options - Options type.
*
* @param interval - The interval.
* @param options - An object with options.
*
* @returns The array with starts of yearly timestamps from the month of the interval start to the month of the interval end
*
* @example
* // Each year between 6 February 2014 and 10 August 2017:
* const result = eachYearOfInterval({
* start: new Date(2014, 1, 6),
* end: new Date(2017, 7, 10)
* })
* //=> [
* // Wed Jan 01 2014 00:00:00,
* // Thu Jan 01 2015 00:00:00,
* // Fri Jan 01 2016 00:00:00,
* // Sun Jan 01 2017 00:00:00
* // ]
*/
function eachYearOfInterval(interval, options) {
const { start, end } = normalizeInterval(options?.in, interval);
let reversed = +start > +end;
const endTime = reversed ? +start : +end;
const date = reversed ? end : start;
date.setHours(0, 0, 0, 0);
date.setMonth(0, 1);
let step = options?.step ?? 1;
if (!step) return [];
if (step < 0) {
step = -step;
reversed = !reversed;
}
const dates = [];
while (+date <= endTime) {
dates.push(constructFrom_constructFrom(start, date));
date.setFullYear(date.getFullYear() + step);
}
return reversed ? dates.reverse() : dates;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_eachYearOfInterval = ((/* unused pure expression or super */ null && (eachYearOfInterval)));
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/defaultOptions.js
let _lib_defaultOptions_defaultOptions = {};
function defaultOptions_getDefaultOptions() {
return _lib_defaultOptions_defaultOptions;
}
function defaultOptions_setDefaultOptions(newOptions) {
_lib_defaultOptions_defaultOptions = newOptions;
}
;// ./node_modules/react-day-picker/node_modules/date-fns/endOfWeek.js
/**
* The {@link endOfWeek} function options.
*/
/**
* @name endOfWeek
* @category Week Helpers
* @summary Return the end of a week for the given date.
*
* @description
* Return the end of a week for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The end of a week
*
* @example
* // The end of a week for 2 September 2014 11:55:00:
* const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0))
* //=> Sat Sep 06 2014 23:59:59.999
*
* @example
* // If the week starts on Monday, the end of the week for 2 September 2014 11:55:00:
* const result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
* //=> Sun Sep 07 2014 23:59:59.999
*/
function endOfWeek_endOfWeek(date, options) {
const defaultOptions = defaultOptions_getDefaultOptions();
const weekStartsOn =
options?.weekStartsOn ??
options?.locale?.options?.weekStartsOn ??
defaultOptions.weekStartsOn ??
defaultOptions.locale?.options?.weekStartsOn ??
0;
const _date = toDate_toDate(date, options?.in);
const day = _date.getDay();
const diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn);
_date.setDate(_date.getDate() + diff);
_date.setHours(23, 59, 59, 999);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_endOfWeek = ((/* unused pure expression or super */ null && (endOfWeek_endOfWeek)));
;// ./node_modules/react-day-picker/node_modules/date-fns/endOfISOWeek.js
/**
* The {@link endOfISOWeek} function options.
*/
/**
* @name endOfISOWeek
* @category ISO Week Helpers
* @summary Return the end of an ISO week for the given date.
*
* @description
* Return the end of an ISO week for the given date.
* The result will be in the local timezone.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The end of an ISO week
*
* @example
* // The end of an ISO week for 2 September 2014 11:55:00:
* const result = endOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))
* //=> Sun Sep 07 2014 23:59:59.999
*/
function endOfISOWeek(date, options) {
return endOfWeek_endOfWeek(date, { ...options, weekStartsOn: 1 });
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_endOfISOWeek = ((/* unused pure expression or super */ null && (endOfISOWeek)));
;// ./node_modules/react-day-picker/node_modules/date-fns/endOfMonth.js
/**
* The {@link endOfMonth} function options.
*/
/**
* @name endOfMonth
* @category Month Helpers
* @summary Return the end of a month for the given date.
*
* @description
* Return the end of a month for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The end of a month
*
* @example
* // The end of a month for 2 September 2014 11:55:00:
* const result = endOfMonth(new Date(2014, 8, 2, 11, 55, 0))
* //=> Tue Sep 30 2014 23:59:59.999
*/
function endOfMonth_endOfMonth(date, options) {
const _date = toDate_toDate(date, options?.in);
const month = _date.getMonth();
_date.setFullYear(_date.getFullYear(), month + 1, 0);
_date.setHours(23, 59, 59, 999);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_endOfMonth = ((/* unused pure expression or super */ null && (endOfMonth_endOfMonth)));
;// ./node_modules/react-day-picker/node_modules/date-fns/endOfYear.js
/**
* The {@link endOfYear} function options.
*/
/**
* @name endOfYear
* @category Year Helpers
* @summary Return the end of a year for the given date.
*
* @description
* Return the end of a year for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - The options
*
* @returns The end of a year
*
* @example
* // The end of a year for 2 September 2014 11:55:00:
* const result = endOfYear(new Date(2014, 8, 2, 11, 55, 0))
* //=> Wed Dec 31 2014 23:59:59.999
*/
function endOfYear(date, options) {
const _date = toDate_toDate(date, options?.in);
const year = _date.getFullYear();
_date.setFullYear(year + 1, 0, 0);
_date.setHours(23, 59, 59, 999);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_endOfYear = ((/* unused pure expression or super */ null && (endOfYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/startOfYear.js
/**
* The {@link startOfYear} function options.
*/
/**
* @name startOfYear
* @category Year Helpers
* @summary Return the start of a year for the given date.
*
* @description
* Return the start of a year for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - The options
*
* @returns The start of a year
*
* @example
* // The start of a year for 2 September 2014 11:55:00:
* const result = startOfYear(new Date(2014, 8, 2, 11, 55, 00))
* //=> Wed Jan 01 2014 00:00:00
*/
function startOfYear_startOfYear(date, options) {
const date_ = toDate_toDate(date, options?.in);
date_.setFullYear(date_.getFullYear(), 0, 1);
date_.setHours(0, 0, 0, 0);
return date_;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_startOfYear = ((/* unused pure expression or super */ null && (startOfYear_startOfYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getDayOfYear.js
/**
* The {@link getDayOfYear} function options.
*/
/**
* @name getDayOfYear
* @category Day Helpers
* @summary Get the day of the year of the given date.
*
* @description
* Get the day of the year of the given date.
*
* @param date - The given date
* @param options - The options
*
* @returns The day of year
*
* @example
* // Which day of the year is 2 July 2014?
* const result = getDayOfYear(new Date(2014, 6, 2))
* //=> 183
*/
function getDayOfYear_getDayOfYear(date, options) {
const _date = toDate_toDate(date, options?.in);
const diff = differenceInCalendarDays_differenceInCalendarDays(_date, startOfYear_startOfYear(_date));
const dayOfYear = diff + 1;
return dayOfYear;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_getDayOfYear = ((/* unused pure expression or super */ null && (getDayOfYear_getDayOfYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/startOfWeek.js
/**
* The {@link startOfWeek} function options.
*/
/**
* @name startOfWeek
* @category Week Helpers
* @summary Return the start of a week for the given date.
*
* @description
* Return the start of a week for the given date.
* The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The start of a week
*
* @example
* // The start of a week for 2 September 2014 11:55:00:
* const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))
* //=> Sun Aug 31 2014 00:00:00
*
* @example
* // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:
* const result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), { weekStartsOn: 1 })
* //=> Mon Sep 01 2014 00:00:00
*/
function startOfWeek_startOfWeek(date, options) {
const defaultOptions = defaultOptions_getDefaultOptions();
const weekStartsOn =
options?.weekStartsOn ??
options?.locale?.options?.weekStartsOn ??
defaultOptions.weekStartsOn ??
defaultOptions.locale?.options?.weekStartsOn ??
0;
const _date = toDate_toDate(date, options?.in);
const day = _date.getDay();
const diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn;
_date.setDate(_date.getDate() - diff);
_date.setHours(0, 0, 0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_startOfWeek = ((/* unused pure expression or super */ null && (startOfWeek_startOfWeek)));
;// ./node_modules/react-day-picker/node_modules/date-fns/startOfISOWeek.js
/**
* The {@link startOfISOWeek} function options.
*/
/**
* @name startOfISOWeek
* @category ISO Week Helpers
* @summary Return the start of an ISO week for the given date.
*
* @description
* Return the start of an ISO week for the given date.
* The result will be in the local timezone.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The start of an ISO week
*
* @example
* // The start of an ISO week for 2 September 2014 11:55:00:
* const result = startOfISOWeek(new Date(2014, 8, 2, 11, 55, 0))
* //=> Mon Sep 01 2014 00:00:00
*/
function startOfISOWeek_startOfISOWeek(date, options) {
return startOfWeek_startOfWeek(date, { ...options, weekStartsOn: 1 });
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_startOfISOWeek = ((/* unused pure expression or super */ null && (startOfISOWeek_startOfISOWeek)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getISOWeekYear.js
/**
* The {@link getISOWeekYear} function options.
*/
/**
* @name getISOWeekYear
* @category ISO Week-Numbering Year Helpers
* @summary Get the ISO week-numbering year of the given date.
*
* @description
* Get the ISO week-numbering year of the given date,
* which always starts 3 days before the year's first Thursday.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @param date - The given date
*
* @returns The ISO week-numbering year
*
* @example
* // Which ISO-week numbering year is 2 January 2005?
* const result = getISOWeekYear(new Date(2005, 0, 2))
* //=> 2004
*/
function getISOWeekYear_getISOWeekYear(date, options) {
const _date = toDate_toDate(date, options?.in);
const year = _date.getFullYear();
const fourthOfJanuaryOfNextYear = constructFrom_constructFrom(_date, 0);
fourthOfJanuaryOfNextYear.setFullYear(year + 1, 0, 4);
fourthOfJanuaryOfNextYear.setHours(0, 0, 0, 0);
const startOfNextYear = startOfISOWeek_startOfISOWeek(fourthOfJanuaryOfNextYear);
const fourthOfJanuaryOfThisYear = constructFrom_constructFrom(_date, 0);
fourthOfJanuaryOfThisYear.setFullYear(year, 0, 4);
fourthOfJanuaryOfThisYear.setHours(0, 0, 0, 0);
const startOfThisYear = startOfISOWeek_startOfISOWeek(fourthOfJanuaryOfThisYear);
if (_date.getTime() >= startOfNextYear.getTime()) {
return year + 1;
} else if (_date.getTime() >= startOfThisYear.getTime()) {
return year;
} else {
return year - 1;
}
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_getISOWeekYear = ((/* unused pure expression or super */ null && (getISOWeekYear_getISOWeekYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/startOfISOWeekYear.js
/**
* The {@link startOfISOWeekYear} function options.
*/
/**
* @name startOfISOWeekYear
* @category ISO Week-Numbering Year Helpers
* @summary Return the start of an ISO week-numbering year for the given date.
*
* @description
* Return the start of an ISO week-numbering year,
* which always starts 3 days before the year's first Thursday.
* The result will be in the local timezone.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The start of an ISO week-numbering year
*
* @example
* // The start of an ISO week-numbering year for 2 July 2005:
* const result = startOfISOWeekYear(new Date(2005, 6, 2))
* //=> Mon Jan 03 2005 00:00:00
*/
function startOfISOWeekYear_startOfISOWeekYear(date, options) {
const year = getISOWeekYear_getISOWeekYear(date, options);
const fourthOfJanuary = constructFrom_constructFrom(options?.in || date, 0);
fourthOfJanuary.setFullYear(year, 0, 4);
fourthOfJanuary.setHours(0, 0, 0, 0);
return startOfISOWeek_startOfISOWeek(fourthOfJanuary);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_startOfISOWeekYear = ((/* unused pure expression or super */ null && (startOfISOWeekYear_startOfISOWeekYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getISOWeek.js
/**
* The {@link getISOWeek} function options.
*/
/**
* @name getISOWeek
* @category ISO Week Helpers
* @summary Get the ISO week of the given date.
*
* @description
* Get the ISO week of the given date.
*
* ISO week-numbering year: http://en.wikipedia.org/wiki/ISO_week_date
*
* @param date - The given date
* @param options - The options
*
* @returns The ISO week
*
* @example
* // Which week of the ISO-week numbering year is 2 January 2005?
* const result = getISOWeek(new Date(2005, 0, 2))
* //=> 53
*/
function getISOWeek_getISOWeek(date, options) {
const _date = toDate_toDate(date, options?.in);
const diff = +startOfISOWeek_startOfISOWeek(_date) - +startOfISOWeekYear_startOfISOWeekYear(_date);
// Round the number of weeks to the nearest integer because the number of
// milliseconds in a week is not constant (e.g. it's different in the week of
// the daylight saving time clock shift).
return Math.round(diff / constants_millisecondsInWeek) + 1;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_getISOWeek = ((/* unused pure expression or super */ null && (getISOWeek_getISOWeek)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getWeekYear.js
/**
* The {@link getWeekYear} function options.
*/
/**
* @name getWeekYear
* @category Week-Numbering Year Helpers
* @summary Get the local week-numbering year of the given date.
*
* @description
* Get the local week-numbering year of the given date.
* The exact calculation depends on the values of
* `options.weekStartsOn` (which is the index of the first day of the week)
* and `options.firstWeekContainsDate` (which is the day of January, which is always in
* the first week of the week-numbering year)
*
* Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
*
* @param date - The given date
* @param options - An object with options.
*
* @returns The local week-numbering year
*
* @example
* // Which week numbering year is 26 December 2004 with the default settings?
* const result = getWeekYear(new Date(2004, 11, 26))
* //=> 2005
*
* @example
* // Which week numbering year is 26 December 2004 if week starts on Saturday?
* const result = getWeekYear(new Date(2004, 11, 26), { weekStartsOn: 6 })
* //=> 2004
*
* @example
* // Which week numbering year is 26 December 2004 if the first week contains 4 January?
* const result = getWeekYear(new Date(2004, 11, 26), { firstWeekContainsDate: 4 })
* //=> 2004
*/
function getWeekYear_getWeekYear(date, options) {
const _date = toDate_toDate(date, options?.in);
const year = _date.getFullYear();
const defaultOptions = defaultOptions_getDefaultOptions();
const firstWeekContainsDate =
options?.firstWeekContainsDate ??
options?.locale?.options?.firstWeekContainsDate ??
defaultOptions.firstWeekContainsDate ??
defaultOptions.locale?.options?.firstWeekContainsDate ??
1;
const firstWeekOfNextYear = constructFrom_constructFrom(options?.in || date, 0);
firstWeekOfNextYear.setFullYear(year + 1, 0, firstWeekContainsDate);
firstWeekOfNextYear.setHours(0, 0, 0, 0);
const startOfNextYear = startOfWeek_startOfWeek(firstWeekOfNextYear, options);
const firstWeekOfThisYear = constructFrom_constructFrom(options?.in || date, 0);
firstWeekOfThisYear.setFullYear(year, 0, firstWeekContainsDate);
firstWeekOfThisYear.setHours(0, 0, 0, 0);
const startOfThisYear = startOfWeek_startOfWeek(firstWeekOfThisYear, options);
if (+_date >= +startOfNextYear) {
return year + 1;
} else if (+_date >= +startOfThisYear) {
return year;
} else {
return year - 1;
}
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_getWeekYear = ((/* unused pure expression or super */ null && (getWeekYear_getWeekYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/startOfWeekYear.js
/**
* The {@link startOfWeekYear} function options.
*/
/**
* @name startOfWeekYear
* @category Week-Numbering Year Helpers
* @summary Return the start of a local week-numbering year for the given date.
*
* @description
* Return the start of a local week-numbering year.
* The exact calculation depends on the values of
* `options.weekStartsOn` (which is the index of the first day of the week)
* and `options.firstWeekContainsDate` (which is the day of January, which is always in
* the first week of the week-numbering year)
*
* Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The start of a week-numbering year
*
* @example
* // The start of an a week-numbering year for 2 July 2005 with default settings:
* const result = startOfWeekYear(new Date(2005, 6, 2))
* //=> Sun Dec 26 2004 00:00:00
*
* @example
* // The start of a week-numbering year for 2 July 2005
* // if Monday is the first day of week
* // and 4 January is always in the first week of the year:
* const result = startOfWeekYear(new Date(2005, 6, 2), {
* weekStartsOn: 1,
* firstWeekContainsDate: 4
* })
* //=> Mon Jan 03 2005 00:00:00
*/
function startOfWeekYear_startOfWeekYear(date, options) {
const defaultOptions = defaultOptions_getDefaultOptions();
const firstWeekContainsDate =
options?.firstWeekContainsDate ??
options?.locale?.options?.firstWeekContainsDate ??
defaultOptions.firstWeekContainsDate ??
defaultOptions.locale?.options?.firstWeekContainsDate ??
1;
const year = getWeekYear_getWeekYear(date, options);
const firstWeek = constructFrom_constructFrom(options?.in || date, 0);
firstWeek.setFullYear(year, 0, firstWeekContainsDate);
firstWeek.setHours(0, 0, 0, 0);
const _date = startOfWeek_startOfWeek(firstWeek, options);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_startOfWeekYear = ((/* unused pure expression or super */ null && (startOfWeekYear_startOfWeekYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getWeek.js
/**
* The {@link getWeek} function options.
*/
/**
* @name getWeek
* @category Week Helpers
* @summary Get the local week index of the given date.
*
* @description
* Get the local week index of the given date.
* The exact calculation depends on the values of
* `options.weekStartsOn` (which is the index of the first day of the week)
* and `options.firstWeekContainsDate` (which is the day of January, which is always in
* the first week of the week-numbering year)
*
* Week numbering: https://en.wikipedia.org/wiki/Week#The_ISO_week_date_system
*
* @param date - The given date
* @param options - An object with options
*
* @returns The week
*
* @example
* // Which week of the local week numbering year is 2 January 2005 with default options?
* const result = getWeek(new Date(2005, 0, 2))
* //=> 2
*
* @example
* // Which week of the local week numbering year is 2 January 2005,
* // if Monday is the first day of the week,
* // and the first week of the year always contains 4 January?
* const result = getWeek(new Date(2005, 0, 2), {
* weekStartsOn: 1,
* firstWeekContainsDate: 4
* })
* //=> 53
*/
function getWeek_getWeek(date, options) {
const _date = toDate_toDate(date, options?.in);
const diff = +startOfWeek_startOfWeek(_date, options) - +startOfWeekYear_startOfWeekYear(_date, options);
// Round the number of weeks to the nearest integer because the number of
// milliseconds in a week is not constant (e.g. it's different in the week of
// the daylight saving time clock shift).
return Math.round(diff / constants_millisecondsInWeek) + 1;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_getWeek = ((/* unused pure expression or super */ null && (getWeek_getWeek)));
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/addLeadingZeros.js
function addLeadingZeros_addLeadingZeros(number, targetLength) {
const sign = number < 0 ? "-" : "";
const output = Math.abs(number).toString().padStart(targetLength, "0");
return sign + output;
}
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/format/lightFormatters.js
/*
* | | Unit | | Unit |
* |-----|--------------------------------|-----|--------------------------------|
* | a | AM, PM | A* | |
* | d | Day of month | D | |
* | h | Hour [1-12] | H | Hour [0-23] |
* | m | Minute | M | Month |
* | s | Second | S | Fraction of second |
* | y | Year (abs) | Y | |
*
* Letters marked by * are not implemented but reserved by Unicode standard.
*/
const lightFormatters_lightFormatters = {
// Year
y(date, token) {
// From http://www.unicode.org/reports/tr35/tr35-31/tr35-dates.html#Date_Format_tokens
// | Year | y | yy | yyy | yyyy | yyyyy |
// |----------|-------|----|-------|-------|-------|
// | AD 1 | 1 | 01 | 001 | 0001 | 00001 |
// | AD 12 | 12 | 12 | 012 | 0012 | 00012 |
// | AD 123 | 123 | 23 | 123 | 0123 | 00123 |
// | AD 1234 | 1234 | 34 | 1234 | 1234 | 01234 |
// | AD 12345 | 12345 | 45 | 12345 | 12345 | 12345 |
const signedYear = date.getFullYear();
// Returns 1 for 1 BC (which is year 0 in JavaScript)
const year = signedYear > 0 ? signedYear : 1 - signedYear;
return addLeadingZeros_addLeadingZeros(token === "yy" ? year % 100 : year, token.length);
},
// Month
M(date, token) {
const month = date.getMonth();
return token === "M" ? String(month + 1) : addLeadingZeros_addLeadingZeros(month + 1, 2);
},
// Day of the month
d(date, token) {
return addLeadingZeros_addLeadingZeros(date.getDate(), token.length);
},
// AM or PM
a(date, token) {
const dayPeriodEnumValue = date.getHours() / 12 >= 1 ? "pm" : "am";
switch (token) {
case "a":
case "aa":
return dayPeriodEnumValue.toUpperCase();
case "aaa":
return dayPeriodEnumValue;
case "aaaaa":
return dayPeriodEnumValue[0];
case "aaaa":
default:
return dayPeriodEnumValue === "am" ? "a.m." : "p.m.";
}
},
// Hour [1-12]
h(date, token) {
return addLeadingZeros_addLeadingZeros(date.getHours() % 12 || 12, token.length);
},
// Hour [0-23]
H(date, token) {
return addLeadingZeros_addLeadingZeros(date.getHours(), token.length);
},
// Minute
m(date, token) {
return addLeadingZeros_addLeadingZeros(date.getMinutes(), token.length);
},
// Second
s(date, token) {
return addLeadingZeros_addLeadingZeros(date.getSeconds(), token.length);
},
// Fraction of second
S(date, token) {
const numberOfDigits = token.length;
const milliseconds = date.getMilliseconds();
const fractionalSeconds = Math.trunc(
milliseconds * Math.pow(10, numberOfDigits - 3),
);
return addLeadingZeros_addLeadingZeros(fractionalSeconds, token.length);
},
};
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/format/formatters.js
const formatters_dayPeriodEnum = {
am: "am",
pm: "pm",
midnight: "midnight",
noon: "noon",
morning: "morning",
afternoon: "afternoon",
evening: "evening",
night: "night",
};
/*
* | | Unit | | Unit |
* |-----|--------------------------------|-----|--------------------------------|
* | a | AM, PM | A* | Milliseconds in day |
* | b | AM, PM, noon, midnight | B | Flexible day period |
* | c | Stand-alone local day of week | C* | Localized hour w/ day period |
* | d | Day of month | D | Day of year |
* | e | Local day of week | E | Day of week |
* | f | | F* | Day of week in month |
* | g* | Modified Julian day | G | Era |
* | h | Hour [1-12] | H | Hour [0-23] |
* | i! | ISO day of week | I! | ISO week of year |
* | j* | Localized hour w/ day period | J* | Localized hour w/o day period |
* | k | Hour [1-24] | K | Hour [0-11] |
* | l* | (deprecated) | L | Stand-alone month |
* | m | Minute | M | Month |
* | n | | N | |
* | o! | Ordinal number modifier | O | Timezone (GMT) |
* | p! | Long localized time | P! | Long localized date |
* | q | Stand-alone quarter | Q | Quarter |
* | r* | Related Gregorian year | R! | ISO week-numbering year |
* | s | Second | S | Fraction of second |
* | t! | Seconds timestamp | T! | Milliseconds timestamp |
* | u | Extended year | U* | Cyclic year |
* | v* | Timezone (generic non-locat.) | V* | Timezone (location) |
* | w | Local week of year | W* | Week of month |
* | x | Timezone (ISO-8601 w/o Z) | X | Timezone (ISO-8601) |
* | y | Year (abs) | Y | Local week-numbering year |
* | z | Timezone (specific non-locat.) | Z* | Timezone (aliases) |
*
* Letters marked by * are not implemented but reserved by Unicode standard.
*
* Letters marked by ! are non-standard, but implemented by date-fns:
* - `o` modifies the previous token to turn it into an ordinal (see `format` docs)
* - `i` is ISO day of week. For `i` and `ii` is returns numeric ISO week days,
* i.e. 7 for Sunday, 1 for Monday, etc.
* - `I` is ISO week of year, as opposed to `w` which is local week of year.
* - `R` is ISO week-numbering year, as opposed to `Y` which is local week-numbering year.
* `R` is supposed to be used in conjunction with `I` and `i`
* for universal ISO week-numbering date, whereas
* `Y` is supposed to be used in conjunction with `w` and `e`
* for week-numbering date specific to the locale.
* - `P` is long localized date format
* - `p` is long localized time format
*/
const formatters_formatters = {
// Era
G: function (date, token, localize) {
const era = date.getFullYear() > 0 ? 1 : 0;
switch (token) {
// AD, BC
case "G":
case "GG":
case "GGG":
return localize.era(era, { width: "abbreviated" });
// A, B
case "GGGGG":
return localize.era(era, { width: "narrow" });
// Anno Domini, Before Christ
case "GGGG":
default:
return localize.era(era, { width: "wide" });
}
},
// Year
y: function (date, token, localize) {
// Ordinal number
if (token === "yo") {
const signedYear = date.getFullYear();
// Returns 1 for 1 BC (which is year 0 in JavaScript)
const year = signedYear > 0 ? signedYear : 1 - signedYear;
return localize.ordinalNumber(year, { unit: "year" });
}
return lightFormatters_lightFormatters.y(date, token);
},
// Local week-numbering year
Y: function (date, token, localize, options) {
const signedWeekYear = getWeekYear_getWeekYear(date, options);
// Returns 1 for 1 BC (which is year 0 in JavaScript)
const weekYear = signedWeekYear > 0 ? signedWeekYear : 1 - signedWeekYear;
// Two digit year
if (token === "YY") {
const twoDigitYear = weekYear % 100;
return addLeadingZeros_addLeadingZeros(twoDigitYear, 2);
}
// Ordinal number
if (token === "Yo") {
return localize.ordinalNumber(weekYear, { unit: "year" });
}
// Padding
return addLeadingZeros_addLeadingZeros(weekYear, token.length);
},
// ISO week-numbering year
R: function (date, token) {
const isoWeekYear = getISOWeekYear_getISOWeekYear(date);
// Padding
return addLeadingZeros_addLeadingZeros(isoWeekYear, token.length);
},
// Extended year. This is a single number designating the year of this calendar system.
// The main difference between `y` and `u` localizers are B.C. years:
// | Year | `y` | `u` |
// |------|-----|-----|
// | AC 1 | 1 | 1 |
// | BC 1 | 1 | 0 |
// | BC 2 | 2 | -1 |
// Also `yy` always returns the last two digits of a year,
// while `uu` pads single digit years to 2 characters and returns other years unchanged.
u: function (date, token) {
const year = date.getFullYear();
return addLeadingZeros_addLeadingZeros(year, token.length);
},
// Quarter
Q: function (date, token, localize) {
const quarter = Math.ceil((date.getMonth() + 1) / 3);
switch (token) {
// 1, 2, 3, 4
case "Q":
return String(quarter);
// 01, 02, 03, 04
case "QQ":
return addLeadingZeros_addLeadingZeros(quarter, 2);
// 1st, 2nd, 3rd, 4th
case "Qo":
return localize.ordinalNumber(quarter, { unit: "quarter" });
// Q1, Q2, Q3, Q4
case "QQQ":
return localize.quarter(quarter, {
width: "abbreviated",
context: "formatting",
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "QQQQQ":
return localize.quarter(quarter, {
width: "narrow",
context: "formatting",
});
// 1st quarter, 2nd quarter, ...
case "QQQQ":
default:
return localize.quarter(quarter, {
width: "wide",
context: "formatting",
});
}
},
// Stand-alone quarter
q: function (date, token, localize) {
const quarter = Math.ceil((date.getMonth() + 1) / 3);
switch (token) {
// 1, 2, 3, 4
case "q":
return String(quarter);
// 01, 02, 03, 04
case "qq":
return addLeadingZeros_addLeadingZeros(quarter, 2);
// 1st, 2nd, 3rd, 4th
case "qo":
return localize.ordinalNumber(quarter, { unit: "quarter" });
// Q1, Q2, Q3, Q4
case "qqq":
return localize.quarter(quarter, {
width: "abbreviated",
context: "standalone",
});
// 1, 2, 3, 4 (narrow quarter; could be not numerical)
case "qqqqq":
return localize.quarter(quarter, {
width: "narrow",
context: "standalone",
});
// 1st quarter, 2nd quarter, ...
case "qqqq":
default:
return localize.quarter(quarter, {
width: "wide",
context: "standalone",
});
}
},
// Month
M: function (date, token, localize) {
const month = date.getMonth();
switch (token) {
case "M":
case "MM":
return lightFormatters_lightFormatters.M(date, token);
// 1st, 2nd, ..., 12th
case "Mo":
return localize.ordinalNumber(month + 1, { unit: "month" });
// Jan, Feb, ..., Dec
case "MMM":
return localize.month(month, {
width: "abbreviated",
context: "formatting",
});
// J, F, ..., D
case "MMMMM":
return localize.month(month, {
width: "narrow",
context: "formatting",
});
// January, February, ..., December
case "MMMM":
default:
return localize.month(month, { width: "wide", context: "formatting" });
}
},
// Stand-alone month
L: function (date, token, localize) {
const month = date.getMonth();
switch (token) {
// 1, 2, ..., 12
case "L":
return String(month + 1);
// 01, 02, ..., 12
case "LL":
return addLeadingZeros_addLeadingZeros(month + 1, 2);
// 1st, 2nd, ..., 12th
case "Lo":
return localize.ordinalNumber(month + 1, { unit: "month" });
// Jan, Feb, ..., Dec
case "LLL":
return localize.month(month, {
width: "abbreviated",
context: "standalone",
});
// J, F, ..., D
case "LLLLL":
return localize.month(month, {
width: "narrow",
context: "standalone",
});
// January, February, ..., December
case "LLLL":
default:
return localize.month(month, { width: "wide", context: "standalone" });
}
},
// Local week of year
w: function (date, token, localize, options) {
const week = getWeek_getWeek(date, options);
if (token === "wo") {
return localize.ordinalNumber(week, { unit: "week" });
}
return addLeadingZeros_addLeadingZeros(week, token.length);
},
// ISO week of year
I: function (date, token, localize) {
const isoWeek = getISOWeek_getISOWeek(date);
if (token === "Io") {
return localize.ordinalNumber(isoWeek, { unit: "week" });
}
return addLeadingZeros_addLeadingZeros(isoWeek, token.length);
},
// Day of the month
d: function (date, token, localize) {
if (token === "do") {
return localize.ordinalNumber(date.getDate(), { unit: "date" });
}
return lightFormatters_lightFormatters.d(date, token);
},
// Day of year
D: function (date, token, localize) {
const dayOfYear = getDayOfYear_getDayOfYear(date);
if (token === "Do") {
return localize.ordinalNumber(dayOfYear, { unit: "dayOfYear" });
}
return addLeadingZeros_addLeadingZeros(dayOfYear, token.length);
},
// Day of week
E: function (date, token, localize) {
const dayOfWeek = date.getDay();
switch (token) {
// Tue
case "E":
case "EE":
case "EEE":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "formatting",
});
// T
case "EEEEE":
return localize.day(dayOfWeek, {
width: "narrow",
context: "formatting",
});
// Tu
case "EEEEEE":
return localize.day(dayOfWeek, {
width: "short",
context: "formatting",
});
// Tuesday
case "EEEE":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "formatting",
});
}
},
// Local day of week
e: function (date, token, localize, options) {
const dayOfWeek = date.getDay();
const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
switch (token) {
// Numerical value (Nth day of week with current locale or weekStartsOn)
case "e":
return String(localDayOfWeek);
// Padded numerical value
case "ee":
return addLeadingZeros_addLeadingZeros(localDayOfWeek, 2);
// 1st, 2nd, ..., 7th
case "eo":
return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
case "eee":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "formatting",
});
// T
case "eeeee":
return localize.day(dayOfWeek, {
width: "narrow",
context: "formatting",
});
// Tu
case "eeeeee":
return localize.day(dayOfWeek, {
width: "short",
context: "formatting",
});
// Tuesday
case "eeee":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "formatting",
});
}
},
// Stand-alone local day of week
c: function (date, token, localize, options) {
const dayOfWeek = date.getDay();
const localDayOfWeek = (dayOfWeek - options.weekStartsOn + 8) % 7 || 7;
switch (token) {
// Numerical value (same as in `e`)
case "c":
return String(localDayOfWeek);
// Padded numerical value
case "cc":
return addLeadingZeros_addLeadingZeros(localDayOfWeek, token.length);
// 1st, 2nd, ..., 7th
case "co":
return localize.ordinalNumber(localDayOfWeek, { unit: "day" });
case "ccc":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "standalone",
});
// T
case "ccccc":
return localize.day(dayOfWeek, {
width: "narrow",
context: "standalone",
});
// Tu
case "cccccc":
return localize.day(dayOfWeek, {
width: "short",
context: "standalone",
});
// Tuesday
case "cccc":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "standalone",
});
}
},
// ISO day of week
i: function (date, token, localize) {
const dayOfWeek = date.getDay();
const isoDayOfWeek = dayOfWeek === 0 ? 7 : dayOfWeek;
switch (token) {
// 2
case "i":
return String(isoDayOfWeek);
// 02
case "ii":
return addLeadingZeros_addLeadingZeros(isoDayOfWeek, token.length);
// 2nd
case "io":
return localize.ordinalNumber(isoDayOfWeek, { unit: "day" });
// Tue
case "iii":
return localize.day(dayOfWeek, {
width: "abbreviated",
context: "formatting",
});
// T
case "iiiii":
return localize.day(dayOfWeek, {
width: "narrow",
context: "formatting",
});
// Tu
case "iiiiii":
return localize.day(dayOfWeek, {
width: "short",
context: "formatting",
});
// Tuesday
case "iiii":
default:
return localize.day(dayOfWeek, {
width: "wide",
context: "formatting",
});
}
},
// AM or PM
a: function (date, token, localize) {
const hours = date.getHours();
const dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
switch (token) {
case "a":
case "aa":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
});
case "aaa":
return localize
.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
})
.toLowerCase();
case "aaaaa":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "narrow",
context: "formatting",
});
case "aaaa":
default:
return localize.dayPeriod(dayPeriodEnumValue, {
width: "wide",
context: "formatting",
});
}
},
// AM, PM, midnight, noon
b: function (date, token, localize) {
const hours = date.getHours();
let dayPeriodEnumValue;
if (hours === 12) {
dayPeriodEnumValue = formatters_dayPeriodEnum.noon;
} else if (hours === 0) {
dayPeriodEnumValue = formatters_dayPeriodEnum.midnight;
} else {
dayPeriodEnumValue = hours / 12 >= 1 ? "pm" : "am";
}
switch (token) {
case "b":
case "bb":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
});
case "bbb":
return localize
.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
})
.toLowerCase();
case "bbbbb":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "narrow",
context: "formatting",
});
case "bbbb":
default:
return localize.dayPeriod(dayPeriodEnumValue, {
width: "wide",
context: "formatting",
});
}
},
// in the morning, in the afternoon, in the evening, at night
B: function (date, token, localize) {
const hours = date.getHours();
let dayPeriodEnumValue;
if (hours >= 17) {
dayPeriodEnumValue = formatters_dayPeriodEnum.evening;
} else if (hours >= 12) {
dayPeriodEnumValue = formatters_dayPeriodEnum.afternoon;
} else if (hours >= 4) {
dayPeriodEnumValue = formatters_dayPeriodEnum.morning;
} else {
dayPeriodEnumValue = formatters_dayPeriodEnum.night;
}
switch (token) {
case "B":
case "BB":
case "BBB":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "abbreviated",
context: "formatting",
});
case "BBBBB":
return localize.dayPeriod(dayPeriodEnumValue, {
width: "narrow",
context: "formatting",
});
case "BBBB":
default:
return localize.dayPeriod(dayPeriodEnumValue, {
width: "wide",
context: "formatting",
});
}
},
// Hour [1-12]
h: function (date, token, localize) {
if (token === "ho") {
let hours = date.getHours() % 12;
if (hours === 0) hours = 12;
return localize.ordinalNumber(hours, { unit: "hour" });
}
return lightFormatters_lightFormatters.h(date, token);
},
// Hour [0-23]
H: function (date, token, localize) {
if (token === "Ho") {
return localize.ordinalNumber(date.getHours(), { unit: "hour" });
}
return lightFormatters_lightFormatters.H(date, token);
},
// Hour [0-11]
K: function (date, token, localize) {
const hours = date.getHours() % 12;
if (token === "Ko") {
return localize.ordinalNumber(hours, { unit: "hour" });
}
return addLeadingZeros_addLeadingZeros(hours, token.length);
},
// Hour [1-24]
k: function (date, token, localize) {
let hours = date.getHours();
if (hours === 0) hours = 24;
if (token === "ko") {
return localize.ordinalNumber(hours, { unit: "hour" });
}
return addLeadingZeros_addLeadingZeros(hours, token.length);
},
// Minute
m: function (date, token, localize) {
if (token === "mo") {
return localize.ordinalNumber(date.getMinutes(), { unit: "minute" });
}
return lightFormatters_lightFormatters.m(date, token);
},
// Second
s: function (date, token, localize) {
if (token === "so") {
return localize.ordinalNumber(date.getSeconds(), { unit: "second" });
}
return lightFormatters_lightFormatters.s(date, token);
},
// Fraction of second
S: function (date, token) {
return lightFormatters_lightFormatters.S(date, token);
},
// Timezone (ISO-8601. If offset is 0, output is always `'Z'`)
X: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
if (timezoneOffset === 0) {
return "Z";
}
switch (token) {
// Hours and optional minutes
case "X":
return formatters_formatTimezoneWithOptionalMinutes(timezoneOffset);
// Hours, minutes and optional seconds without `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `XX`
case "XXXX":
case "XX": // Hours and minutes without `:` delimiter
return formatters_formatTimezone(timezoneOffset);
// Hours, minutes and optional seconds with `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `XXX`
case "XXXXX":
case "XXX": // Hours and minutes with `:` delimiter
default:
return formatters_formatTimezone(timezoneOffset, ":");
}
},
// Timezone (ISO-8601. If offset is 0, output is `'+00:00'` or equivalent)
x: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
switch (token) {
// Hours and optional minutes
case "x":
return formatters_formatTimezoneWithOptionalMinutes(timezoneOffset);
// Hours, minutes and optional seconds without `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `xx`
case "xxxx":
case "xx": // Hours and minutes without `:` delimiter
return formatters_formatTimezone(timezoneOffset);
// Hours, minutes and optional seconds with `:` delimiter
// Note: neither ISO-8601 nor JavaScript supports seconds in timezone offsets
// so this token always has the same output as `xxx`
case "xxxxx":
case "xxx": // Hours and minutes with `:` delimiter
default:
return formatters_formatTimezone(timezoneOffset, ":");
}
},
// Timezone (GMT)
O: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
switch (token) {
// Short
case "O":
case "OO":
case "OOO":
return "GMT" + formatters_formatTimezoneShort(timezoneOffset, ":");
// Long
case "OOOO":
default:
return "GMT" + formatters_formatTimezone(timezoneOffset, ":");
}
},
// Timezone (specific non-location)
z: function (date, token, _localize) {
const timezoneOffset = date.getTimezoneOffset();
switch (token) {
// Short
case "z":
case "zz":
case "zzz":
return "GMT" + formatters_formatTimezoneShort(timezoneOffset, ":");
// Long
case "zzzz":
default:
return "GMT" + formatters_formatTimezone(timezoneOffset, ":");
}
},
// Seconds timestamp
t: function (date, token, _localize) {
const timestamp = Math.trunc(+date / 1000);
return addLeadingZeros_addLeadingZeros(timestamp, token.length);
},
// Milliseconds timestamp
T: function (date, token, _localize) {
return addLeadingZeros_addLeadingZeros(+date, token.length);
},
};
function formatters_formatTimezoneShort(offset, delimiter = "") {
const sign = offset > 0 ? "-" : "+";
const absOffset = Math.abs(offset);
const hours = Math.trunc(absOffset / 60);
const minutes = absOffset % 60;
if (minutes === 0) {
return sign + String(hours);
}
return sign + String(hours) + delimiter + addLeadingZeros_addLeadingZeros(minutes, 2);
}
function formatters_formatTimezoneWithOptionalMinutes(offset, delimiter) {
if (offset % 60 === 0) {
const sign = offset > 0 ? "-" : "+";
return sign + addLeadingZeros_addLeadingZeros(Math.abs(offset) / 60, 2);
}
return formatters_formatTimezone(offset, delimiter);
}
function formatters_formatTimezone(offset, delimiter = "") {
const sign = offset > 0 ? "-" : "+";
const absOffset = Math.abs(offset);
const hours = addLeadingZeros_addLeadingZeros(Math.trunc(absOffset / 60), 2);
const minutes = addLeadingZeros_addLeadingZeros(absOffset % 60, 2);
return sign + hours + delimiter + minutes;
}
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/format/longFormatters.js
const longFormatters_dateLongFormatter = (pattern, formatLong) => {
switch (pattern) {
case "P":
return formatLong.date({ width: "short" });
case "PP":
return formatLong.date({ width: "medium" });
case "PPP":
return formatLong.date({ width: "long" });
case "PPPP":
default:
return formatLong.date({ width: "full" });
}
};
const longFormatters_timeLongFormatter = (pattern, formatLong) => {
switch (pattern) {
case "p":
return formatLong.time({ width: "short" });
case "pp":
return formatLong.time({ width: "medium" });
case "ppp":
return formatLong.time({ width: "long" });
case "pppp":
default:
return formatLong.time({ width: "full" });
}
};
const longFormatters_dateTimeLongFormatter = (pattern, formatLong) => {
const matchResult = pattern.match(/(P+)(p+)?/) || [];
const datePattern = matchResult[1];
const timePattern = matchResult[2];
if (!timePattern) {
return longFormatters_dateLongFormatter(pattern, formatLong);
}
let dateTimeFormat;
switch (datePattern) {
case "P":
dateTimeFormat = formatLong.dateTime({ width: "short" });
break;
case "PP":
dateTimeFormat = formatLong.dateTime({ width: "medium" });
break;
case "PPP":
dateTimeFormat = formatLong.dateTime({ width: "long" });
break;
case "PPPP":
default:
dateTimeFormat = formatLong.dateTime({ width: "full" });
break;
}
return dateTimeFormat
.replace("{{date}}", longFormatters_dateLongFormatter(datePattern, formatLong))
.replace("{{time}}", longFormatters_timeLongFormatter(timePattern, formatLong));
};
const longFormatters_longFormatters = {
p: longFormatters_timeLongFormatter,
P: longFormatters_dateTimeLongFormatter,
};
;// ./node_modules/react-day-picker/node_modules/date-fns/_lib/protectedTokens.js
const protectedTokens_dayOfYearTokenRE = /^D+$/;
const protectedTokens_weekYearTokenRE = /^Y+$/;
const protectedTokens_throwTokens = ["D", "DD", "YY", "YYYY"];
function protectedTokens_isProtectedDayOfYearToken(token) {
return protectedTokens_dayOfYearTokenRE.test(token);
}
function protectedTokens_isProtectedWeekYearToken(token) {
return protectedTokens_weekYearTokenRE.test(token);
}
function protectedTokens_warnOrThrowProtectedError(token, format, input) {
const _message = protectedTokens_message(token, format, input);
console.warn(_message);
if (protectedTokens_throwTokens.includes(token)) throw new RangeError(_message);
}
function protectedTokens_message(token, format, input) {
const subject = token[0] === "Y" ? "years" : "days of the month";
return `Use \`${token.toLowerCase()}\` instead of \`${token}\` (in \`${format}\`) for formatting ${subject} to the input \`${input}\`; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md`;
}
;// ./node_modules/react-day-picker/node_modules/date-fns/isDate.js
/**
* @name isDate
* @category Common Helpers
* @summary Is the given value a date?
*
* @description
* Returns true if the given value is an instance of Date. The function works for dates transferred across iframes.
*
* @param value - The value to check
*
* @returns True if the given value is a date
*
* @example
* // For a valid date:
* const result = isDate(new Date())
* //=> true
*
* @example
* // For an invalid date:
* const result = isDate(new Date(NaN))
* //=> true
*
* @example
* // For some value:
* const result = isDate('2014-02-31')
* //=> false
*
* @example
* // For an object:
* const result = isDate({})
* //=> false
*/
function isDate_isDate(value) {
return (
value instanceof Date ||
(typeof value === "object" &&
Object.prototype.toString.call(value) === "[object Date]")
);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_isDate = ((/* unused pure expression or super */ null && (isDate_isDate)));
;// ./node_modules/react-day-picker/node_modules/date-fns/isValid.js
/**
* @name isValid
* @category Common Helpers
* @summary Is the given date valid?
*
* @description
* Returns false if argument is Invalid Date and true otherwise.
* Argument is converted to Date using `toDate`. See [toDate](https://date-fns.org/docs/toDate)
* Invalid Date is a Date, whose time value is NaN.
*
* Time value of Date: http://es5.github.io/#x15.9.1.1
*
* @param date - The date to check
*
* @returns The date is valid
*
* @example
* // For the valid date:
* const result = isValid(new Date(2014, 1, 31))
* //=> true
*
* @example
* // For the value, convertible into a date:
* const result = isValid(1393804800000)
* //=> true
*
* @example
* // For the invalid date:
* const result = isValid(new Date(''))
* //=> false
*/
function isValid_isValid(date) {
return !((!isDate_isDate(date) && typeof date !== "number") || isNaN(+toDate_toDate(date)));
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_isValid = ((/* unused pure expression or super */ null && (isValid_isValid)));
;// ./node_modules/react-day-picker/node_modules/date-fns/format.js
// Rexports of internal for libraries to use.
// See: https://github.com/date-fns/date-fns/issues/3638#issuecomment-1877082874
// This RegExp consists of three parts separated by `|`:
// - [yYQqMLwIdDecihHKkms]o matches any available ordinal number token
// (one of the certain letters followed by `o`)
// - (\w)\1* matches any sequences of the same letter
// - '' matches two quote characters in a row
// - '(''|[^'])+('|$) matches anything surrounded by two quote characters ('),
// except a single quote symbol, which ends the sequence.
// Two quote characters do not end the sequence.
// If there is no matching single quote
// then the sequence will continue until the end of the string.
// - . matches any single character unmatched by previous parts of the RegExps
const format_formattingTokensRegExp =
/[yYQqMLwIdDecihHKkms]o|(\w)\1*|''|'(''|[^'])+('|$)|./g;
// This RegExp catches symbols escaped by quotes, and also
// sequences of symbols P, p, and the combinations like `PPPPPPPppppp`
const format_longFormattingTokensRegExp = /P+p+|P+|p+|''|'(''|[^'])+('|$)|./g;
const format_escapedStringRegExp = /^'([^]*?)'?$/;
const format_doubleQuoteRegExp = /''/g;
const format_unescapedLatinCharacterRegExp = /[a-zA-Z]/;
/**
* The {@link format} function options.
*/
/**
* @name format
* @alias formatDate
* @category Common Helpers
* @summary Format the date.
*
* @description
* Return the formatted date string in the given format. The result may vary by locale.
*
* > ⚠️ Please note that the `format` tokens differ from Moment.js and other libraries.
* > See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
*
* The characters wrapped between two single quotes characters (') are escaped.
* Two single quotes in a row, whether inside or outside a quoted sequence, represent a 'real' single quote.
* (see the last example)
*
* Format of the string is based on Unicode Technical Standard #35:
* https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
* with a few additions (see note 7 below the table).
*
* Accepted patterns:
* | Unit | Pattern | Result examples | Notes |
* |---------------------------------|---------|-----------------------------------|-------|
* | Era | G..GGG | AD, BC | |
* | | GGGG | Anno Domini, Before Christ | 2 |
* | | GGGGG | A, B | |
* | Calendar year | y | 44, 1, 1900, 2017 | 5 |
* | | yo | 44th, 1st, 0th, 17th | 5,7 |
* | | yy | 44, 01, 00, 17 | 5 |
* | | yyy | 044, 001, 1900, 2017 | 5 |
* | | yyyy | 0044, 0001, 1900, 2017 | 5 |
* | | yyyyy | ... | 3,5 |
* | Local week-numbering year | Y | 44, 1, 1900, 2017 | 5 |
* | | Yo | 44th, 1st, 1900th, 2017th | 5,7 |
* | | YY | 44, 01, 00, 17 | 5,8 |
* | | YYY | 044, 001, 1900, 2017 | 5 |
* | | YYYY | 0044, 0001, 1900, 2017 | 5,8 |
* | | YYYYY | ... | 3,5 |
* | ISO week-numbering year | R | -43, 0, 1, 1900, 2017 | 5,7 |
* | | RR | -43, 00, 01, 1900, 2017 | 5,7 |
* | | RRR | -043, 000, 001, 1900, 2017 | 5,7 |
* | | RRRR | -0043, 0000, 0001, 1900, 2017 | 5,7 |
* | | RRRRR | ... | 3,5,7 |
* | Extended year | u | -43, 0, 1, 1900, 2017 | 5 |
* | | uu | -43, 01, 1900, 2017 | 5 |
* | | uuu | -043, 001, 1900, 2017 | 5 |
* | | uuuu | -0043, 0001, 1900, 2017 | 5 |
* | | uuuuu | ... | 3,5 |
* | Quarter (formatting) | Q | 1, 2, 3, 4 | |
* | | Qo | 1st, 2nd, 3rd, 4th | 7 |
* | | QQ | 01, 02, 03, 04 | |
* | | QQQ | Q1, Q2, Q3, Q4 | |
* | | QQQQ | 1st quarter, 2nd quarter, ... | 2 |
* | | QQQQQ | 1, 2, 3, 4 | 4 |
* | Quarter (stand-alone) | q | 1, 2, 3, 4 | |
* | | qo | 1st, 2nd, 3rd, 4th | 7 |
* | | qq | 01, 02, 03, 04 | |
* | | qqq | Q1, Q2, Q3, Q4 | |
* | | qqqq | 1st quarter, 2nd quarter, ... | 2 |
* | | qqqqq | 1, 2, 3, 4 | 4 |
* | Month (formatting) | M | 1, 2, ..., 12 | |
* | | Mo | 1st, 2nd, ..., 12th | 7 |
* | | MM | 01, 02, ..., 12 | |
* | | MMM | Jan, Feb, ..., Dec | |
* | | MMMM | January, February, ..., December | 2 |
* | | MMMMM | J, F, ..., D | |
* | Month (stand-alone) | L | 1, 2, ..., 12 | |
* | | Lo | 1st, 2nd, ..., 12th | 7 |
* | | LL | 01, 02, ..., 12 | |
* | | LLL | Jan, Feb, ..., Dec | |
* | | LLLL | January, February, ..., December | 2 |
* | | LLLLL | J, F, ..., D | |
* | Local week of year | w | 1, 2, ..., 53 | |
* | | wo | 1st, 2nd, ..., 53th | 7 |
* | | ww | 01, 02, ..., 53 | |
* | ISO week of year | I | 1, 2, ..., 53 | 7 |
* | | Io | 1st, 2nd, ..., 53th | 7 |
* | | II | 01, 02, ..., 53 | 7 |
* | Day of month | d | 1, 2, ..., 31 | |
* | | do | 1st, 2nd, ..., 31st | 7 |
* | | dd | 01, 02, ..., 31 | |
* | Day of year | D | 1, 2, ..., 365, 366 | 9 |
* | | Do | 1st, 2nd, ..., 365th, 366th | 7 |
* | | DD | 01, 02, ..., 365, 366 | 9 |
* | | DDD | 001, 002, ..., 365, 366 | |
* | | DDDD | ... | 3 |
* | Day of week (formatting) | E..EEE | Mon, Tue, Wed, ..., Sun | |
* | | EEEE | Monday, Tuesday, ..., Sunday | 2 |
* | | EEEEE | M, T, W, T, F, S, S | |
* | | EEEEEE | Mo, Tu, We, Th, Fr, Sa, Su | |
* | ISO day of week (formatting) | i | 1, 2, 3, ..., 7 | 7 |
* | | io | 1st, 2nd, ..., 7th | 7 |
* | | ii | 01, 02, ..., 07 | 7 |
* | | iii | Mon, Tue, Wed, ..., Sun | 7 |
* | | iiii | Monday, Tuesday, ..., Sunday | 2,7 |
* | | iiiii | M, T, W, T, F, S, S | 7 |
* | | iiiiii | Mo, Tu, We, Th, Fr, Sa, Su | 7 |
* | Local day of week (formatting) | e | 2, 3, 4, ..., 1 | |
* | | eo | 2nd, 3rd, ..., 1st | 7 |
* | | ee | 02, 03, ..., 01 | |
* | | eee | Mon, Tue, Wed, ..., Sun | |
* | | eeee | Monday, Tuesday, ..., Sunday | 2 |
* | | eeeee | M, T, W, T, F, S, S | |
* | | eeeeee | Mo, Tu, We, Th, Fr, Sa, Su | |
* | Local day of week (stand-alone) | c | 2, 3, 4, ..., 1 | |
* | | co | 2nd, 3rd, ..., 1st | 7 |
* | | cc | 02, 03, ..., 01 | |
* | | ccc | Mon, Tue, Wed, ..., Sun | |
* | | cccc | Monday, Tuesday, ..., Sunday | 2 |
* | | ccccc | M, T, W, T, F, S, S | |
* | | cccccc | Mo, Tu, We, Th, Fr, Sa, Su | |
* | AM, PM | a..aa | AM, PM | |
* | | aaa | am, pm | |
* | | aaaa | a.m., p.m. | 2 |
* | | aaaaa | a, p | |
* | AM, PM, noon, midnight | b..bb | AM, PM, noon, midnight | |
* | | bbb | am, pm, noon, midnight | |
* | | bbbb | a.m., p.m., noon, midnight | 2 |
* | | bbbbb | a, p, n, mi | |
* | Flexible day period | B..BBB | at night, in the morning, ... | |
* | | BBBB | at night, in the morning, ... | 2 |
* | | BBBBB | at night, in the morning, ... | |
* | Hour [1-12] | h | 1, 2, ..., 11, 12 | |
* | | ho | 1st, 2nd, ..., 11th, 12th | 7 |
* | | hh | 01, 02, ..., 11, 12 | |
* | Hour [0-23] | H | 0, 1, 2, ..., 23 | |
* | | Ho | 0th, 1st, 2nd, ..., 23rd | 7 |
* | | HH | 00, 01, 02, ..., 23 | |
* | Hour [0-11] | K | 1, 2, ..., 11, 0 | |
* | | Ko | 1st, 2nd, ..., 11th, 0th | 7 |
* | | KK | 01, 02, ..., 11, 00 | |
* | Hour [1-24] | k | 24, 1, 2, ..., 23 | |
* | | ko | 24th, 1st, 2nd, ..., 23rd | 7 |
* | | kk | 24, 01, 02, ..., 23 | |
* | Minute | m | 0, 1, ..., 59 | |
* | | mo | 0th, 1st, ..., 59th | 7 |
* | | mm | 00, 01, ..., 59 | |
* | Second | s | 0, 1, ..., 59 | |
* | | so | 0th, 1st, ..., 59th | 7 |
* | | ss | 00, 01, ..., 59 | |
* | Fraction of second | S | 0, 1, ..., 9 | |
* | | SS | 00, 01, ..., 99 | |
* | | SSS | 000, 001, ..., 999 | |
* | | SSSS | ... | 3 |
* | Timezone (ISO-8601 w/ Z) | X | -08, +0530, Z | |
* | | XX | -0800, +0530, Z | |
* | | XXX | -08:00, +05:30, Z | |
* | | XXXX | -0800, +0530, Z, +123456 | 2 |
* | | XXXXX | -08:00, +05:30, Z, +12:34:56 | |
* | Timezone (ISO-8601 w/o Z) | x | -08, +0530, +00 | |
* | | xx | -0800, +0530, +0000 | |
* | | xxx | -08:00, +05:30, +00:00 | 2 |
* | | xxxx | -0800, +0530, +0000, +123456 | |
* | | xxxxx | -08:00, +05:30, +00:00, +12:34:56 | |
* | Timezone (GMT) | O...OOO | GMT-8, GMT+5:30, GMT+0 | |
* | | OOOO | GMT-08:00, GMT+05:30, GMT+00:00 | 2 |
* | Timezone (specific non-locat.) | z...zzz | GMT-8, GMT+5:30, GMT+0 | 6 |
* | | zzzz | GMT-08:00, GMT+05:30, GMT+00:00 | 2,6 |
* | Seconds timestamp | t | 512969520 | 7 |
* | | tt | ... | 3,7 |
* | Milliseconds timestamp | T | 512969520900 | 7 |
* | | TT | ... | 3,7 |
* | Long localized date | P | 04/29/1453 | 7 |
* | | PP | Apr 29, 1453 | 7 |
* | | PPP | April 29th, 1453 | 7 |
* | | PPPP | Friday, April 29th, 1453 | 2,7 |
* | Long localized time | p | 12:00 AM | 7 |
* | | pp | 12:00:00 AM | 7 |
* | | ppp | 12:00:00 AM GMT+2 | 7 |
* | | pppp | 12:00:00 AM GMT+02:00 | 2,7 |
* | Combination of date and time | Pp | 04/29/1453, 12:00 AM | 7 |
* | | PPpp | Apr 29, 1453, 12:00:00 AM | 7 |
* | | PPPppp | April 29th, 1453 at ... | 7 |
* | | PPPPpppp| Friday, April 29th, 1453 at ... | 2,7 |
* Notes:
* 1. "Formatting" units (e.g. formatting quarter) in the default en-US locale
* are the same as "stand-alone" units, but are different in some languages.
* "Formatting" units are declined according to the rules of the language
* in the context of a date. "Stand-alone" units are always nominative singular:
*
* `format(new Date(2017, 10, 6), 'do LLLL', {locale: cs}) //=> '6. listopad'`
*
* `format(new Date(2017, 10, 6), 'do MMMM', {locale: cs}) //=> '6. listopadu'`
*
* 2. Any sequence of the identical letters is a pattern, unless it is escaped by
* the single quote characters (see below).
* If the sequence is longer than listed in table (e.g. `EEEEEEEEEEE`)
* the output will be the same as default pattern for this unit, usually
* the longest one (in case of ISO weekdays, `EEEE`). Default patterns for units
* are marked with "2" in the last column of the table.
*
* `format(new Date(2017, 10, 6), 'MMM') //=> 'Nov'`
*
* `format(new Date(2017, 10, 6), 'MMMM') //=> 'November'`
*
* `format(new Date(2017, 10, 6), 'MMMMM') //=> 'N'`
*
* `format(new Date(2017, 10, 6), 'MMMMMM') //=> 'November'`
*
* `format(new Date(2017, 10, 6), 'MMMMMMM') //=> 'November'`
*
* 3. Some patterns could be unlimited length (such as `yyyyyyyy`).
* The output will be padded with zeros to match the length of the pattern.
*
* `format(new Date(2017, 10, 6), 'yyyyyyyy') //=> '00002017'`
*
* 4. `QQQQQ` and `qqqqq` could be not strictly numerical in some locales.
* These tokens represent the shortest form of the quarter.
*
* 5. The main difference between `y` and `u` patterns are B.C. years:
*
* | Year | `y` | `u` |
* |------|-----|-----|
* | AC 1 | 1 | 1 |
* | BC 1 | 1 | 0 |
* | BC 2 | 2 | -1 |
*
* Also `yy` always returns the last two digits of a year,
* while `uu` pads single digit years to 2 characters and returns other years unchanged:
*
* | Year | `yy` | `uu` |
* |------|------|------|
* | 1 | 01 | 01 |
* | 14 | 14 | 14 |
* | 376 | 76 | 376 |
* | 1453 | 53 | 1453 |
*
* The same difference is true for local and ISO week-numbering years (`Y` and `R`),
* except local week-numbering years are dependent on `options.weekStartsOn`
* and `options.firstWeekContainsDate` (compare [getISOWeekYear](https://date-fns.org/docs/getISOWeekYear)
* and [getWeekYear](https://date-fns.org/docs/getWeekYear)).
*
* 6. Specific non-location timezones are currently unavailable in `date-fns`,
* so right now these tokens fall back to GMT timezones.
*
* 7. These patterns are not in the Unicode Technical Standard #35:
* - `i`: ISO day of week
* - `I`: ISO week of year
* - `R`: ISO week-numbering year
* - `t`: seconds timestamp
* - `T`: milliseconds timestamp
* - `o`: ordinal number modifier
* - `P`: long localized date
* - `p`: long localized time
*
* 8. `YY` and `YYYY` tokens represent week-numbering years but they are often confused with years.
* You should enable `options.useAdditionalWeekYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
*
* 9. `D` and `DD` tokens represent days of the year but they are often confused with days of the month.
* You should enable `options.useAdditionalDayOfYearTokens` to use them. See: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
*
* @param date - The original date
* @param format - The string of tokens
* @param options - An object with options
*
* @returns The formatted date string
*
* @throws `date` must not be Invalid Date
* @throws `options.locale` must contain `localize` property
* @throws `options.locale` must contain `formatLong` property
* @throws use `yyyy` instead of `YYYY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws use `yy` instead of `YY` for formatting years using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws use `d` instead of `D` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws use `dd` instead of `DD` for formatting days of the month using [format provided] to the input [input provided]; see: https://github.com/date-fns/date-fns/blob/master/docs/unicodeTokens.md
* @throws format string contains an unescaped latin alphabet character
*
* @example
* // Represent 11 February 2014 in middle-endian format:
* const result = format(new Date(2014, 1, 11), 'MM/dd/yyyy')
* //=> '02/11/2014'
*
* @example
* // Represent 2 July 2014 in Esperanto:
* import { eoLocale } from 'date-fns/locale/eo'
* const result = format(new Date(2014, 6, 2), "do 'de' MMMM yyyy", {
* locale: eoLocale
* })
* //=> '2-a de julio 2014'
*
* @example
* // Escape string by single quote characters:
* const result = format(new Date(2014, 6, 2, 15), "h 'o''clock'")
* //=> "3 o'clock"
*/
function format_format(date, formatStr, options) {
const defaultOptions = defaultOptions_getDefaultOptions();
const locale = options?.locale ?? defaultOptions.locale ?? en_US_enUS;
const firstWeekContainsDate =
options?.firstWeekContainsDate ??
options?.locale?.options?.firstWeekContainsDate ??
defaultOptions.firstWeekContainsDate ??
defaultOptions.locale?.options?.firstWeekContainsDate ??
1;
const weekStartsOn =
options?.weekStartsOn ??
options?.locale?.options?.weekStartsOn ??
defaultOptions.weekStartsOn ??
defaultOptions.locale?.options?.weekStartsOn ??
0;
const originalDate = toDate_toDate(date, options?.in);
if (!isValid_isValid(originalDate)) {
throw new RangeError("Invalid time value");
}
let parts = formatStr
.match(format_longFormattingTokensRegExp)
.map((substring) => {
const firstCharacter = substring[0];
if (firstCharacter === "p" || firstCharacter === "P") {
const longFormatter = longFormatters_longFormatters[firstCharacter];
return longFormatter(substring, locale.formatLong);
}
return substring;
})
.join("")
.match(format_formattingTokensRegExp)
.map((substring) => {
// Replace two single quote characters with one single quote character
if (substring === "''") {
return { isToken: false, value: "'" };
}
const firstCharacter = substring[0];
if (firstCharacter === "'") {
return { isToken: false, value: format_cleanEscapedString(substring) };
}
if (formatters_formatters[firstCharacter]) {
return { isToken: true, value: substring };
}
if (firstCharacter.match(format_unescapedLatinCharacterRegExp)) {
throw new RangeError(
"Format string contains an unescaped latin alphabet character `" +
firstCharacter +
"`",
);
}
return { isToken: false, value: substring };
});
// invoke localize preprocessor (only for french locales at the moment)
if (locale.localize.preprocessor) {
parts = locale.localize.preprocessor(originalDate, parts);
}
const formatterOptions = {
firstWeekContainsDate,
weekStartsOn,
locale,
};
return parts
.map((part) => {
if (!part.isToken) return part.value;
const token = part.value;
if (
(!options?.useAdditionalWeekYearTokens &&
protectedTokens_isProtectedWeekYearToken(token)) ||
(!options?.useAdditionalDayOfYearTokens &&
protectedTokens_isProtectedDayOfYearToken(token))
) {
protectedTokens_warnOrThrowProtectedError(token, formatStr, String(date));
}
const formatter = formatters_formatters[token[0]];
return formatter(originalDate, token, locale.localize, formatterOptions);
})
.join("");
}
function format_cleanEscapedString(input) {
const matched = input.match(format_escapedStringRegExp);
if (!matched) {
return input;
}
return matched[1].replace(format_doubleQuoteRegExp, "'");
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_format = ((/* unused pure expression or super */ null && (format_format)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getMonth.js
/**
* The {@link getMonth} function options.
*/
/**
* @name getMonth
* @category Month Helpers
* @summary Get the month of the given date.
*
* @description
* Get the month of the given date.
*
* @param date - The given date
* @param options - An object with options
*
* @returns The month index (0-11)
*
* @example
* // Which month is 29 February 2012?
* const result = getMonth(new Date(2012, 1, 29))
* //=> 1
*/
function getMonth(date, options) {
return toDate_toDate(date, options?.in).getMonth();
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getMonth = ((/* unused pure expression or super */ null && (getMonth)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getYear.js
/**
* The {@link getYear} function options.
*/
/**
* @name getYear
* @category Year Helpers
* @summary Get the year of the given date.
*
* @description
* Get the year of the given date.
*
* @param date - The given date
* @param options - An object with options
*
* @returns The year
*
* @example
* // Which year is 2 July 2014?
* const result = getYear(new Date(2014, 6, 2))
* //=> 2014
*/
function getYear(date, options) {
return toDate_toDate(date, options?.in).getFullYear();
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_getYear = ((/* unused pure expression or super */ null && (getYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/isAfter.js
/**
* @name isAfter
* @category Common Helpers
* @summary Is the first date after the second one?
*
* @description
* Is the first date after the second one?
*
* @param date - The date that should be after the other one to return true
* @param dateToCompare - The date to compare with
*
* @returns The first date is after the second date
*
* @example
* // Is 10 July 1989 after 11 February 1987?
* const result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))
* //=> true
*/
function isAfter_isAfter(date, dateToCompare) {
return +toDate_toDate(date) > +toDate_toDate(dateToCompare);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_isAfter = ((/* unused pure expression or super */ null && (isAfter_isAfter)));
;// ./node_modules/react-day-picker/node_modules/date-fns/isBefore.js
/**
* @name isBefore
* @category Common Helpers
* @summary Is the first date before the second one?
*
* @description
* Is the first date before the second one?
*
* @param date - The date that should be before the other one to return true
* @param dateToCompare - The date to compare with
*
* @returns The first date is before the second date
*
* @example
* // Is 10 July 1989 before 11 February 1987?
* const result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))
* //=> false
*/
function isBefore_isBefore(date, dateToCompare) {
return +toDate_toDate(date) < +toDate_toDate(dateToCompare);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_isBefore = ((/* unused pure expression or super */ null && (isBefore_isBefore)));
;// ./node_modules/react-day-picker/node_modules/date-fns/isSameDay.js
/**
* The {@link isSameDay} function options.
*/
/**
* @name isSameDay
* @category Day Helpers
* @summary Are the given dates in the same day (and year and month)?
*
* @description
* Are the given dates in the same day (and year and month)?
*
* @param laterDate - The first date to check
* @param earlierDate - The second date to check
* @param options - An object with options
*
* @returns The dates are in the same day (and year and month)
*
* @example
* // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?
* const result = isSameDay(new Date(2014, 8, 4, 6, 0), new Date(2014, 8, 4, 18, 0))
* //=> true
*
* @example
* // Are 4 September and 4 October in the same day?
* const result = isSameDay(new Date(2014, 8, 4), new Date(2014, 9, 4))
* //=> false
*
* @example
* // Are 4 September, 2014 and 4 September, 2015 in the same day?
* const result = isSameDay(new Date(2014, 8, 4), new Date(2015, 8, 4))
* //=> false
*/
function isSameDay_isSameDay(laterDate, earlierDate, options) {
const [dateLeft_, dateRight_] = normalizeDates(
options?.in,
laterDate,
earlierDate,
);
return +startOfDay_startOfDay(dateLeft_) === +startOfDay_startOfDay(dateRight_);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_isSameDay = ((/* unused pure expression or super */ null && (isSameDay_isSameDay)));
;// ./node_modules/react-day-picker/node_modules/date-fns/isSameMonth.js
/**
* The {@link isSameMonth} function options.
*/
/**
* @name isSameMonth
* @category Month Helpers
* @summary Are the given dates in the same month (and year)?
*
* @description
* Are the given dates in the same month (and year)?
*
* @param laterDate - The first date to check
* @param earlierDate - The second date to check
* @param options - An object with options
*
* @returns The dates are in the same month (and year)
*
* @example
* // Are 2 September 2014 and 25 September 2014 in the same month?
* const result = isSameMonth(new Date(2014, 8, 2), new Date(2014, 8, 25))
* //=> true
*
* @example
* // Are 2 September 2014 and 25 September 2015 in the same month?
* const result = isSameMonth(new Date(2014, 8, 2), new Date(2015, 8, 25))
* //=> false
*/
function isSameMonth_isSameMonth(laterDate, earlierDate, options) {
const [laterDate_, earlierDate_] = normalizeDates(
options?.in,
laterDate,
earlierDate,
);
return (
laterDate_.getFullYear() === earlierDate_.getFullYear() &&
laterDate_.getMonth() === earlierDate_.getMonth()
);
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_isSameMonth = ((/* unused pure expression or super */ null && (isSameMonth_isSameMonth)));
;// ./node_modules/react-day-picker/node_modules/date-fns/isSameYear.js
/**
* The {@link isSameYear} function options.
*/
/**
* @name isSameYear
* @category Year Helpers
* @summary Are the given dates in the same year?
*
* @description
* Are the given dates in the same year?
*
* @param laterDate - The first date to check
* @param earlierDate - The second date to check
* @param options - An object with options
*
* @returns The dates are in the same year
*
* @example
* // Are 2 September 2014 and 25 September 2014 in the same year?
* const result = isSameYear(new Date(2014, 8, 2), new Date(2014, 8, 25))
* //=> true
*/
function isSameYear(laterDate, earlierDate, options) {
const [laterDate_, earlierDate_] = normalizeDates(
options?.in,
laterDate,
earlierDate,
);
return laterDate_.getFullYear() === earlierDate_.getFullYear();
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_isSameYear = ((/* unused pure expression or super */ null && (isSameYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/max.js
/**
* The {@link max} function options.
*/
/**
* @name max
* @category Common Helpers
* @summary Return the latest of the given dates.
*
* @description
* Return the latest of the given dates.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param dates - The dates to compare
*
* @returns The latest of the dates
*
* @example
* // Which of these dates is the latest?
* const result = max([
* new Date(1989, 6, 10),
* new Date(1987, 1, 11),
* new Date(1995, 6, 2),
* new Date(1990, 0, 1)
* ])
* //=> Sun Jul 02 1995 00:00:00
*/
function max_max(dates, options) {
let result;
let context = options?.in;
dates.forEach((date) => {
// Use the first date object as the context function
if (!context && typeof date === "object")
context = constructFrom_constructFrom.bind(null, date);
const date_ = toDate_toDate(date, context);
if (!result || result < date_ || isNaN(+date_)) result = date_;
});
return constructFrom_constructFrom(context, result || NaN);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_max = ((/* unused pure expression or super */ null && (max_max)));
;// ./node_modules/react-day-picker/node_modules/date-fns/min.js
/**
* The {@link min} function options.
*/
/**
* @name min
* @category Common Helpers
* @summary Returns the earliest of the given dates.
*
* @description
* Returns the earliest of the given dates.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param dates - The dates to compare
*
* @returns The earliest of the dates
*
* @example
* // Which of these dates is the earliest?
* const result = min([
* new Date(1989, 6, 10),
* new Date(1987, 1, 11),
* new Date(1995, 6, 2),
* new Date(1990, 0, 1)
* ])
* //=> Wed Feb 11 1987 00:00:00
*/
function min_min(dates, options) {
let result;
let context = options?.in;
dates.forEach((date) => {
// Use the first date object as the context function
if (!context && typeof date === "object")
context = constructFrom_constructFrom.bind(null, date);
const date_ = toDate_toDate(date, context);
if (!result || result > date_ || isNaN(+date_)) result = date_;
});
return constructFrom_constructFrom(context, result || NaN);
}
// Fallback for modularized imports:
/* harmony default export */ const date_fns_min = ((/* unused pure expression or super */ null && (min_min)));
;// ./node_modules/react-day-picker/node_modules/date-fns/getDaysInMonth.js
/**
* The {@link getDaysInMonth} function options.
*/
/**
* @name getDaysInMonth
* @category Month Helpers
* @summary Get the number of days in a month of the given date.
*
* @description
* Get the number of days in a month of the given date, considering the context if provided.
*
* @param date - The given date
* @param options - An object with options
*
* @returns The number of days in a month
*
* @example
* // How many days are in February 2000?
* const result = getDaysInMonth(new Date(2000, 1))
* //=> 29
*/
function getDaysInMonth_getDaysInMonth(date, options) {
const _date = toDate_toDate(date, options?.in);
const year = _date.getFullYear();
const monthIndex = _date.getMonth();
const lastDayOfMonth = constructFrom_constructFrom(_date, 0);
lastDayOfMonth.setFullYear(year, monthIndex + 1, 0);
lastDayOfMonth.setHours(0, 0, 0, 0);
return lastDayOfMonth.getDate();
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_getDaysInMonth = ((/* unused pure expression or super */ null && (getDaysInMonth_getDaysInMonth)));
;// ./node_modules/react-day-picker/node_modules/date-fns/setMonth.js
/**
* The {@link setMonth} function options.
*/
/**
* @name setMonth
* @category Month Helpers
* @summary Set the month to the given date.
*
* @description
* Set the month to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param month - The month index to set (0-11)
* @param options - The options
*
* @returns The new date with the month set
*
* @example
* // Set February to 1 September 2014:
* const result = setMonth(new Date(2014, 8, 1), 1)
* //=> Sat Feb 01 2014 00:00:00
*/
function setMonth_setMonth(date, month, options) {
const _date = toDate_toDate(date, options?.in);
const year = _date.getFullYear();
const day = _date.getDate();
const midMonth = constructFrom_constructFrom(options?.in || date, 0);
midMonth.setFullYear(year, month, 15);
midMonth.setHours(0, 0, 0, 0);
const daysInMonth = getDaysInMonth_getDaysInMonth(midMonth);
// Set the earlier date, allows to wrap Jan 31 to Feb 28
_date.setMonth(month, Math.min(day, daysInMonth));
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_setMonth = ((/* unused pure expression or super */ null && (setMonth_setMonth)));
;// ./node_modules/react-day-picker/node_modules/date-fns/setYear.js
/**
* The {@link setYear} function options.
*/
/**
* @name setYear
* @category Year Helpers
* @summary Set the year to the given date.
*
* @description
* Set the year to the given date.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments. Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed, or inferred from the arguments.
*
* @param date - The date to be changed
* @param year - The year of the new date
* @param options - An object with options.
*
* @returns The new date with the year set
*
* @example
* // Set year 2013 to 1 September 2014:
* const result = setYear(new Date(2014, 8, 1), 2013)
* //=> Sun Sep 01 2013 00:00:00
*/
function setYear_setYear(date, year, options) {
const date_ = toDate_toDate(date, options?.in);
// Check if date is Invalid Date because Date.prototype.setFullYear ignores the value of Invalid Date
if (isNaN(+date_)) return constructFrom_constructFrom(options?.in || date, NaN);
date_.setFullYear(year);
return date_;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_setYear = ((/* unused pure expression or super */ null && (setYear_setYear)));
;// ./node_modules/react-day-picker/node_modules/date-fns/startOfMonth.js
/**
* The {@link startOfMonth} function options.
*/
/**
* @name startOfMonth
* @category Month Helpers
* @summary Return the start of a month for the given date.
*
* @description
* Return the start of a month for the given date. The result will be in the local timezone.
*
* @typeParam DateType - The `Date` type, the function operates on. Gets inferred from passed arguments.
* Allows to use extensions like [`UTCDate`](https://github.com/date-fns/utc).
* @typeParam ResultDate - The result `Date` type, it is the type returned from the context function if it is passed,
* or inferred from the arguments.
*
* @param date - The original date
* @param options - An object with options
*
* @returns The start of a month
*
* @example
* // The start of a month for 2 September 2014 11:55:00:
* const result = startOfMonth(new Date(2014, 8, 2, 11, 55, 0))
* //=> Mon Sep 01 2014 00:00:00
*/
function startOfMonth_startOfMonth(date, options) {
const _date = toDate_toDate(date, options?.in);
_date.setDate(1);
_date.setHours(0, 0, 0, 0);
return _date;
}
// Fallback for modularized imports:
/* harmony default export */ const node_modules_date_fns_startOfMonth = ((/* unused pure expression or super */ null && (startOfMonth_startOfMonth)));
;// ./node_modules/react-day-picker/dist/esm/helpers/getBroadcastWeeksInMonth.js
const FIVE_WEEKS = 5;
const FOUR_WEEKS = 4;
/**
* Returns the number of weeks to display in the broadcast calendar for a given
* month.
*
* The broadcast calendar may have either 4 or 5 weeks in a month, depending on
* the start and end dates of the broadcast weeks.
*
* @since 9.4.0
* @param month The month for which to calculate the number of weeks.
* @param dateLib The date library to use for date manipulation.
* @returns The number of weeks in the broadcast calendar (4 or 5).
*/
function getBroadcastWeeksInMonth(month, dateLib) {
// Get the first day of the month
const firstDayOfMonth = dateLib.startOfMonth(month);
// Get the day of the week for the first day of the month (1-7, where 1 is Monday)
const firstDayOfWeek = firstDayOfMonth.getDay() > 0 ? firstDayOfMonth.getDay() : 7;
const broadcastStartDate = dateLib.addDays(month, -firstDayOfWeek + 1);
const lastDateOfLastWeek = dateLib.addDays(broadcastStartDate, FIVE_WEEKS * 7 - 1);
const numberOfWeeks = dateLib.getMonth(month) === dateLib.getMonth(lastDateOfLastWeek)
? FIVE_WEEKS
: FOUR_WEEKS;
return numberOfWeeks;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/startOfBroadcastWeek.js
/**
* Returns the start date of the week in the broadcast calendar.
*
* The broadcast week starts on Monday. If the first day of the month is not a
* Monday, this function calculates the previous Monday as the start of the
* broadcast week.
*
* @since 9.4.0
* @param date The date for which to calculate the start of the broadcast week.
* @param dateLib The date library to use for date manipulation.
* @returns The start date of the broadcast week.
*/
function startOfBroadcastWeek(date, dateLib) {
const firstOfMonth = dateLib.startOfMonth(date);
const dayOfWeek = firstOfMonth.getDay();
if (dayOfWeek === 1) {
return firstOfMonth;
}
else if (dayOfWeek === 0) {
return dateLib.addDays(firstOfMonth, -1 * 6);
}
else {
return dateLib.addDays(firstOfMonth, -1 * (dayOfWeek - 1));
}
}
;// ./node_modules/react-day-picker/dist/esm/helpers/endOfBroadcastWeek.js
/**
* Returns the end date of the week in the broadcast calendar.
*
* The broadcast week ends on the last day of the last broadcast week for the
* given date.
*
* @since 9.4.0
* @param date The date for which to calculate the end of the broadcast week.
* @param dateLib The date library to use for date manipulation.
* @returns The end date of the broadcast week.
*/
function endOfBroadcastWeek(date, dateLib) {
const startDate = startOfBroadcastWeek(date, dateLib);
const numberOfWeeks = getBroadcastWeeksInMonth(date, dateLib);
const endDate = dateLib.addDays(startDate, numberOfWeeks * 7 - 1);
return endDate;
}
;// ./node_modules/react-day-picker/dist/esm/classes/DateLib.js
/**
* A wrapper class around [date-fns](http://date-fns.org) that provides utility
* methods for date manipulation and formatting.
*
* @since 9.2.0
* @example
* const dateLib = new DateLib({ locale: es });
* const newDate = dateLib.addDays(new Date(), 5);
*/
class DateLib {
/**
* Creates an instance of `DateLib`.
*
* @param options Configuration options for the date library.
* @param overrides Custom overrides for the date library functions.
*/
constructor(options, overrides) {
/**
* Reference to the built-in Date constructor.
*
* @deprecated Use `newDate()` or `today()`.
*/
this.Date = Date;
/**
* Creates a new `Date` object representing today's date.
*
* @since 9.5.0
* @returns A `Date` object for today's date.
*/
this.today = () => {
if (this.overrides?.today) {
return this.overrides.today();
}
if (this.options.timeZone) {
return date_TZDate.tz(this.options.timeZone);
}
return new this.Date();
};
/**
* Creates a new `Date` object with the specified year, month, and day.
*
* @since 9.5.0
* @param year The year.
* @param monthIndex The month (0-11).
* @param date The day of the month.
* @returns A new `Date` object.
*/
this.newDate = (year, monthIndex, date) => {
if (this.overrides?.newDate) {
return this.overrides.newDate(year, monthIndex, date);
}
if (this.options.timeZone) {
return new date_TZDate(year, monthIndex, date, this.options.timeZone);
}
return new Date(year, monthIndex, date);
};
/**
* Adds the specified number of days to the given date.
*
* @param date The date to add days to.
* @param amount The number of days to add.
* @returns The new date with the days added.
*/
this.addDays = (date, amount) => {
return this.overrides?.addDays
? this.overrides.addDays(date, amount)
: addDays_addDays(date, amount);
};
/**
* Adds the specified number of months to the given date.
*
* @param date The date to add months to.
* @param amount The number of months to add.
* @returns The new date with the months added.
*/
this.addMonths = (date, amount) => {
return this.overrides?.addMonths
? this.overrides.addMonths(date, amount)
: addMonths_addMonths(date, amount);
};
/**
* Adds the specified number of weeks to the given date.
*
* @param date The date to add weeks to.
* @param amount The number of weeks to add.
* @returns The new date with the weeks added.
*/
this.addWeeks = (date, amount) => {
return this.overrides?.addWeeks
? this.overrides.addWeeks(date, amount)
: addWeeks_addWeeks(date, amount);
};
/**
* Adds the specified number of years to the given date.
*
* @param date The date to add years to.
* @param amount The number of years to add.
* @returns The new date with the years added.
*/
this.addYears = (date, amount) => {
return this.overrides?.addYears
? this.overrides.addYears(date, amount)
: addYears_addYears(date, amount);
};
/**
* Returns the number of calendar days between the given dates.
*
* @param dateLeft The later date.
* @param dateRight The earlier date.
* @returns The number of calendar days between the dates.
*/
this.differenceInCalendarDays = (dateLeft, dateRight) => {
return this.overrides?.differenceInCalendarDays
? this.overrides.differenceInCalendarDays(dateLeft, dateRight)
: differenceInCalendarDays_differenceInCalendarDays(dateLeft, dateRight);
};
/**
* Returns the number of calendar months between the given dates.
*
* @param dateLeft The later date.
* @param dateRight The earlier date.
* @returns The number of calendar months between the dates.
*/
this.differenceInCalendarMonths = (dateLeft, dateRight) => {
return this.overrides?.differenceInCalendarMonths
? this.overrides.differenceInCalendarMonths(dateLeft, dateRight)
: differenceInCalendarMonths(dateLeft, dateRight);
};
/**
* Returns the months between the given dates.
*
* @param interval The interval to get the months for.
*/
this.eachMonthOfInterval = (interval) => {
return this.overrides?.eachMonthOfInterval
? this.overrides.eachMonthOfInterval(interval)
: eachMonthOfInterval_eachMonthOfInterval(interval);
};
/**
* Returns the years between the given dates.
*
* @since 9.11.1
* @param interval The interval to get the years for.
* @returns The array of years in the interval.
*/
this.eachYearOfInterval = (interval) => {
const years = this.overrides?.eachYearOfInterval
? this.overrides.eachYearOfInterval(interval)
: eachYearOfInterval(interval);
// Remove duplicates that may happen across DST transitions (e.g., "America/Sao_Paulo")
// See https://github.com/date-fns/tz/issues/72
const uniqueYears = new Set(years.map((d) => this.getYear(d)));
if (uniqueYears.size === years.length) {
// No duplicates, return as is
return years;
}
// Rebuild the array to ensure one date per year
const yearsArray = [];
uniqueYears.forEach((y) => {
yearsArray.push(new Date(y, 0, 1));
});
return yearsArray;
};
/**
* Returns the end of the broadcast week for the given date.
*
* @param date The original date.
* @returns The end of the broadcast week.
*/
this.endOfBroadcastWeek = (date) => {
return this.overrides?.endOfBroadcastWeek
? this.overrides.endOfBroadcastWeek(date)
: endOfBroadcastWeek(date, this);
};
/**
* Returns the end of the ISO week for the given date.
*
* @param date The original date.
* @returns The end of the ISO week.
*/
this.endOfISOWeek = (date) => {
return this.overrides?.endOfISOWeek
? this.overrides.endOfISOWeek(date)
: endOfISOWeek(date);
};
/**
* Returns the end of the month for the given date.
*
* @param date The original date.
* @returns The end of the month.
*/
this.endOfMonth = (date) => {
return this.overrides?.endOfMonth
? this.overrides.endOfMonth(date)
: endOfMonth_endOfMonth(date);
};
/**
* Returns the end of the week for the given date.
*
* @param date The original date.
* @returns The end of the week.
*/
this.endOfWeek = (date, options) => {
return this.overrides?.endOfWeek
? this.overrides.endOfWeek(date, options)
: endOfWeek_endOfWeek(date, this.options);
};
/**
* Returns the end of the year for the given date.
*
* @param date The original date.
* @returns The end of the year.
*/
this.endOfYear = (date) => {
return this.overrides?.endOfYear
? this.overrides.endOfYear(date)
: endOfYear(date);
};
/**
* Formats the given date using the specified format string.
*
* @param date The date to format.
* @param formatStr The format string.
* @returns The formatted date string.
*/
this.format = (date, formatStr, _options) => {
const formatted = this.overrides?.format
? this.overrides.format(date, formatStr, this.options)
: format_format(date, formatStr, this.options);
if (this.options.numerals && this.options.numerals !== "latn") {
return this.replaceDigits(formatted);
}
return formatted;
};
/**
* Returns the ISO week number for the given date.
*
* @param date The date to get the ISO week number for.
* @returns The ISO week number.
*/
this.getISOWeek = (date) => {
return this.overrides?.getISOWeek
? this.overrides.getISOWeek(date)
: getISOWeek_getISOWeek(date);
};
/**
* Returns the month of the given date.
*
* @param date The date to get the month for.
* @returns The month.
*/
this.getMonth = (date, _options) => {
return this.overrides?.getMonth
? this.overrides.getMonth(date, this.options)
: getMonth(date, this.options);
};
/**
* Returns the year of the given date.
*
* @param date The date to get the year for.
* @returns The year.
*/
this.getYear = (date, _options) => {
return this.overrides?.getYear
? this.overrides.getYear(date, this.options)
: getYear(date, this.options);
};
/**
* Returns the local week number for the given date.
*
* @param date The date to get the week number for.
* @returns The week number.
*/
this.getWeek = (date, _options) => {
return this.overrides?.getWeek
? this.overrides.getWeek(date, this.options)
: getWeek_getWeek(date, this.options);
};
/**
* Checks if the first date is after the second date.
*
* @param date The date to compare.
* @param dateToCompare The date to compare with.
* @returns True if the first date is after the second date.
*/
this.isAfter = (date, dateToCompare) => {
return this.overrides?.isAfter
? this.overrides.isAfter(date, dateToCompare)
: isAfter_isAfter(date, dateToCompare);
};
/**
* Checks if the first date is before the second date.
*
* @param date The date to compare.
* @param dateToCompare The date to compare with.
* @returns True if the first date is before the second date.
*/
this.isBefore = (date, dateToCompare) => {
return this.overrides?.isBefore
? this.overrides.isBefore(date, dateToCompare)
: isBefore_isBefore(date, dateToCompare);
};
/**
* Checks if the given value is a Date object.
*
* @param value The value to check.
* @returns True if the value is a Date object.
*/
this.isDate = (value) => {
return this.overrides?.isDate
? this.overrides.isDate(value)
: isDate_isDate(value);
};
/**
* Checks if the given dates are on the same day.
*
* @param dateLeft The first date to compare.
* @param dateRight The second date to compare.
* @returns True if the dates are on the same day.
*/
this.isSameDay = (dateLeft, dateRight) => {
return this.overrides?.isSameDay
? this.overrides.isSameDay(dateLeft, dateRight)
: isSameDay_isSameDay(dateLeft, dateRight);
};
/**
* Checks if the given dates are in the same month.
*
* @param dateLeft The first date to compare.
* @param dateRight The second date to compare.
* @returns True if the dates are in the same month.
*/
this.isSameMonth = (dateLeft, dateRight) => {
return this.overrides?.isSameMonth
? this.overrides.isSameMonth(dateLeft, dateRight)
: isSameMonth_isSameMonth(dateLeft, dateRight);
};
/**
* Checks if the given dates are in the same year.
*
* @param dateLeft The first date to compare.
* @param dateRight The second date to compare.
* @returns True if the dates are in the same year.
*/
this.isSameYear = (dateLeft, dateRight) => {
return this.overrides?.isSameYear
? this.overrides.isSameYear(dateLeft, dateRight)
: isSameYear(dateLeft, dateRight);
};
/**
* Returns the latest date in the given array of dates.
*
* @param dates The array of dates to compare.
* @returns The latest date.
*/
this.max = (dates) => {
return this.overrides?.max ? this.overrides.max(dates) : max_max(dates);
};
/**
* Returns the earliest date in the given array of dates.
*
* @param dates The array of dates to compare.
* @returns The earliest date.
*/
this.min = (dates) => {
return this.overrides?.min ? this.overrides.min(dates) : min_min(dates);
};
/**
* Sets the month of the given date.
*
* @param date The date to set the month on.
* @param month The month to set (0-11).
* @returns The new date with the month set.
*/
this.setMonth = (date, month) => {
return this.overrides?.setMonth
? this.overrides.setMonth(date, month)
: setMonth_setMonth(date, month);
};
/**
* Sets the year of the given date.
*
* @param date The date to set the year on.
* @param year The year to set.
* @returns The new date with the year set.
*/
this.setYear = (date, year) => {
return this.overrides?.setYear
? this.overrides.setYear(date, year)
: setYear_setYear(date, year);
};
/**
* Returns the start of the broadcast week for the given date.
*
* @param date The original date.
* @returns The start of the broadcast week.
*/
this.startOfBroadcastWeek = (date, _dateLib) => {
return this.overrides?.startOfBroadcastWeek
? this.overrides.startOfBroadcastWeek(date, this)
: startOfBroadcastWeek(date, this);
};
/**
* Returns the start of the day for the given date.
*
* @param date The original date.
* @returns The start of the day.
*/
this.startOfDay = (date) => {
return this.overrides?.startOfDay
? this.overrides.startOfDay(date)
: startOfDay_startOfDay(date);
};
/**
* Returns the start of the ISO week for the given date.
*
* @param date The original date.
* @returns The start of the ISO week.
*/
this.startOfISOWeek = (date) => {
return this.overrides?.startOfISOWeek
? this.overrides.startOfISOWeek(date)
: startOfISOWeek_startOfISOWeek(date);
};
/**
* Returns the start of the month for the given date.
*
* @param date The original date.
* @returns The start of the month.
*/
this.startOfMonth = (date) => {
return this.overrides?.startOfMonth
? this.overrides.startOfMonth(date)
: startOfMonth_startOfMonth(date);
};
/**
* Returns the start of the week for the given date.
*
* @param date The original date.
* @returns The start of the week.
*/
this.startOfWeek = (date, _options) => {
return this.overrides?.startOfWeek
? this.overrides.startOfWeek(date, this.options)
: startOfWeek_startOfWeek(date, this.options);
};
/**
* Returns the start of the year for the given date.
*
* @param date The original date.
* @returns The start of the year.
*/
this.startOfYear = (date) => {
return this.overrides?.startOfYear
? this.overrides.startOfYear(date)
: startOfYear_startOfYear(date);
};
this.options = { locale: en_US_enUS, ...options };
this.overrides = overrides;
}
/**
* Generates a mapping of Arabic digits (0-9) to the target numbering system
* digits.
*
* @since 9.5.0
* @returns A record mapping Arabic digits to the target numerals.
*/
getDigitMap() {
const { numerals = "latn" } = this.options;
// Use Intl.NumberFormat to create a formatter with the specified numbering system
const formatter = new Intl.NumberFormat("en-US", {
numberingSystem: numerals,
});
// Map Arabic digits (0-9) to the target numerals
const digitMap = {};
for (let i = 0; i < 10; i++) {
digitMap[i.toString()] = formatter.format(i);
}
return digitMap;
}
/**
* Replaces Arabic digits in a string with the target numbering system digits.
*
* @since 9.5.0
* @param input The string containing Arabic digits.
* @returns The string with digits replaced.
*/
replaceDigits(input) {
const digitMap = this.getDigitMap();
return input.replace(/\d/g, (digit) => digitMap[digit] || digit);
}
/**
* Formats a number using the configured numbering system.
*
* @since 9.5.0
* @param value The number to format.
* @returns The formatted number as a string.
*/
formatNumber(value) {
return this.replaceDigits(value.toString());
}
/**
* Returns the preferred ordering for month and year labels for the current
* locale.
*/
getMonthYearOrder() {
const code = this.options.locale?.code;
if (!code) {
return "month-first";
}
return DateLib.yearFirstLocales.has(code) ? "year-first" : "month-first";
}
/**
* Formats the month/year pair respecting locale conventions.
*
* @since 9.11.0
*/
formatMonthYear(date) {
const { locale, timeZone, numerals } = this.options;
const localeCode = locale?.code;
if (localeCode && DateLib.yearFirstLocales.has(localeCode)) {
try {
const intl = new Intl.DateTimeFormat(localeCode, {
month: "long",
year: "numeric",
timeZone,
numberingSystem: numerals,
});
const formatted = intl.format(date);
return formatted;
}
catch {
// Fallback to date-fns formatting below.
}
}
const pattern = this.getMonthYearOrder() === "year-first" ? "y LLLL" : "LLLL y";
return this.format(date, pattern);
}
}
DateLib.yearFirstLocales = new Set([
"eu",
"hu",
"ja",
"ja-Hira",
"ja-JP",
"ko",
"ko-KR",
"lt",
"lt-LT",
"lv",
"lv-LV",
"mn",
"mn-MN",
"zh",
"zh-CN",
"zh-HK",
"zh-TW",
]);
/** The default locale (English). */
/**
* The default date library with English locale.
*
* @since 9.2.0
*/
const DateLib_defaultDateLib = new DateLib();
/**
* @ignore
* @deprecated Use `defaultDateLib`.
*/
const dateLib = (/* unused pure expression or super */ null && (DateLib_defaultDateLib));
;// ./node_modules/react-day-picker/dist/esm/UI.js
/**
* Enum representing the UI elements composing DayPicker. These elements are
* mapped to {@link CustomComponents}, {@link ClassNames}, and {@link Styles}.
*
* Some elements are extended by flags and modifiers.
*/
var UI_UI;
(function (UI) {
/** The root component displaying the months and the navigation bar. */
UI["Root"] = "root";
/** The Chevron SVG element used by navigation buttons and dropdowns. */
UI["Chevron"] = "chevron";
/**
* The grid cell with the day's date. Extended by {@link DayFlag} and
* {@link SelectionState}.
*/
UI["Day"] = "day";
/** The button containing the formatted day's date, inside the grid cell. */
UI["DayButton"] = "day_button";
/** The caption label of the month (when not showing the dropdown navigation). */
UI["CaptionLabel"] = "caption_label";
/** The container of the dropdown navigation (when enabled). */
UI["Dropdowns"] = "dropdowns";
/** The dropdown element to select for years and months. */
UI["Dropdown"] = "dropdown";
/** The container element of the dropdown. */
UI["DropdownRoot"] = "dropdown_root";
/** The root element of the footer. */
UI["Footer"] = "footer";
/** The month grid. */
UI["MonthGrid"] = "month_grid";
/** Contains the dropdown navigation or the caption label. */
UI["MonthCaption"] = "month_caption";
/** The dropdown with the months. */
UI["MonthsDropdown"] = "months_dropdown";
/** Wrapper of the month grid. */
UI["Month"] = "month";
/** The container of the displayed months. */
UI["Months"] = "months";
/** The navigation bar with the previous and next buttons. */
UI["Nav"] = "nav";
/**
* The next month button in the navigation. *
*
* @since 9.1.0
*/
UI["NextMonthButton"] = "button_next";
/**
* The previous month button in the navigation.
*
* @since 9.1.0
*/
UI["PreviousMonthButton"] = "button_previous";
/** The row containing the week. */
UI["Week"] = "week";
/** The group of row weeks in a month (`tbody`). */
UI["Weeks"] = "weeks";
/** The column header with the weekday. */
UI["Weekday"] = "weekday";
/** The row grouping the weekdays in the column headers. */
UI["Weekdays"] = "weekdays";
/** The cell containing the week number. */
UI["WeekNumber"] = "week_number";
/** The cell header of the week numbers column. */
UI["WeekNumberHeader"] = "week_number_header";
/** The dropdown with the years. */
UI["YearsDropdown"] = "years_dropdown";
})(UI_UI || (UI_UI = {}));
/** Enum representing flags for the {@link UI.Day} element. */
var DayFlag;
(function (DayFlag) {
/** The day is disabled. */
DayFlag["disabled"] = "disabled";
/** The day is hidden. */
DayFlag["hidden"] = "hidden";
/** The day is outside the current month. */
DayFlag["outside"] = "outside";
/** The day is focused. */
DayFlag["focused"] = "focused";
/** The day is today. */
DayFlag["today"] = "today";
})(DayFlag || (DayFlag = {}));
/**
* Enum representing selection states that can be applied to the {@link UI.Day}
* element in selection mode.
*/
var SelectionState;
(function (SelectionState) {
/** The day is at the end of a selected range. */
SelectionState["range_end"] = "range_end";
/** The day is at the middle of a selected range. */
SelectionState["range_middle"] = "range_middle";
/** The day is at the start of a selected range. */
SelectionState["range_start"] = "range_start";
/** The day is selected. */
SelectionState["selected"] = "selected";
})(SelectionState || (SelectionState = {}));
/**
* Enum representing different animation states for transitioning between
* months.
*/
var Animation;
(function (Animation) {
/** The entering weeks when they appear before the exiting month. */
Animation["weeks_before_enter"] = "weeks_before_enter";
/** The exiting weeks when they disappear before the entering month. */
Animation["weeks_before_exit"] = "weeks_before_exit";
/** The entering weeks when they appear after the exiting month. */
Animation["weeks_after_enter"] = "weeks_after_enter";
/** The exiting weeks when they disappear after the entering month. */
Animation["weeks_after_exit"] = "weeks_after_exit";
/** The entering caption when it appears after the exiting month. */
Animation["caption_after_enter"] = "caption_after_enter";
/** The exiting caption when it disappears after the entering month. */
Animation["caption_after_exit"] = "caption_after_exit";
/** The entering caption when it appears before the exiting month. */
Animation["caption_before_enter"] = "caption_before_enter";
/** The exiting caption when it disappears before the entering month. */
Animation["caption_before_exit"] = "caption_before_exit";
})(Animation || (Animation = {}));
;// ./node_modules/react-day-picker/dist/esm/utils/rangeIncludesDate.js
/**
* Checks if a given date is within a specified date range.
*
* @since 9.0.0
* @param range - The date range to check against.
* @param date - The date to check.
* @param excludeEnds - If `true`, the range's start and end dates are excluded.
* @param dateLib - The date utility library instance.
* @returns `true` if the date is within the range, otherwise `false`.
* @group Utilities
*/
function rangeIncludesDate(range, date, excludeEnds = false, dateLib = DateLib_defaultDateLib) {
let { from, to } = range;
const { differenceInCalendarDays, isSameDay } = dateLib;
if (from && to) {
const isRangeInverted = differenceInCalendarDays(to, from) < 0;
if (isRangeInverted) {
[from, to] = [to, from];
}
const isInRange = differenceInCalendarDays(date, from) >= (excludeEnds ? 1 : 0) &&
differenceInCalendarDays(to, date) >= (excludeEnds ? 1 : 0);
return isInRange;
}
if (!excludeEnds && to) {
return isSameDay(to, date);
}
if (!excludeEnds && from) {
return isSameDay(from, date);
}
return false;
}
/**
* @private
* @deprecated Use {@link rangeIncludesDate} instead.
*/
const isDateInRange = (range, date) => rangeIncludesDate(range, date, false, defaultDateLib);
;// ./node_modules/react-day-picker/dist/esm/utils/typeguards.js
/**
* Checks if the given value is of type {@link DateInterval}.
*
* @param matcher - The value to check.
* @returns `true` if the value is a {@link DateInterval}, otherwise `false`.
* @group Utilities
*/
function isDateInterval(matcher) {
return Boolean(matcher &&
typeof matcher === "object" &&
"before" in matcher &&
"after" in matcher);
}
/**
* Checks if the given value is of type {@link DateRange}.
*
* @param value - The value to check.
* @returns `true` if the value is a {@link DateRange}, otherwise `false`.
* @group Utilities
*/
function isDateRange(value) {
return Boolean(value && typeof value === "object" && "from" in value);
}
/**
* Checks if the given value is of type {@link DateAfter}.
*
* @param value - The value to check.
* @returns `true` if the value is a {@link DateAfter}, otherwise `false`.
* @group Utilities
*/
function isDateAfterType(value) {
return Boolean(value && typeof value === "object" && "after" in value);
}
/**
* Checks if the given value is of type {@link DateBefore}.
*
* @param value - The value to check.
* @returns `true` if the value is a {@link DateBefore}, otherwise `false`.
* @group Utilities
*/
function isDateBeforeType(value) {
return Boolean(value && typeof value === "object" && "before" in value);
}
/**
* Checks if the given value is of type {@link DayOfWeek}.
*
* @param value - The value to check.
* @returns `true` if the value is a {@link DayOfWeek}, otherwise `false`.
* @group Utilities
*/
function isDayOfWeekType(value) {
return Boolean(value && typeof value === "object" && "dayOfWeek" in value);
}
/**
* Checks if the given value is an array of valid dates.
*
* @private
* @param value - The value to check.
* @param dateLib - The date utility library instance.
* @returns `true` if the value is an array of valid dates, otherwise `false`.
*/
function isDatesArray(value, dateLib) {
return Array.isArray(value) && value.every(dateLib.isDate);
}
;// ./node_modules/react-day-picker/dist/esm/utils/dateMatchModifiers.js
/**
* Checks if a given date matches at least one of the specified {@link Matcher}.
*
* @param date - The date to check.
* @param matchers - The matchers to check against.
* @param dateLib - The date utility library instance.
* @returns `true` if the date matches any of the matchers, otherwise `false`.
* @group Utilities
*/
function dateMatchModifiers(date, matchers, dateLib = DateLib_defaultDateLib) {
const matchersArr = !Array.isArray(matchers) ? [matchers] : matchers;
const { isSameDay, differenceInCalendarDays, isAfter } = dateLib;
return matchersArr.some((matcher) => {
if (typeof matcher === "boolean") {
return matcher;
}
if (dateLib.isDate(matcher)) {
return isSameDay(date, matcher);
}
if (isDatesArray(matcher, dateLib)) {
return matcher.includes(date);
}
if (isDateRange(matcher)) {
return rangeIncludesDate(matcher, date, false, dateLib);
}
if (isDayOfWeekType(matcher)) {
if (!Array.isArray(matcher.dayOfWeek)) {
return matcher.dayOfWeek === date.getDay();
}
return matcher.dayOfWeek.includes(date.getDay());
}
if (isDateInterval(matcher)) {
const diffBefore = differenceInCalendarDays(matcher.before, date);
const diffAfter = differenceInCalendarDays(matcher.after, date);
const isDayBefore = diffBefore > 0;
const isDayAfter = diffAfter < 0;
const isClosedInterval = isAfter(matcher.before, matcher.after);
if (isClosedInterval) {
return isDayAfter && isDayBefore;
}
else {
return isDayBefore || isDayAfter;
}
}
if (isDateAfterType(matcher)) {
return differenceInCalendarDays(date, matcher.after) > 0;
}
if (isDateBeforeType(matcher)) {
return differenceInCalendarDays(matcher.before, date) > 0;
}
if (typeof matcher === "function") {
return matcher(date);
}
return false;
});
}
/**
* @private
* @deprecated Use {@link dateMatchModifiers} instead.
*/
const isMatch = (/* unused pure expression or super */ null && (dateMatchModifiers));
;// ./node_modules/react-day-picker/dist/esm/helpers/createGetModifiers.js
/**
* Creates a function to retrieve the modifiers for a given day.
*
* This function calculates both internal and custom modifiers for each day
* based on the provided calendar days and DayPicker props.
*
* @private
* @param days The array of `CalendarDay` objects to process.
* @param props The DayPicker props, including modifiers and configuration
* options.
* @param dateLib The date library to use for date manipulation.
* @returns A function that retrieves the modifiers for a given `CalendarDay`.
*/
function createGetModifiers(days, props, navStart, navEnd, dateLib) {
const { disabled, hidden, modifiers, showOutsideDays, broadcastCalendar, today, } = props;
const { isSameDay, isSameMonth, startOfMonth, isBefore, endOfMonth, isAfter, } = dateLib;
const computedNavStart = navStart && startOfMonth(navStart);
const computedNavEnd = navEnd && endOfMonth(navEnd);
const internalModifiersMap = {
[DayFlag.focused]: [],
[DayFlag.outside]: [],
[DayFlag.disabled]: [],
[DayFlag.hidden]: [],
[DayFlag.today]: [],
};
const customModifiersMap = {};
for (const day of days) {
const { date, displayMonth } = day;
const isOutside = Boolean(displayMonth && !isSameMonth(date, displayMonth));
const isBeforeNavStart = Boolean(computedNavStart && isBefore(date, computedNavStart));
const isAfterNavEnd = Boolean(computedNavEnd && isAfter(date, computedNavEnd));
const isDisabled = Boolean(disabled && dateMatchModifiers(date, disabled, dateLib));
const isHidden = Boolean(hidden && dateMatchModifiers(date, hidden, dateLib)) ||
isBeforeNavStart ||
isAfterNavEnd ||
// Broadcast calendar will show outside days as default
(!broadcastCalendar && !showOutsideDays && isOutside) ||
(broadcastCalendar && showOutsideDays === false && isOutside);
const isToday = isSameDay(date, today ?? dateLib.today());
if (isOutside)
internalModifiersMap.outside.push(day);
if (isDisabled)
internalModifiersMap.disabled.push(day);
if (isHidden)
internalModifiersMap.hidden.push(day);
if (isToday)
internalModifiersMap.today.push(day);
// Add custom modifiers
if (modifiers) {
Object.keys(modifiers).forEach((name) => {
const modifierValue = modifiers?.[name];
const isMatch = modifierValue
? dateMatchModifiers(date, modifierValue, dateLib)
: false;
if (!isMatch)
return;
if (customModifiersMap[name]) {
customModifiersMap[name].push(day);
}
else {
customModifiersMap[name] = [day];
}
});
}
}
return (day) => {
// Initialize all the modifiers to false
const dayFlags = {
[DayFlag.focused]: false,
[DayFlag.disabled]: false,
[DayFlag.hidden]: false,
[DayFlag.outside]: false,
[DayFlag.today]: false,
};
const customModifiers = {};
// Find the modifiers for the given day
for (const name in internalModifiersMap) {
const days = internalModifiersMap[name];
dayFlags[name] = days.some((d) => d === day);
}
for (const name in customModifiersMap) {
customModifiers[name] = customModifiersMap[name].some((d) => d === day);
}
return {
...dayFlags,
// custom modifiers should override all the previous ones
...customModifiers,
};
};
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getClassNamesForModifiers.js
/**
* Returns the class names for a day based on its modifiers.
*
* This function combines the base class name for the day with any class names
* associated with active modifiers.
*
* @param modifiers The modifiers applied to the day.
* @param classNames The base class names for the calendar elements.
* @param modifiersClassNames The class names associated with specific
* modifiers.
* @returns An array of class names for the day.
*/
function getClassNamesForModifiers(modifiers, classNames, modifiersClassNames = {}) {
const modifierClassNames = Object.entries(modifiers)
.filter(([, active]) => active === true)
.reduce((previousValue, [key]) => {
if (modifiersClassNames[key]) {
previousValue.push(modifiersClassNames[key]);
}
else if (classNames[DayFlag[key]]) {
previousValue.push(classNames[DayFlag[key]]);
}
else if (classNames[SelectionState[key]]) {
previousValue.push(classNames[SelectionState[key]]);
}
return previousValue;
}, [classNames[UI_UI.Day]]);
return modifierClassNames;
}
;// ./node_modules/react-day-picker/dist/esm/components/Button.js
/**
* Render the button elements in the calendar.
*
* @private
* @deprecated Use `PreviousMonthButton` or `@link NextMonthButton` instead.
*/
function Button_Button(props) {
return external_React_.createElement("button", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/CaptionLabel.js
/**
* Render the label in the month caption.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function CaptionLabel(props) {
return external_React_.createElement("span", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Chevron.js
/**
* Render the chevron icon used in the navigation buttons and dropdowns.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Chevron(props) {
const { size = 24, orientation = "left", className } = props;
return (
// biome-ignore lint/a11y/noSvgWithoutTitle: handled by the parent component
external_React_.createElement("svg", { className: className, width: size, height: size, viewBox: "0 0 24 24" },
orientation === "up" && (external_React_.createElement("polygon", { points: "6.77 17 12.5 11.43 18.24 17 20 15.28 12.5 8 5 15.28" })),
orientation === "down" && (external_React_.createElement("polygon", { points: "6.77 8 12.5 13.57 18.24 8 20 9.72 12.5 17 5 9.72" })),
orientation === "left" && (external_React_.createElement("polygon", { points: "16 18.112 9.81111111 12 16 5.87733333 14.0888889 4 6 12 14.0888889 20" })),
orientation === "right" && (external_React_.createElement("polygon", { points: "8 18.112 14.18888889 12 8 5.87733333 9.91111111 4 18 12 9.91111111 20" }))));
}
;// ./node_modules/react-day-picker/dist/esm/components/Day.js
/**
* Render a grid cell for a specific day in the calendar.
*
* Handles interaction and focus for the day. If you only need to change the
* content of the day cell, consider swapping the `DayButton` component
* instead.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Day_Day(props) {
const { day, modifiers, ...tdProps } = props;
return external_React_.createElement("td", { ...tdProps });
}
;// ./node_modules/react-day-picker/dist/esm/components/DayButton.js
/**
* Render a button for a specific day in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function DayButton_DayButton(props) {
const { day, modifiers, ...buttonProps } = props;
const ref = external_React_.useRef(null);
external_React_.useEffect(() => {
if (modifiers.focused)
ref.current?.focus();
}, [modifiers.focused]);
return external_React_.createElement("button", { ref: ref, ...buttonProps });
}
;// ./node_modules/react-day-picker/dist/esm/components/Dropdown.js
/**
* Render a dropdown component for navigation in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Dropdown_Dropdown(props) {
const { options, className, components, classNames, ...selectProps } = props;
const cssClassSelect = [classNames[UI_UI.Dropdown], className].join(" ");
const selectedOption = options?.find(({ value }) => value === selectProps.value);
return (external_React_.createElement("span", { "data-disabled": selectProps.disabled, className: classNames[UI_UI.DropdownRoot] },
external_React_.createElement(components.Select, { className: cssClassSelect, ...selectProps }, options?.map(({ value, label, disabled }) => (external_React_.createElement(components.Option, { key: value, value: value, disabled: disabled }, label)))),
external_React_.createElement("span", { className: classNames[UI_UI.CaptionLabel], "aria-hidden": true },
selectedOption?.label,
external_React_.createElement(components.Chevron, { orientation: "down", size: 18, className: classNames[UI_UI.Chevron] }))));
}
;// ./node_modules/react-day-picker/dist/esm/components/DropdownNav.js
/**
* Render the navigation dropdowns for the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function DropdownNav(props) {
return external_React_.createElement("div", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Footer.js
/**
* Render the footer of the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Footer_Footer(props) {
return external_React_.createElement("div", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Month.js
/**
* Render the grid with the weekday header row and the weeks for a specific
* month.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Month_Month(props) {
const { calendarMonth, displayIndex, ...divProps } = props;
return external_React_.createElement("div", { ...divProps }, props.children);
}
;// ./node_modules/react-day-picker/dist/esm/components/MonthCaption.js
/**
* Render the caption for a month in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function MonthCaption(props) {
const { calendarMonth, displayIndex, ...divProps } = props;
return external_React_.createElement("div", { ...divProps });
}
;// ./node_modules/react-day-picker/dist/esm/components/MonthGrid.js
/**
* Render the grid of days for a specific month.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function MonthGrid(props) {
return external_React_.createElement("table", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Months.js
/**
* Render a container wrapping the month grids.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Months(props) {
return external_React_.createElement("div", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/useDayPicker.js
/** @ignore */
const dayPickerContext = (0,external_React_.createContext)(undefined);
/**
* Provides access to the DayPicker context, which includes properties and
* methods to interact with the DayPicker component. This hook must be used
* within a custom component.
*
* @template T - Use this type to refine the returned context type with a
* specific selection mode.
* @returns The context to work with DayPicker.
* @throws {Error} If the hook is used outside of a DayPicker provider.
* @group Hooks
* @see https://daypicker.dev/guides/custom-components
*/
function useDayPicker() {
const context = (0,external_React_.useContext)(dayPickerContext);
if (context === undefined) {
throw new Error("useDayPicker() must be used within a custom component.");
}
return context;
}
;// ./node_modules/react-day-picker/dist/esm/components/MonthsDropdown.js
/**
* Render a dropdown to navigate between months in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function MonthsDropdown(props) {
const { components } = useDayPicker();
return external_React_.createElement(components.Dropdown, { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Nav.js
/**
* Render the navigation toolbar with buttons to navigate between months.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Nav(props) {
const { onPreviousClick, onNextClick, previousMonth, nextMonth, ...navProps } = props;
const { components, classNames, labels: { labelPrevious, labelNext }, } = useDayPicker();
const handleNextClick = (0,external_React_.useCallback)((e) => {
if (nextMonth) {
onNextClick?.(e);
}
}, [nextMonth, onNextClick]);
const handlePreviousClick = (0,external_React_.useCallback)((e) => {
if (previousMonth) {
onPreviousClick?.(e);
}
}, [previousMonth, onPreviousClick]);
return (external_React_.createElement("nav", { ...navProps },
external_React_.createElement(components.PreviousMonthButton, { type: "button", className: classNames[UI_UI.PreviousMonthButton], tabIndex: previousMonth ? undefined : -1, "aria-disabled": previousMonth ? undefined : true, "aria-label": labelPrevious(previousMonth), onClick: handlePreviousClick },
external_React_.createElement(components.Chevron, { disabled: previousMonth ? undefined : true, className: classNames[UI_UI.Chevron], orientation: "left" })),
external_React_.createElement(components.NextMonthButton, { type: "button", className: classNames[UI_UI.NextMonthButton], tabIndex: nextMonth ? undefined : -1, "aria-disabled": nextMonth ? undefined : true, "aria-label": labelNext(nextMonth), onClick: handleNextClick },
external_React_.createElement(components.Chevron, { disabled: nextMonth ? undefined : true, orientation: "right", className: classNames[UI_UI.Chevron] }))));
}
;// ./node_modules/react-day-picker/dist/esm/components/NextMonthButton.js
/**
* Render the button to navigate to the next month in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function NextMonthButton(props) {
const { components } = useDayPicker();
return external_React_.createElement(components.Button, { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Option.js
/**
* Render an `option` element.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Option_Option(props) {
return external_React_.createElement("option", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/PreviousMonthButton.js
/**
* Render the button to navigate to the previous month in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function PreviousMonthButton(props) {
const { components } = useDayPicker();
return external_React_.createElement(components.Button, { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Root.js
/**
* Render the root element of the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Root_Root(props) {
const { rootRef, ...rest } = props;
return external_React_.createElement("div", { ...rest, ref: rootRef });
}
;// ./node_modules/react-day-picker/dist/esm/components/Select.js
/**
* Render a `select` element.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Select_Select(props) {
return external_React_.createElement("select", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Week.js
/**
* Render a table row representing a week in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Week(props) {
const { week, ...trProps } = props;
return external_React_.createElement("tr", { ...trProps });
}
;// ./node_modules/react-day-picker/dist/esm/components/Weekday.js
/**
* Render a table header cell with the name of a weekday (e.g., "Mo", "Tu").
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Weekday(props) {
return external_React_.createElement("th", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Weekdays.js
/**
* Render the table row containing the weekday names.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Weekdays(props) {
return (external_React_.createElement("thead", { "aria-hidden": true },
external_React_.createElement("tr", { ...props })));
}
;// ./node_modules/react-day-picker/dist/esm/components/WeekNumber.js
/**
* Render a table cell displaying the number of the week.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function WeekNumber(props) {
const { week, ...thProps } = props;
return external_React_.createElement("th", { ...thProps });
}
;// ./node_modules/react-day-picker/dist/esm/components/WeekNumberHeader.js
/**
* Render the header cell for the week numbers column.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function WeekNumberHeader(props) {
return external_React_.createElement("th", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/Weeks.js
/**
* Render the container for the weeks in the month grid.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function Weeks(props) {
return external_React_.createElement("tbody", { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/YearsDropdown.js
/**
* Render a dropdown to navigate between years in the calendar.
*
* @group Components
* @see https://daypicker.dev/guides/custom-components
*/
function YearsDropdown(props) {
const { components } = useDayPicker();
return external_React_.createElement(components.Dropdown, { ...props });
}
;// ./node_modules/react-day-picker/dist/esm/components/custom-components.js
;// ./node_modules/react-day-picker/dist/esm/helpers/getComponents.js
/**
* Merges custom components from the props with the default components.
*
* This function ensures that any custom components provided in the props
* override the default components.
*
* @param customComponents The custom components provided in the DayPicker
* props.
* @returns An object containing the merged components.
*/
function getComponents(customComponents) {
return {
...custom_components_namespaceObject,
...customComponents,
};
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getDataAttributes.js
/**
* Extracts `data-` attributes from the DayPicker props.
*
* This function collects all `data-` attributes from the props and adds
* additional attributes based on the DayPicker configuration.
*
* @param props The DayPicker props.
* @returns An object containing the `data-` attributes.
*/
function getDataAttributes(props) {
const dataAttributes = {
"data-mode": props.mode ?? undefined,
"data-required": "required" in props ? props.required : undefined,
"data-multiple-months": (props.numberOfMonths && props.numberOfMonths > 1) || undefined,
"data-week-numbers": props.showWeekNumber || undefined,
"data-broadcast-calendar": props.broadcastCalendar || undefined,
"data-nav-layout": props.navLayout || undefined,
};
Object.entries(props).forEach(([key, val]) => {
if (key.startsWith("data-")) {
dataAttributes[key] = val;
}
});
return dataAttributes;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getDefaultClassNames.js
/**
* Returns the default class names for the UI elements.
*
* This function generates a mapping of default class names for various UI
* elements, day flags, selection states, and animations.
*
* @returns An object containing the default class names.
* @group Utilities
*/
function getDefaultClassNames() {
const classNames = {};
for (const key in UI_UI) {
classNames[UI_UI[key]] =
`rdp-${UI_UI[key]}`;
}
for (const key in DayFlag) {
classNames[DayFlag[key]] =
`rdp-${DayFlag[key]}`;
}
for (const key in SelectionState) {
classNames[SelectionState[key]] =
`rdp-${SelectionState[key]}`;
}
for (const key in Animation) {
classNames[Animation[key]] =
`rdp-${Animation[key]}`;
}
return classNames;
}
;// ./node_modules/react-day-picker/dist/esm/formatters/formatCaption.js
/**
* Formats the caption of the month.
*
* @defaultValue Locale-specific month/year order (e.g., "November 2022").
* @param month The date representing the month.
* @param options Configuration options for the date library.
* @param dateLib The date library to use for formatting. If not provided, a new
* instance is created.
* @returns The formatted caption as a string.
* @group Formatters
* @see https://daypicker.dev/docs/translation#custom-formatters
*/
function formatCaption(month, options, dateLib) {
const lib = dateLib ?? new DateLib(options);
return lib.formatMonthYear(month);
}
/**
* @private
* @deprecated Use {@link formatCaption} instead.
* @group Formatters
*/
const formatMonthCaption = formatCaption;
;// ./node_modules/react-day-picker/dist/esm/formatters/formatDay.js
/**
* Formats the day date shown in the day cell.
*
* @defaultValue `d` (e.g., "1").
* @param date The date to format.
* @param options Configuration options for the date library.
* @param dateLib The date library to use for formatting. If not provided, a new
* instance is created.
* @returns The formatted day as a string.
* @group Formatters
* @see https://daypicker.dev/docs/translation#custom-formatters
*/
function formatDay(date, options, dateLib) {
return (dateLib ?? new DateLib(options)).format(date, "d");
}
;// ./node_modules/react-day-picker/dist/esm/formatters/formatMonthDropdown.js
/**
* Formats the month for the dropdown option label.
*
* @defaultValue The localized full month name.
* @param month The date representing the month.
* @param dateLib The date library to use for formatting. Defaults to
* `defaultDateLib`.
* @returns The formatted month name as a string.
* @group Formatters
* @see https://daypicker.dev/docs/translation#custom-formatters
*/
function formatMonthDropdown(month, dateLib = DateLib_defaultDateLib) {
return dateLib.format(month, "LLLL");
}
;// ./node_modules/react-day-picker/dist/esm/formatters/formatWeekdayName.js
/**
* Formats the name of a weekday to be displayed in the weekdays header.
*
* @defaultValue `cccccc` (e.g., "Mo" for Monday).
* @param weekday The date representing the weekday.
* @param options Configuration options for the date library.
* @param dateLib The date library to use for formatting. If not provided, a new
* instance is created.
* @returns The formatted weekday name as a string.
* @group Formatters
* @see https://daypicker.dev/docs/translation#custom-formatters
*/
function formatWeekdayName(weekday, options, dateLib) {
return (dateLib ?? new DateLib(options)).format(weekday, "cccccc");
}
;// ./node_modules/react-day-picker/dist/esm/formatters/formatWeekNumber.js
/**
* Formats the week number.
*
* @defaultValue The week number as a string, with a leading zero for single-digit numbers.
* @param weekNumber The week number to format.
* @param dateLib The date library to use for formatting. Defaults to
* `defaultDateLib`.
* @returns The formatted week number as a string.
* @group Formatters
* @see https://daypicker.dev/docs/translation#custom-formatters
*/
function formatWeekNumber(weekNumber, dateLib = DateLib_defaultDateLib) {
if (weekNumber < 10) {
return dateLib.formatNumber(`0${weekNumber.toLocaleString()}`);
}
return dateLib.formatNumber(`${weekNumber.toLocaleString()}`);
}
;// ./node_modules/react-day-picker/dist/esm/formatters/formatWeekNumberHeader.js
/**
* Formats the header for the week number column.
*
* @defaultValue An empty string `""`.
* @returns The formatted week number header as a string.
* @group Formatters
* @see https://daypicker.dev/docs/translation#custom-formatters
*/
function formatWeekNumberHeader() {
return ``;
}
;// ./node_modules/react-day-picker/dist/esm/formatters/formatYearDropdown.js
/**
* Formats the year for the dropdown option label.
*
* @param year The year to format.
* @param dateLib The date library to use for formatting. Defaults to
* `defaultDateLib`.
* @returns The formatted year as a string.
* @group Formatters
* @see https://daypicker.dev/docs/translation#custom-formatters
*/
function formatYearDropdown(year, dateLib = DateLib_defaultDateLib) {
return dateLib.format(year, "yyyy");
}
/**
* @private
* @deprecated Use `formatYearDropdown` instead.
* @group Formatters
*/
const formatYearCaption = formatYearDropdown;
;// ./node_modules/react-day-picker/dist/esm/formatters/index.js
;// ./node_modules/react-day-picker/dist/esm/helpers/getFormatters.js
/**
* Merges custom formatters from the props with the default formatters.
*
* @param customFormatters The custom formatters provided in the DayPicker
* props.
* @returns The merged formatters object.
*/
function getFormatters(customFormatters) {
if (customFormatters?.formatMonthCaption && !customFormatters.formatCaption) {
customFormatters.formatCaption = customFormatters.formatMonthCaption;
}
if (customFormatters?.formatYearCaption &&
!customFormatters.formatYearDropdown) {
customFormatters.formatYearDropdown = customFormatters.formatYearCaption;
}
return {
...esm_formatters_namespaceObject,
...customFormatters,
};
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getMonthOptions.js
/**
* Returns the months to show in the dropdown.
*
* This function generates a list of months for the current year, formatted
* using the provided formatter, and determines whether each month should be
* disabled based on the navigation range.
*
* @param displayMonth The currently displayed month.
* @param navStart The start date for navigation.
* @param navEnd The end date for navigation.
* @param formatters The formatters to use for formatting the month labels.
* @param dateLib The date library to use for date manipulation.
* @returns An array of dropdown options representing the months, or `undefined`
* if no months are available.
*/
function getMonthOptions(displayMonth, navStart, navEnd, formatters, dateLib) {
const { startOfMonth, startOfYear, endOfYear, eachMonthOfInterval, getMonth, } = dateLib;
const months = eachMonthOfInterval({
start: startOfYear(displayMonth),
end: endOfYear(displayMonth),
});
const options = months.map((month) => {
const label = formatters.formatMonthDropdown(month, dateLib);
const value = getMonth(month);
const disabled = (navStart && month < startOfMonth(navStart)) ||
(navEnd && month > startOfMonth(navEnd)) ||
false;
return { value, label, disabled };
});
return options;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getStyleForModifiers.js
/**
* Returns the computed style for a day based on its modifiers.
*
* This function merges the base styles for the day with any styles associated
* with active modifiers.
*
* @param dayModifiers The modifiers applied to the day.
* @param styles The base styles for the calendar elements.
* @param modifiersStyles The styles associated with specific modifiers.
* @returns The computed style for the day.
*/
function getStyleForModifiers(dayModifiers, styles = {}, modifiersStyles = {}) {
let style = { ...styles?.[UI_UI.Day] };
Object.entries(dayModifiers)
.filter(([, active]) => active === true)
.forEach(([modifier]) => {
style = {
...style,
...modifiersStyles?.[modifier],
};
});
return style;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getWeekdays.js
/**
* Generates a series of 7 days, starting from the beginning of the week, to use
* for formatting weekday names (e.g., Monday, Tuesday, etc.).
*
* @param dateLib The date library to use for date manipulation.
* @param ISOWeek Whether to use ISO week numbering (weeks start on Monday).
* @param broadcastCalendar Whether to use the broadcast calendar (weeks start
* on Monday, but may include adjustments for broadcast-specific rules).
* @returns An array of 7 dates representing the weekdays.
*/
function getWeekdays(dateLib, ISOWeek, broadcastCalendar) {
const today = dateLib.today();
const start = broadcastCalendar
? dateLib.startOfBroadcastWeek(today, dateLib)
: ISOWeek
? dateLib.startOfISOWeek(today)
: dateLib.startOfWeek(today);
const days = [];
for (let i = 0; i < 7; i++) {
const day = dateLib.addDays(start, i);
days.push(day);
}
return days;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getYearOptions.js
/**
* Returns the years to display in the dropdown.
*
* This function generates a list of years between the navigation start and end
* dates, formatted using the provided formatter.
*
* @param navStart The start date for navigation.
* @param navEnd The end date for navigation.
* @param formatters The formatters to use for formatting the year labels.
* @param dateLib The date library to use for date manipulation.
* @param reverse If true, reverses the order of the years (descending).
* @returns An array of dropdown options representing the years, or `undefined`
* if `navStart` or `navEnd` is not provided.
*/
function getYearOptions(navStart, navEnd, formatters, dateLib, reverse = false) {
if (!navStart)
return undefined;
if (!navEnd)
return undefined;
const { startOfYear, endOfYear, eachYearOfInterval, getYear } = dateLib;
const firstNavYear = startOfYear(navStart);
const lastNavYear = endOfYear(navEnd);
const years = eachYearOfInterval({ start: firstNavYear, end: lastNavYear });
if (reverse)
years.reverse();
return years.map((year) => {
const label = formatters.formatYearDropdown(year, dateLib);
return {
value: getYear(year),
label,
disabled: false,
};
});
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelDayButton.js
/**
* Generates the ARIA label for a day button.
*
* Use the `modifiers` argument to provide additional context for the label,
* such as indicating if the day is "today" or "selected."
*
* @defaultValue The formatted date.
* @param date - The date to format.
* @param modifiers - The modifiers providing context for the day.
* @param options - Optional configuration for the date formatting library.
* @param dateLib - An optional instance of the date formatting library.
* @returns The ARIA label for the day button.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelDayButton(date, modifiers, options, dateLib) {
let label = (dateLib ?? new DateLib(options)).format(date, "PPPP");
if (modifiers.today)
label = `Today, ${label}`;
if (modifiers.selected)
label = `${label}, selected`;
return label;
}
/**
* @ignore
* @deprecated Use `labelDayButton` instead.
*/
const labelDay = labelDayButton;
;// ./node_modules/react-day-picker/dist/esm/labels/labelGrid.js
/**
* Generates the ARIA label for the month grid, which is announced when entering
* the grid.
*
* @defaultValue Locale-specific month/year order (e.g., "November 2022").
* @param date - The date representing the month.
* @param options - Optional configuration for the date formatting library.
* @param dateLib - An optional instance of the date formatting library.
* @returns The ARIA label for the month grid.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelGrid(date, options, dateLib) {
const lib = dateLib ?? new DateLib(options);
return lib.formatMonthYear(date);
}
/**
* @ignore
* @deprecated Use {@link labelGrid} instead.
*/
const labelCaption = labelGrid;
;// ./node_modules/react-day-picker/dist/esm/labels/labelGridcell.js
/**
* Generates the label for a day grid cell when the calendar is not interactive.
*
* @param date - The date to format.
* @param modifiers - Optional modifiers providing context for the day.
* @param options - Optional configuration for the date formatting library.
* @param dateLib - An optional instance of the date formatting library.
* @returns The label for the day grid cell.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelGridcell(date, modifiers, options, dateLib) {
let label = (dateLib ?? new DateLib(options)).format(date, "PPPP");
if (modifiers?.today) {
label = `Today, ${label}`;
}
return label;
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelMonthDropdown.js
/**
* Generates the ARIA label for the months dropdown.
*
* @defaultValue `"Choose the Month"`
* @param options - Optional configuration for the date formatting library.
* @returns The ARIA label for the months dropdown.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelMonthDropdown(_options) {
return "Choose the Month";
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelNav.js
/**
* Generates the ARIA label for the navigation toolbar.
*
* @defaultValue `""`
* @returns The ARIA label for the navigation toolbar.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelNav() {
return "";
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelNext.js
/**
* Generates the ARIA label for the "next month" button.
*
* @defaultValue `"Go to the Next Month"`
* @param month - The date representing the next month, or `undefined` if there
* is no next month.
* @returns The ARIA label for the "next month" button.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelNext(_month) {
return "Go to the Next Month";
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelPrevious.js
/**
* Generates the ARIA label for the "previous month" button.
*
* @defaultValue `"Go to the Previous Month"`
* @param month - The date representing the previous month, or `undefined` if
* there is no previous month.
* @returns The ARIA label for the "previous month" button.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelPrevious(_month) {
return "Go to the Previous Month";
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelWeekday.js
/**
* Generates the ARIA label for a weekday column header.
*
* @defaultValue `"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"`
* @param date - The date representing the weekday.
* @param options - Optional configuration for the date formatting library.
* @param dateLib - An optional instance of the date formatting library.
* @returns The ARIA label for the weekday column header.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelWeekday(date, options, dateLib) {
return (dateLib ?? new DateLib(options)).format(date, "cccc");
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelWeekNumber.js
/**
* Generates the ARIA label for the week number cell (the first cell in a row).
*
* @defaultValue `Week ${weekNumber}`
* @param weekNumber - The number of the week.
* @param options - Optional configuration for the date formatting library.
* @returns The ARIA label for the week number cell.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelWeekNumber(weekNumber, _options) {
return `Week ${weekNumber}`;
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelWeekNumberHeader.js
/**
* Generates the ARIA label for the week number header element.
*
* @defaultValue `"Week Number"`
* @param options - Optional configuration for the date formatting library.
* @returns The ARIA label for the week number header.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelWeekNumberHeader(_options) {
return "Week Number";
}
;// ./node_modules/react-day-picker/dist/esm/labels/labelYearDropdown.js
/**
* Generates the ARIA label for the years dropdown.
*
* @defaultValue `"Choose the Year"`
* @param options - Optional configuration for the date formatting library.
* @returns The ARIA label for the years dropdown.
* @group Labels
* @see https://daypicker.dev/docs/translation#aria-labels
*/
function labelYearDropdown(_options) {
return "Choose the Year";
}
;// ./node_modules/react-day-picker/dist/esm/labels/index.js
;// ./node_modules/react-day-picker/dist/esm/useAnimation.js
const asHtmlElement = (element) => {
if (element instanceof HTMLElement)
return element;
return null;
};
const queryMonthEls = (element) => [
...(element.querySelectorAll("[data-animated-month]") ?? []),
];
const queryMonthEl = (element) => asHtmlElement(element.querySelector("[data-animated-month]"));
const queryCaptionEl = (element) => asHtmlElement(element.querySelector("[data-animated-caption]"));
const queryWeeksEl = (element) => asHtmlElement(element.querySelector("[data-animated-weeks]"));
const queryNavEl = (element) => asHtmlElement(element.querySelector("[data-animated-nav]"));
const queryWeekdaysEl = (element) => asHtmlElement(element.querySelector("[data-animated-weekdays]"));
/**
* Handles animations for transitioning between months in the DayPicker
* component.
*
* @private
* @param rootElRef - A reference to the root element of the DayPicker
* component.
* @param enabled - Whether animations are enabled.
* @param options - Configuration options for the animation, including class
* names, months, focused day, and the date utility library.
*/
function useAnimation(rootElRef, enabled, { classNames, months, focused, dateLib, }) {
const previousRootElSnapshotRef = (0,external_React_.useRef)(null);
const previousMonthsRef = (0,external_React_.useRef)(months);
const animatingRef = (0,external_React_.useRef)(false);
(0,external_React_.useLayoutEffect)(() => {
// get previous months before updating the previous months ref
const previousMonths = previousMonthsRef.current;
// update previous months ref for next effect trigger
previousMonthsRef.current = months;
if (!enabled ||
!rootElRef.current ||
// safety check because the ref can be set to anything by consumers
!(rootElRef.current instanceof HTMLElement) ||
// validation required for the animation to work as expected
months.length === 0 ||
previousMonths.length === 0 ||
months.length !== previousMonths.length) {
return;
}
const isSameMonth = dateLib.isSameMonth(months[0].date, previousMonths[0].date);
const isAfterPreviousMonth = dateLib.isAfter(months[0].date, previousMonths[0].date);
const captionAnimationClass = isAfterPreviousMonth
? classNames[Animation.caption_after_enter]
: classNames[Animation.caption_before_enter];
const weeksAnimationClass = isAfterPreviousMonth
? classNames[Animation.weeks_after_enter]
: classNames[Animation.weeks_before_enter];
// get previous root element snapshot before updating the snapshot ref
const previousRootElSnapshot = previousRootElSnapshotRef.current;
// update snapshot for next effect trigger
const rootElSnapshot = rootElRef.current.cloneNode(true);
if (rootElSnapshot instanceof HTMLElement) {
// if this effect is triggered while animating, we need to clean up the new root snapshot
// to put it in the same state as when not animating, to correctly animate the next month change
const currentMonthElsSnapshot = queryMonthEls(rootElSnapshot);
currentMonthElsSnapshot.forEach((currentMonthElSnapshot) => {
if (!(currentMonthElSnapshot instanceof HTMLElement))
return;
// remove the old month snapshots from the new root snapshot
const previousMonthElSnapshot = queryMonthEl(currentMonthElSnapshot);
if (previousMonthElSnapshot &&
currentMonthElSnapshot.contains(previousMonthElSnapshot)) {
currentMonthElSnapshot.removeChild(previousMonthElSnapshot);
}
// remove animation classes from the new month snapshots
const captionEl = queryCaptionEl(currentMonthElSnapshot);
if (captionEl) {
captionEl.classList.remove(captionAnimationClass);
}
const weeksEl = queryWeeksEl(currentMonthElSnapshot);
if (weeksEl) {
weeksEl.classList.remove(weeksAnimationClass);
}
});
previousRootElSnapshotRef.current = rootElSnapshot;
}
else {
previousRootElSnapshotRef.current = null;
}
if (animatingRef.current ||
isSameMonth ||
// skip animation if a day is focused because it can cause issues to the animation and is better for a11y
focused) {
return;
}
const previousMonthEls = previousRootElSnapshot instanceof HTMLElement
? queryMonthEls(previousRootElSnapshot)
: [];
const currentMonthEls = queryMonthEls(rootElRef.current);
if (currentMonthEls?.every((el) => el instanceof HTMLElement) &&
previousMonthEls &&
previousMonthEls.every((el) => el instanceof HTMLElement)) {
animatingRef.current = true;
const cleanUpFunctions = [];
// set isolation to isolate to isolate the stacking context during animation
rootElRef.current.style.isolation = "isolate";
// set z-index to 1 to ensure the nav is clickable over the other elements being animated
const navEl = queryNavEl(rootElRef.current);
if (navEl) {
navEl.style.zIndex = "1";
}
currentMonthEls.forEach((currentMonthEl, index) => {
const previousMonthEl = previousMonthEls[index];
if (!previousMonthEl) {
return;
}
// animate new displayed month
currentMonthEl.style.position = "relative";
currentMonthEl.style.overflow = "hidden";
const captionEl = queryCaptionEl(currentMonthEl);
if (captionEl) {
captionEl.classList.add(captionAnimationClass);
}
const weeksEl = queryWeeksEl(currentMonthEl);
if (weeksEl) {
weeksEl.classList.add(weeksAnimationClass);
}
// animate new displayed month end
const cleanUp = () => {
animatingRef.current = false;
if (rootElRef.current) {
rootElRef.current.style.isolation = "";
}
if (navEl) {
navEl.style.zIndex = "";
}
if (captionEl) {
captionEl.classList.remove(captionAnimationClass);
}
if (weeksEl) {
weeksEl.classList.remove(weeksAnimationClass);
}
currentMonthEl.style.position = "";
currentMonthEl.style.overflow = "";
if (currentMonthEl.contains(previousMonthEl)) {
currentMonthEl.removeChild(previousMonthEl);
}
};
cleanUpFunctions.push(cleanUp);
// animate old displayed month
previousMonthEl.style.pointerEvents = "none";
previousMonthEl.style.position = "absolute";
previousMonthEl.style.overflow = "hidden";
previousMonthEl.setAttribute("aria-hidden", "true");
// hide the weekdays container of the old month and only the new one
const previousWeekdaysEl = queryWeekdaysEl(previousMonthEl);
if (previousWeekdaysEl) {
previousWeekdaysEl.style.opacity = "0";
}
const previousCaptionEl = queryCaptionEl(previousMonthEl);
if (previousCaptionEl) {
previousCaptionEl.classList.add(isAfterPreviousMonth
? classNames[Animation.caption_before_exit]
: classNames[Animation.caption_after_exit]);
previousCaptionEl.addEventListener("animationend", cleanUp);
}
const previousWeeksEl = queryWeeksEl(previousMonthEl);
if (previousWeeksEl) {
previousWeeksEl.classList.add(isAfterPreviousMonth
? classNames[Animation.weeks_before_exit]
: classNames[Animation.weeks_after_exit]);
}
currentMonthEl.insertBefore(previousMonthEl, currentMonthEl.firstChild);
});
}
});
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getDates.js
/**
* Returns all the dates to display in the calendar.
*
* This function calculates the range of dates to display based on the provided
* display months, constraints, and calendar configuration.
*
* @param displayMonths The months to display in the calendar.
* @param maxDate The maximum date to include in the range.
* @param props The DayPicker props, including calendar configuration options.
* @param dateLib The date library to use for date manipulation.
* @returns An array of dates to display in the calendar.
*/
function getDates(displayMonths, maxDate, props, dateLib) {
const firstMonth = displayMonths[0];
const lastMonth = displayMonths[displayMonths.length - 1];
const { ISOWeek, fixedWeeks, broadcastCalendar } = props ?? {};
const { addDays, differenceInCalendarDays, differenceInCalendarMonths, endOfBroadcastWeek, endOfISOWeek, endOfMonth, endOfWeek, isAfter, startOfBroadcastWeek, startOfISOWeek, startOfWeek, } = dateLib;
const startWeekFirstDate = broadcastCalendar
? startOfBroadcastWeek(firstMonth, dateLib)
: ISOWeek
? startOfISOWeek(firstMonth)
: startOfWeek(firstMonth);
const endWeekLastDate = broadcastCalendar
? endOfBroadcastWeek(lastMonth)
: ISOWeek
? endOfISOWeek(endOfMonth(lastMonth))
: endOfWeek(endOfMonth(lastMonth));
const nOfDays = differenceInCalendarDays(endWeekLastDate, startWeekFirstDate);
const nOfMonths = differenceInCalendarMonths(lastMonth, firstMonth) + 1;
const dates = [];
for (let i = 0; i <= nOfDays; i++) {
const date = addDays(startWeekFirstDate, i);
if (maxDate && isAfter(date, maxDate)) {
break;
}
dates.push(date);
}
// If fixed weeks is enabled, add the extra dates to the array
const nrOfDaysWithFixedWeeks = broadcastCalendar ? 35 : 42;
const extraDates = nrOfDaysWithFixedWeeks * nOfMonths;
if (fixedWeeks && dates.length < extraDates) {
const daysToAdd = extraDates - dates.length;
for (let i = 0; i < daysToAdd; i++) {
const date = addDays(dates[dates.length - 1], 1);
dates.push(date);
}
}
return dates;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getDays.js
/**
* Returns all the days belonging to the calendar by merging the days in the
* weeks for each month.
*
* @param calendarMonths The array of calendar months.
* @returns An array of `CalendarDay` objects representing all the days in the
* calendar.
*/
function getDays(calendarMonths) {
const initialDays = [];
return calendarMonths.reduce((days, month) => {
const weekDays = month.weeks.reduce((weekDays, week) => {
return weekDays.concat(week.days.slice());
}, initialDays.slice());
return days.concat(weekDays.slice());
}, initialDays.slice());
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getDisplayMonths.js
/**
* Returns the months to display in the calendar.
*
* @param firstDisplayedMonth The first month currently displayed in the
* calendar.
* @param calendarEndMonth The latest month the user can navigate to.
* @param props The DayPicker props, including `numberOfMonths`.
* @param dateLib The date library to use for date manipulation.
* @returns An array of dates representing the months to display.
*/
function getDisplayMonths(firstDisplayedMonth, calendarEndMonth, props, dateLib) {
const { numberOfMonths = 1 } = props;
const months = [];
for (let i = 0; i < numberOfMonths; i++) {
const month = dateLib.addMonths(firstDisplayedMonth, i);
if (calendarEndMonth && month > calendarEndMonth) {
break;
}
months.push(month);
}
return months;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getInitialMonth.js
/**
* Determines the initial month to display in the calendar based on the provided
* props.
*
* This function calculates the starting month, considering constraints such as
* `startMonth`, `endMonth`, and the number of months to display.
*
* @param props The DayPicker props, including navigation and date constraints.
* @param dateLib The date library to use for date manipulation.
* @returns The initial month to display.
*/
function getInitialMonth(props, navStart, navEnd, dateLib) {
const { month, defaultMonth, today = dateLib.today(), numberOfMonths = 1, } = props;
let initialMonth = month || defaultMonth || today;
const { differenceInCalendarMonths, addMonths, startOfMonth } = dateLib;
if (navEnd &&
differenceInCalendarMonths(navEnd, initialMonth) < numberOfMonths - 1) {
const offset = -1 * (numberOfMonths - 1);
initialMonth = addMonths(navEnd, offset);
}
if (navStart && differenceInCalendarMonths(initialMonth, navStart) < 0) {
initialMonth = navStart;
}
return startOfMonth(initialMonth);
}
;// ./node_modules/react-day-picker/dist/esm/classes/CalendarDay.js
/**
* Represents a day displayed in the calendar.
*
* In DayPicker, a `CalendarDay` is a wrapper around a `Date` object that
* provides additional information about the day, such as whether it belongs to
* the displayed month.
*/
class CalendarDay {
constructor(date, displayMonth, dateLib = DateLib_defaultDateLib) {
this.date = date;
this.displayMonth = displayMonth;
this.outside = Boolean(displayMonth && !dateLib.isSameMonth(date, displayMonth));
this.dateLib = dateLib;
}
/**
* Checks if this day is equal to another `CalendarDay`, considering both the
* date and the displayed month.
*
* @param day The `CalendarDay` to compare with.
* @returns `true` if the days are equal, otherwise `false`.
*/
isEqualTo(day) {
return (this.dateLib.isSameDay(day.date, this.date) &&
this.dateLib.isSameMonth(day.displayMonth, this.displayMonth));
}
}
;// ./node_modules/react-day-picker/dist/esm/classes/CalendarWeek.js
/**
* Represents a week in a calendar month.
*
* A `CalendarWeek` contains the days within the week and the week number.
*/
class CalendarWeek {
constructor(weekNumber, days) {
this.days = days;
this.weekNumber = weekNumber;
}
}
;// ./node_modules/react-day-picker/dist/esm/classes/CalendarMonth.js
/**
* Represents a month in a calendar year.
*
* A `CalendarMonth` contains the weeks within the month and the date of the
* month.
*/
class CalendarMonth {
constructor(month, weeks) {
this.date = month;
this.weeks = weeks;
}
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getMonths.js
/**
* Returns the months to display in the calendar.
*
* This function generates `CalendarMonth` objects for each month to be
* displayed, including their weeks and days, based on the provided display
* months and dates.
*
* @param displayMonths The months (as dates) to display in the calendar.
* @param dates The dates to display in the calendar.
* @param props Options from the DayPicker props context.
* @param dateLib The date library to use for date manipulation.
* @returns An array of `CalendarMonth` objects representing the months to
* display.
*/
function getMonths(displayMonths, dates, props, dateLib) {
const { addDays, endOfBroadcastWeek, endOfISOWeek, endOfMonth, endOfWeek, getISOWeek, getWeek, startOfBroadcastWeek, startOfISOWeek, startOfWeek, } = dateLib;
const dayPickerMonths = displayMonths.reduce((months, month) => {
const firstDateOfFirstWeek = props.broadcastCalendar
? startOfBroadcastWeek(month, dateLib)
: props.ISOWeek
? startOfISOWeek(month)
: startOfWeek(month);
const lastDateOfLastWeek = props.broadcastCalendar
? endOfBroadcastWeek(month)
: props.ISOWeek
? endOfISOWeek(endOfMonth(month))
: endOfWeek(endOfMonth(month));
/** The dates to display in the month. */
const monthDates = dates.filter((date) => {
return date >= firstDateOfFirstWeek && date <= lastDateOfLastWeek;
});
const nrOfDaysWithFixedWeeks = props.broadcastCalendar ? 35 : 42;
if (props.fixedWeeks && monthDates.length < nrOfDaysWithFixedWeeks) {
const extraDates = dates.filter((date) => {
const daysToAdd = nrOfDaysWithFixedWeeks - monthDates.length;
return (date > lastDateOfLastWeek &&
date <= addDays(lastDateOfLastWeek, daysToAdd));
});
monthDates.push(...extraDates);
}
const weeks = monthDates.reduce((weeks, date) => {
const weekNumber = props.ISOWeek ? getISOWeek(date) : getWeek(date);
const week = weeks.find((week) => week.weekNumber === weekNumber);
const day = new CalendarDay(date, month, dateLib);
if (!week) {
weeks.push(new CalendarWeek(weekNumber, [day]));
}
else {
week.days.push(day);
}
return weeks;
}, []);
const dayPickerMonth = new CalendarMonth(month, weeks);
months.push(dayPickerMonth);
return months;
}, []);
if (!props.reverseMonths) {
return dayPickerMonths;
}
else {
return dayPickerMonths.reverse();
}
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getNavMonth.js
/**
* Returns the start and end months for calendar navigation.
*
* @param props The DayPicker props, including navigation and layout options.
* @param dateLib The date library to use for date manipulation.
* @returns A tuple containing the start and end months for navigation.
*/
function getNavMonths(props, dateLib) {
let { startMonth, endMonth } = props;
const { startOfYear, startOfDay, startOfMonth, endOfMonth, addYears, endOfYear, newDate, today, } = dateLib;
// Handle deprecated code
const { fromYear, toYear, fromMonth, toMonth } = props;
if (!startMonth && fromMonth) {
startMonth = fromMonth;
}
if (!startMonth && fromYear) {
startMonth = dateLib.newDate(fromYear, 0, 1);
}
if (!endMonth && toMonth) {
endMonth = toMonth;
}
if (!endMonth && toYear) {
endMonth = newDate(toYear, 11, 31);
}
const hasYearDropdown = props.captionLayout === "dropdown" ||
props.captionLayout === "dropdown-years";
if (startMonth) {
startMonth = startOfMonth(startMonth);
}
else if (fromYear) {
startMonth = newDate(fromYear, 0, 1);
}
else if (!startMonth && hasYearDropdown) {
startMonth = startOfYear(addYears(props.today ?? today(), -100));
}
if (endMonth) {
endMonth = endOfMonth(endMonth);
}
else if (toYear) {
endMonth = newDate(toYear, 11, 31);
}
else if (!endMonth && hasYearDropdown) {
endMonth = endOfYear(props.today ?? today());
}
return [
startMonth ? startOfDay(startMonth) : startMonth,
endMonth ? startOfDay(endMonth) : endMonth,
];
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getNextMonth.js
/**
* Returns the next month the user can navigate to, based on the given options.
*
* The next month is not always the next calendar month:
*
* - If it is after the `calendarEndMonth`, it returns `undefined`.
* - If paged navigation is enabled, it skips forward by the number of displayed
* months.
*
* @param firstDisplayedMonth The first month currently displayed in the
* calendar.
* @param calendarEndMonth The latest month the user can navigate to.
* @param options Navigation options, including `numberOfMonths` and
* `pagedNavigation`.
* @param dateLib The date library to use for date manipulation.
* @returns The next month, or `undefined` if navigation is not possible.
*/
function getNextMonth(firstDisplayedMonth, calendarEndMonth, options, dateLib) {
if (options.disableNavigation) {
return undefined;
}
const { pagedNavigation, numberOfMonths = 1 } = options;
const { startOfMonth, addMonths, differenceInCalendarMonths } = dateLib;
const offset = pagedNavigation ? numberOfMonths : 1;
const month = startOfMonth(firstDisplayedMonth);
if (!calendarEndMonth) {
return addMonths(month, offset);
}
const monthsDiff = differenceInCalendarMonths(calendarEndMonth, firstDisplayedMonth);
if (monthsDiff < numberOfMonths) {
return undefined;
}
return addMonths(month, offset);
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getPreviousMonth.js
/**
* Returns the previous month the user can navigate to, based on the given
* options.
*
* The previous month is not always the previous calendar month:
*
* - If it is before the `calendarStartMonth`, it returns `undefined`.
* - If paged navigation is enabled, it skips back by the number of displayed
* months.
*
* @param firstDisplayedMonth The first month currently displayed in the
* calendar.
* @param calendarStartMonth The earliest month the user can navigate to.
* @param options Navigation options, including `numberOfMonths` and
* `pagedNavigation`.
* @param dateLib The date library to use for date manipulation.
* @returns The previous month, or `undefined` if navigation is not possible.
*/
function getPreviousMonth(firstDisplayedMonth, calendarStartMonth, options, dateLib) {
if (options.disableNavigation) {
return undefined;
}
const { pagedNavigation, numberOfMonths } = options;
const { startOfMonth, addMonths, differenceInCalendarMonths } = dateLib;
const offset = pagedNavigation ? (numberOfMonths ?? 1) : 1;
const month = startOfMonth(firstDisplayedMonth);
if (!calendarStartMonth) {
return addMonths(month, -offset);
}
const monthsDiff = differenceInCalendarMonths(month, calendarStartMonth);
if (monthsDiff <= 0) {
return undefined;
}
return addMonths(month, -offset);
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getWeeks.js
/**
* Returns an array of calendar weeks from an array of calendar months.
*
* @param months The array of calendar months.
* @returns An array of calendar weeks.
*/
function getWeeks(months) {
const initialWeeks = [];
return months.reduce((weeks, month) => {
return weeks.concat(month.weeks.slice());
}, initialWeeks.slice());
}
;// ./node_modules/react-day-picker/dist/esm/helpers/useControlledValue.js
/**
* A custom hook for managing both controlled and uncontrolled component states.
*
* This hook allows a component to support both controlled and uncontrolled
* states by determining whether the `controlledValue` is provided. If it is
* undefined, the hook falls back to using the internal state.
*
* @example
* // Uncontrolled usage
* const [value, setValue] = useControlledValue(0, undefined);
*
* // Controlled usage
* const [value, setValue] = useControlledValue(0, props.value);
*
* @template T - The type of the value.
* @param defaultValue The initial value for the uncontrolled state.
* @param controlledValue The value for the controlled state. If undefined, the
* component will use the uncontrolled state.
* @returns A tuple where the first element is the current value (either
* controlled or uncontrolled) and the second element is a setter function to
* update the value.
*/
function useControlledValue_useControlledValue(defaultValue, controlledValue) {
const [uncontrolledValue, setValue] = (0,external_React_.useState)(defaultValue);
const value = controlledValue === undefined ? uncontrolledValue : controlledValue;
return [value, setValue];
}
;// ./node_modules/react-day-picker/dist/esm/useCalendar.js
/**
* Provides the calendar object to work with the calendar in custom components.
*
* @private
* @param props - The DayPicker props related to calendar configuration.
* @param dateLib - The date utility library instance.
* @returns The calendar object containing displayed days, weeks, months, and
* navigation methods.
*/
function useCalendar(props, dateLib) {
const [navStart, navEnd] = getNavMonths(props, dateLib);
const { startOfMonth, endOfMonth } = dateLib;
const initialMonth = getInitialMonth(props, navStart, navEnd, dateLib);
const [firstMonth, setFirstMonth] = useControlledValue_useControlledValue(initialMonth,
// initialMonth is always computed from props.month if provided
props.month ? initialMonth : undefined);
// biome-ignore lint/correctness/useExhaustiveDependencies: change the initial month when the time zone changes.
(0,external_React_.useEffect)(() => {
const newInitialMonth = getInitialMonth(props, navStart, navEnd, dateLib);
setFirstMonth(newInitialMonth);
}, [props.timeZone]);
/** The months displayed in the calendar. */
const displayMonths = getDisplayMonths(firstMonth, navEnd, props, dateLib);
/** The dates displayed in the calendar. */
const dates = getDates(displayMonths, props.endMonth ? endOfMonth(props.endMonth) : undefined, props, dateLib);
/** The Months displayed in the calendar. */
const months = getMonths(displayMonths, dates, props, dateLib);
/** The Weeks displayed in the calendar. */
const weeks = getWeeks(months);
/** The Days displayed in the calendar. */
const days = getDays(months);
const previousMonth = getPreviousMonth(firstMonth, navStart, props, dateLib);
const nextMonth = getNextMonth(firstMonth, navEnd, props, dateLib);
const { disableNavigation, onMonthChange } = props;
const isDayInCalendar = (day) => weeks.some((week) => week.days.some((d) => d.isEqualTo(day)));
const goToMonth = (date) => {
if (disableNavigation) {
return;
}
let newMonth = startOfMonth(date);
// if month is before start, use the first month instead
if (navStart && newMonth < startOfMonth(navStart)) {
newMonth = startOfMonth(navStart);
}
// if month is after endMonth, use the last month instead
if (navEnd && newMonth > startOfMonth(navEnd)) {
newMonth = startOfMonth(navEnd);
}
setFirstMonth(newMonth);
onMonthChange?.(newMonth);
};
const goToDay = (day) => {
// is this check necessary?
if (isDayInCalendar(day)) {
return;
}
goToMonth(day.date);
};
const calendar = {
months,
weeks,
days,
navStart,
navEnd,
previousMonth,
nextMonth,
goToMonth,
goToDay,
};
return calendar;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/calculateFocusTarget.js
var FocusTargetPriority;
(function (FocusTargetPriority) {
FocusTargetPriority[FocusTargetPriority["Today"] = 0] = "Today";
FocusTargetPriority[FocusTargetPriority["Selected"] = 1] = "Selected";
FocusTargetPriority[FocusTargetPriority["LastFocused"] = 2] = "LastFocused";
FocusTargetPriority[FocusTargetPriority["FocusedModifier"] = 3] = "FocusedModifier";
})(FocusTargetPriority || (FocusTargetPriority = {}));
/**
* Determines if a day is focusable based on its modifiers.
*
* A day is considered focusable if it is not disabled, hidden, or outside the
* displayed month.
*
* @param modifiers The modifiers applied to the day.
* @returns `true` if the day is focusable, otherwise `false`.
*/
function isFocusableDay(modifiers) {
return (!modifiers[DayFlag.disabled] &&
!modifiers[DayFlag.hidden] &&
!modifiers[DayFlag.outside]);
}
/**
* Calculates the focus target day based on priority.
*
* This function determines the day that should receive focus in the calendar,
* prioritizing days with specific modifiers (e.g., "focused", "today") or
* selection states.
*
* @param days The array of `CalendarDay` objects to evaluate.
* @param getModifiers A function to retrieve the modifiers for a given day.
* @param isSelected A function to determine if a day is selected.
* @param lastFocused The last focused day, if any.
* @returns The `CalendarDay` that should receive focus, or `undefined` if no
* focusable day is found.
*/
function calculateFocusTarget(days, getModifiers, isSelected, lastFocused) {
let focusTarget;
let foundFocusTargetPriority = -1;
for (const day of days) {
const modifiers = getModifiers(day);
if (isFocusableDay(modifiers)) {
if (modifiers[DayFlag.focused] &&
foundFocusTargetPriority < FocusTargetPriority.FocusedModifier) {
focusTarget = day;
foundFocusTargetPriority = FocusTargetPriority.FocusedModifier;
}
else if (lastFocused?.isEqualTo(day) &&
foundFocusTargetPriority < FocusTargetPriority.LastFocused) {
focusTarget = day;
foundFocusTargetPriority = FocusTargetPriority.LastFocused;
}
else if (isSelected(day.date) &&
foundFocusTargetPriority < FocusTargetPriority.Selected) {
focusTarget = day;
foundFocusTargetPriority = FocusTargetPriority.Selected;
}
else if (modifiers[DayFlag.today] &&
foundFocusTargetPriority < FocusTargetPriority.Today) {
focusTarget = day;
foundFocusTargetPriority = FocusTargetPriority.Today;
}
}
}
if (!focusTarget) {
// Return the first day that is focusable
focusTarget = days.find((day) => isFocusableDay(getModifiers(day)));
}
return focusTarget;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getFocusableDate.js
/**
* Calculates the next date that should be focused in the calendar.
*
* This function determines the next focusable date based on the movement
* direction, constraints, and calendar configuration.
*
* @param moveBy The unit of movement (e.g., "day", "week").
* @param moveDir The direction of movement ("before" or "after").
* @param refDate The reference date from which to calculate the next focusable
* date.
* @param navStart The earliest date the user can navigate to.
* @param navEnd The latest date the user can navigate to.
* @param props The DayPicker props, including calendar configuration options.
* @param dateLib The date library to use for date manipulation.
* @returns The next focusable date.
*/
function getFocusableDate(moveBy, moveDir, refDate, navStart, navEnd, props, dateLib) {
const { ISOWeek, broadcastCalendar } = props;
const { addDays, addMonths, addWeeks, addYears, endOfBroadcastWeek, endOfISOWeek, endOfWeek, max, min, startOfBroadcastWeek, startOfISOWeek, startOfWeek, } = dateLib;
const moveFns = {
day: addDays,
week: addWeeks,
month: addMonths,
year: addYears,
startOfWeek: (date) => broadcastCalendar
? startOfBroadcastWeek(date, dateLib)
: ISOWeek
? startOfISOWeek(date)
: startOfWeek(date),
endOfWeek: (date) => broadcastCalendar
? endOfBroadcastWeek(date)
: ISOWeek
? endOfISOWeek(date)
: endOfWeek(date),
};
let focusableDate = moveFns[moveBy](refDate, moveDir === "after" ? 1 : -1);
if (moveDir === "before" && navStart) {
focusableDate = max([navStart, focusableDate]);
}
else if (moveDir === "after" && navEnd) {
focusableDate = min([navEnd, focusableDate]);
}
return focusableDate;
}
;// ./node_modules/react-day-picker/dist/esm/helpers/getNextFocus.js
/**
* Determines the next focusable day in the calendar.
*
* This function recursively calculates the next focusable day based on the
* movement direction and modifiers applied to the days.
*
* @param moveBy The unit of movement (e.g., "day", "week").
* @param moveDir The direction of movement ("before" or "after").
* @param refDay The currently focused day.
* @param calendarStartMonth The earliest month the user can navigate to.
* @param calendarEndMonth The latest month the user can navigate to.
* @param props The DayPicker props, including modifiers and configuration
* options.
* @param dateLib The date library to use for date manipulation.
* @param attempt The current recursion attempt (used to limit recursion depth).
* @returns The next focusable day, or `undefined` if no focusable day is found.
*/
function getNextFocus(moveBy, moveDir, refDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt = 0) {
if (attempt > 365) {
// Limit the recursion to 365 attempts
return undefined;
}
const focusableDate = getFocusableDate(moveBy, moveDir, refDay.date, calendarStartMonth, calendarEndMonth, props, dateLib);
const isDisabled = Boolean(props.disabled &&
dateMatchModifiers(focusableDate, props.disabled, dateLib));
const isHidden = Boolean(props.hidden && dateMatchModifiers(focusableDate, props.hidden, dateLib));
const targetMonth = focusableDate;
const focusDay = new CalendarDay(focusableDate, targetMonth, dateLib);
if (!isDisabled && !isHidden) {
return focusDay;
}
// Recursively attempt to find the next focusable date
return getNextFocus(moveBy, moveDir, focusDay, calendarStartMonth, calendarEndMonth, props, dateLib, attempt + 1);
}
;// ./node_modules/react-day-picker/dist/esm/useFocus.js
/**
* Manages focus behavior for the DayPicker component, including setting,
* moving, and blurring focus on calendar days.
*
* @template T - The type of DayPicker props.
* @param props - The DayPicker props.
* @param calendar - The calendar object containing the displayed days and
* months.
* @param getModifiers - A function to retrieve modifiers for a given day.
* @param isSelected - A function to check if a date is selected.
* @param dateLib - The date utility library instance.
* @returns An object containing focus-related methods and the currently focused
* day.
*/
function useFocus(props, calendar, getModifiers, isSelected, dateLib) {
const { autoFocus } = props;
const [lastFocused, setLastFocused] = (0,external_React_.useState)();
const focusTarget = calculateFocusTarget(calendar.days, getModifiers, isSelected || (() => false), lastFocused);
const [focusedDay, setFocused] = (0,external_React_.useState)(autoFocus ? focusTarget : undefined);
const blur = () => {
setLastFocused(focusedDay);
setFocused(undefined);
};
const moveFocus = (moveBy, moveDir) => {
if (!focusedDay)
return;
const nextFocus = getNextFocus(moveBy, moveDir, focusedDay, calendar.navStart, calendar.navEnd, props, dateLib);
if (!nextFocus)
return;
if (props.disableNavigation) {
const isNextInCalendar = calendar.days.some((day) => day.isEqualTo(nextFocus));
if (!isNextInCalendar) {
return;
}
}
calendar.goToDay(nextFocus);
setFocused(nextFocus);
};
const isFocusTarget = (day) => {
return Boolean(focusTarget?.isEqualTo(day));
};
const useFocus = {
isFocusTarget,
setFocused,
focused: focusedDay,
blur,
moveFocus,
};
return useFocus;
}
;// ./node_modules/react-day-picker/dist/esm/selection/useMulti.js
/**
* Hook to manage multiple-date selection in the DayPicker component.
*
* @template T - The type of DayPicker props.
* @param props - The DayPicker props.
* @param dateLib - The date utility library instance.
* @returns An object containing the selected dates, a function to select dates,
* and a function to check if a date is selected.
*/
function useMulti(props, dateLib) {
const { selected: initiallySelected, required, onSelect, } = props;
const [internallySelected, setSelected] = useControlledValue_useControlledValue(initiallySelected, onSelect ? initiallySelected : undefined);
const selected = !onSelect ? internallySelected : initiallySelected;
const { isSameDay } = dateLib;
const isSelected = (date) => {
return selected?.some((d) => isSameDay(d, date)) ?? false;
};
const { min, max } = props;
const select = (triggerDate, modifiers, e) => {
let newDates = [...(selected ?? [])];
if (isSelected(triggerDate)) {
if (selected?.length === min) {
// Min value reached, do nothing
return;
}
if (required && selected?.length === 1) {
// Required value already selected do nothing
return;
}
newDates = selected?.filter((d) => !isSameDay(d, triggerDate));
}
else {
if (selected?.length === max) {
// Max value reached, reset the selection to date
newDates = [triggerDate];
}
else {
// Add the date to the selection
newDates = [...newDates, triggerDate];
}
}
if (!onSelect) {
setSelected(newDates);
}
onSelect?.(newDates, triggerDate, modifiers, e);
return newDates;
};
return {
selected,
select,
isSelected,
};
}
;// ./node_modules/react-day-picker/dist/esm/utils/addToRange.js
/**
* Adds a date to an existing range, considering constraints like minimum and
* maximum range size.
*
* @param date - The date to add to the range.
* @param initialRange - The initial range to which the date will be added.
* @param min - The minimum number of days in the range.
* @param max - The maximum number of days in the range.
* @param required - Whether the range must always include at least one date.
* @param dateLib - The date utility library instance.
* @returns The updated date range, or `undefined` if the range is cleared.
* @group Utilities
*/
function addToRange(date, initialRange, min = 0, max = 0, required = false, dateLib = DateLib_defaultDateLib) {
const { from, to } = initialRange || {};
const { isSameDay, isAfter, isBefore } = dateLib;
let range;
if (!from && !to) {
// the range is empty, add the date
range = { from: date, to: min > 0 ? undefined : date };
}
else if (from && !to) {
// adding date to an incomplete range
if (isSameDay(from, date)) {
// adding a date equal to the start of the range
if (min === 0) {
range = { from, to: date };
}
else if (required) {
range = { from, to: undefined };
}
else {
range = undefined;
}
}
else if (isBefore(date, from)) {
// adding a date before the start of the range
range = { from: date, to: from };
}
else {
// adding a date after the start of the range
range = { from, to: date };
}
}
else if (from && to) {
// adding date to a complete range
if (isSameDay(from, date) && isSameDay(to, date)) {
// adding a date that is equal to both start and end of the range
if (required) {
range = { from, to };
}
else {
range = undefined;
}
}
else if (isSameDay(from, date)) {
// adding a date equal to the the start of the range
range = { from, to: min > 0 ? undefined : date };
}
else if (isSameDay(to, date)) {
// adding a dare equal to the end of the range
range = { from: date, to: min > 0 ? undefined : date };
}
else if (isBefore(date, from)) {
// adding a date before the start of the range
range = { from: date, to: to };
}
else if (isAfter(date, from)) {
// adding a date after the start of the range
range = { from, to: date };
}
else if (isAfter(date, to)) {
// adding a date after the end of the range
range = { from, to: date };
}
else {
throw new Error("Invalid range");
}
}
// check for min / max
if (range?.from && range?.to) {
const diff = dateLib.differenceInCalendarDays(range.to, range.from);
if (max > 0 && diff > max) {
range = { from: date, to: undefined };
}
else if (min > 1 && diff < min) {
range = { from: date, to: undefined };
}
}
return range;
}
;// ./node_modules/react-day-picker/dist/esm/utils/rangeContainsDayOfWeek.js
/**
* Checks if a date range contains one or more specified days of the week.
*
* @since 9.2.2
* @param range - The date range to check.
* @param dayOfWeek - The day(s) of the week to check for (`0-6`, where `0` is
* Sunday).
* @param dateLib - The date utility library instance.
* @returns `true` if the range contains the specified day(s) of the week,
* otherwise `false`.
* @group Utilities
*/
function rangeContainsDayOfWeek(range, dayOfWeek, dateLib = DateLib_defaultDateLib) {
const dayOfWeekArr = !Array.isArray(dayOfWeek) ? [dayOfWeek] : dayOfWeek;
let date = range.from;
const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
// iterate at maximum one week or the total days if the range is shorter than one week
const totalDaysLimit = Math.min(totalDays, 6);
for (let i = 0; i <= totalDaysLimit; i++) {
if (dayOfWeekArr.includes(date.getDay())) {
return true;
}
date = dateLib.addDays(date, 1);
}
return false;
}
;// ./node_modules/react-day-picker/dist/esm/utils/rangeOverlaps.js
/**
* Determines if two date ranges overlap.
*
* @since 9.2.2
* @param rangeLeft - The first date range.
* @param rangeRight - The second date range.
* @param dateLib - The date utility library instance.
* @returns `true` if the ranges overlap, otherwise `false`.
* @group Utilities
*/
function rangeOverlaps(rangeLeft, rangeRight, dateLib = DateLib_defaultDateLib) {
return (rangeIncludesDate(rangeLeft, rangeRight.from, false, dateLib) ||
rangeIncludesDate(rangeLeft, rangeRight.to, false, dateLib) ||
rangeIncludesDate(rangeRight, rangeLeft.from, false, dateLib) ||
rangeIncludesDate(rangeRight, rangeLeft.to, false, dateLib));
}
;// ./node_modules/react-day-picker/dist/esm/utils/rangeContainsModifiers.js
/**
* Checks if a date range contains dates that match the given modifiers.
*
* @since 9.2.2
* @param range - The date range to check.
* @param modifiers - The modifiers to match against.
* @param dateLib - The date utility library instance.
* @returns `true` if the range contains matching dates, otherwise `false`.
* @group Utilities
*/
function rangeContainsModifiers(range, modifiers, dateLib = DateLib_defaultDateLib) {
const matchers = Array.isArray(modifiers) ? modifiers : [modifiers];
// Defer function matchers evaluation as they are the least performant.
const nonFunctionMatchers = matchers.filter((matcher) => typeof matcher !== "function");
const nonFunctionMatchersResult = nonFunctionMatchers.some((matcher) => {
if (typeof matcher === "boolean")
return matcher;
if (dateLib.isDate(matcher)) {
return rangeIncludesDate(range, matcher, false, dateLib);
}
if (isDatesArray(matcher, dateLib)) {
return matcher.some((date) => rangeIncludesDate(range, date, false, dateLib));
}
if (isDateRange(matcher)) {
if (matcher.from && matcher.to) {
return rangeOverlaps(range, { from: matcher.from, to: matcher.to }, dateLib);
}
return false;
}
if (isDayOfWeekType(matcher)) {
return rangeContainsDayOfWeek(range, matcher.dayOfWeek, dateLib);
}
if (isDateInterval(matcher)) {
const isClosedInterval = dateLib.isAfter(matcher.before, matcher.after);
if (isClosedInterval) {
return rangeOverlaps(range, {
from: dateLib.addDays(matcher.after, 1),
to: dateLib.addDays(matcher.before, -1),
}, dateLib);
}
return (dateMatchModifiers(range.from, matcher, dateLib) ||
dateMatchModifiers(range.to, matcher, dateLib));
}
if (isDateAfterType(matcher) || isDateBeforeType(matcher)) {
return (dateMatchModifiers(range.from, matcher, dateLib) ||
dateMatchModifiers(range.to, matcher, dateLib));
}
return false;
});
if (nonFunctionMatchersResult) {
return true;
}
const functionMatchers = matchers.filter((matcher) => typeof matcher === "function");
if (functionMatchers.length) {
let date = range.from;
const totalDays = dateLib.differenceInCalendarDays(range.to, range.from);
for (let i = 0; i <= totalDays; i++) {
if (functionMatchers.some((matcher) => matcher(date))) {
return true;
}
date = dateLib.addDays(date, 1);
}
}
return false;
}
;// ./node_modules/react-day-picker/dist/esm/selection/useRange.js
/**
* Hook to manage range selection in the DayPicker component.
*
* @template T - The type of DayPicker props.
* @param props - The DayPicker props.
* @param dateLib - The date utility library instance.
* @returns An object containing the selected range, a function to select a
* range, and a function to check if a date is within the range.
*/
function useRange(props, dateLib) {
const { disabled, excludeDisabled, selected: initiallySelected, required, onSelect, } = props;
const [internallySelected, setSelected] = useControlledValue_useControlledValue(initiallySelected, onSelect ? initiallySelected : undefined);
const selected = !onSelect ? internallySelected : initiallySelected;
const isSelected = (date) => selected && rangeIncludesDate(selected, date, false, dateLib);
const select = (triggerDate, modifiers, e) => {
const { min, max } = props;
const newRange = triggerDate
? addToRange(triggerDate, selected, min, max, required, dateLib)
: undefined;
if (excludeDisabled && disabled && newRange?.from && newRange.to) {
if (rangeContainsModifiers({ from: newRange.from, to: newRange.to }, disabled, dateLib)) {
// if a disabled days is found, the range is reset
newRange.from = triggerDate;
newRange.to = undefined;
}
}
if (!onSelect) {
setSelected(newRange);
}
onSelect?.(newRange, triggerDate, modifiers, e);
return newRange;
};
return {
selected,
select,
isSelected,
};
}
;// ./node_modules/react-day-picker/dist/esm/selection/useSingle.js
/**
* Hook to manage single-date selection in the DayPicker component.
*
* @template T - The type of DayPicker props.
* @param props - The DayPicker props.
* @param dateLib - The date utility library instance.
* @returns An object containing the selected date, a function to select a date,
* and a function to check if a date is selected.
*/
function useSingle(props, dateLib) {
const { selected: initiallySelected, required, onSelect, } = props;
const [internallySelected, setSelected] = useControlledValue_useControlledValue(initiallySelected, onSelect ? initiallySelected : undefined);
const selected = !onSelect ? internallySelected : initiallySelected;
const { isSameDay } = dateLib;
const isSelected = (compareDate) => {
return selected ? isSameDay(selected, compareDate) : false;
};
const select = (triggerDate, modifiers, e) => {
let newDate = triggerDate;
if (!required && selected && selected && isSameDay(triggerDate, selected)) {
// If the date is the same, clear the selection.
newDate = undefined;
}
if (!onSelect) {
setSelected(newDate);
}
if (required) {
onSelect?.(newDate, triggerDate, modifiers, e);
}
else {
onSelect?.(newDate, triggerDate, modifiers, e);
}
return newDate;
};
return {
selected,
select,
isSelected,
};
}
;// ./node_modules/react-day-picker/dist/esm/useSelection.js
/**
* Determines the appropriate selection hook to use based on the selection mode
* and returns the corresponding selection object.
*
* @template T - The type of DayPicker props.
* @param props - The DayPicker props.
* @param dateLib - The date utility library instance.
* @returns The selection object for the specified mode, or `undefined` if no
* mode is set.
*/
function useSelection(props, dateLib) {
const single = useSingle(props, dateLib);
const multi = useMulti(props, dateLib);
const range = useRange(props, dateLib);
switch (props.mode) {
case "single":
return single;
case "multiple":
return multi;
case "range":
return range;
default:
return undefined;
}
}
;// ./node_modules/react-day-picker/dist/esm/DayPicker.js
/**
* Renders the DayPicker calendar component.
*
* @param initialProps - The props for the DayPicker component.
* @returns The rendered DayPicker component.
* @group DayPicker
* @see https://daypicker.dev
*/
function DayPicker(initialProps) {
let props = initialProps;
if (props.timeZone) {
props = {
...initialProps,
};
if (props.today) {
props.today = new date_TZDate(props.today, props.timeZone);
}
if (props.month) {
props.month = new date_TZDate(props.month, props.timeZone);
}
if (props.defaultMonth) {
props.defaultMonth = new date_TZDate(props.defaultMonth, props.timeZone);
}
if (props.startMonth) {
props.startMonth = new date_TZDate(props.startMonth, props.timeZone);
}
if (props.endMonth) {
props.endMonth = new date_TZDate(props.endMonth, props.timeZone);
}
if (props.mode === "single" && props.selected) {
props.selected = new date_TZDate(props.selected, props.timeZone);
}
else if (props.mode === "multiple" && props.selected) {
props.selected = props.selected?.map((date) => new date_TZDate(date, props.timeZone));
}
else if (props.mode === "range" && props.selected) {
props.selected = {
from: props.selected.from
? new date_TZDate(props.selected.from, props.timeZone)
: undefined,
to: props.selected.to
? new date_TZDate(props.selected.to, props.timeZone)
: undefined,
};
}
}
const { components, formatters, labels, dateLib, locale, classNames } = (0,external_React_.useMemo)(() => {
const locale = { ...en_US_enUS, ...props.locale };
const dateLib = new DateLib({
locale,
weekStartsOn: props.broadcastCalendar ? 1 : props.weekStartsOn,
firstWeekContainsDate: props.firstWeekContainsDate,
useAdditionalWeekYearTokens: props.useAdditionalWeekYearTokens,
useAdditionalDayOfYearTokens: props.useAdditionalDayOfYearTokens,
timeZone: props.timeZone,
numerals: props.numerals,
}, props.dateLib);
return {
dateLib,
components: getComponents(props.components),
formatters: getFormatters(props.formatters),
labels: { ...labels_namespaceObject, ...props.labels },
locale,
classNames: { ...getDefaultClassNames(), ...props.classNames },
};
}, [
props.locale,
props.broadcastCalendar,
props.weekStartsOn,
props.firstWeekContainsDate,
props.useAdditionalWeekYearTokens,
props.useAdditionalDayOfYearTokens,
props.timeZone,
props.numerals,
props.dateLib,
props.components,
props.formatters,
props.labels,
props.classNames,
]);
const { captionLayout, mode, navLayout, numberOfMonths = 1, onDayBlur, onDayClick, onDayFocus, onDayKeyDown, onDayMouseEnter, onDayMouseLeave, onNextClick, onPrevClick, showWeekNumber, styles, } = props;
const { formatCaption, formatDay, formatMonthDropdown, formatWeekNumber, formatWeekNumberHeader, formatWeekdayName, formatYearDropdown, } = formatters;
const calendar = useCalendar(props, dateLib);
const { days, months, navStart, navEnd, previousMonth, nextMonth, goToMonth, } = calendar;
const getModifiers = createGetModifiers(days, props, navStart, navEnd, dateLib);
const { isSelected, select, selected: selectedValue, } = useSelection(props, dateLib) ?? {};
const { blur, focused, isFocusTarget, moveFocus, setFocused } = useFocus(props, calendar, getModifiers, isSelected ?? (() => false), dateLib);
const { labelDayButton, labelGridcell, labelGrid, labelMonthDropdown, labelNav, labelPrevious, labelNext, labelWeekday, labelWeekNumber, labelWeekNumberHeader, labelYearDropdown, } = labels;
const weekdays = (0,external_React_.useMemo)(() => getWeekdays(dateLib, props.ISOWeek), [dateLib, props.ISOWeek]);
const isInteractive = mode !== undefined || onDayClick !== undefined;
const handlePreviousClick = (0,external_React_.useCallback)(() => {
if (!previousMonth)
return;
goToMonth(previousMonth);
onPrevClick?.(previousMonth);
}, [previousMonth, goToMonth, onPrevClick]);
const handleNextClick = (0,external_React_.useCallback)(() => {
if (!nextMonth)
return;
goToMonth(nextMonth);
onNextClick?.(nextMonth);
}, [goToMonth, nextMonth, onNextClick]);
const handleDayClick = (0,external_React_.useCallback)((day, m) => (e) => {
e.preventDefault();
e.stopPropagation();
setFocused(day);
select?.(day.date, m, e);
onDayClick?.(day.date, m, e);
}, [select, onDayClick, setFocused]);
const handleDayFocus = (0,external_React_.useCallback)((day, m) => (e) => {
setFocused(day);
onDayFocus?.(day.date, m, e);
}, [onDayFocus, setFocused]);
const handleDayBlur = (0,external_React_.useCallback)((day, m) => (e) => {
blur();
onDayBlur?.(day.date, m, e);
}, [blur, onDayBlur]);
const handleDayKeyDown = (0,external_React_.useCallback)((day, modifiers) => (e) => {
const keyMap = {
ArrowLeft: [
e.shiftKey ? "month" : "day",
props.dir === "rtl" ? "after" : "before",
],
ArrowRight: [
e.shiftKey ? "month" : "day",
props.dir === "rtl" ? "before" : "after",
],
ArrowDown: [e.shiftKey ? "year" : "week", "after"],
ArrowUp: [e.shiftKey ? "year" : "week", "before"],
PageUp: [e.shiftKey ? "year" : "month", "before"],
PageDown: [e.shiftKey ? "year" : "month", "after"],
Home: ["startOfWeek", "before"],
End: ["endOfWeek", "after"],
};
if (keyMap[e.key]) {
e.preventDefault();
e.stopPropagation();
const [moveBy, moveDir] = keyMap[e.key];
moveFocus(moveBy, moveDir);
}
onDayKeyDown?.(day.date, modifiers, e);
}, [moveFocus, onDayKeyDown, props.dir]);
const handleDayMouseEnter = (0,external_React_.useCallback)((day, modifiers) => (e) => {
onDayMouseEnter?.(day.date, modifiers, e);
}, [onDayMouseEnter]);
const handleDayMouseLeave = (0,external_React_.useCallback)((day, modifiers) => (e) => {
onDayMouseLeave?.(day.date, modifiers, e);
}, [onDayMouseLeave]);
const handleMonthChange = (0,external_React_.useCallback)((date) => (e) => {
const selectedMonth = Number(e.target.value);
const month = dateLib.setMonth(dateLib.startOfMonth(date), selectedMonth);
goToMonth(month);
}, [dateLib, goToMonth]);
const handleYearChange = (0,external_React_.useCallback)((date) => (e) => {
const selectedYear = Number(e.target.value);
const month = dateLib.setYear(dateLib.startOfMonth(date), selectedYear);
goToMonth(month);
}, [dateLib, goToMonth]);
const { className, style } = (0,external_React_.useMemo)(() => ({
className: [classNames[UI_UI.Root], props.className]
.filter(Boolean)
.join(" "),
style: { ...styles?.[UI_UI.Root], ...props.style },
}), [classNames, props.className, props.style, styles]);
const dataAttributes = getDataAttributes(props);
const rootElRef = (0,external_React_.useRef)(null);
useAnimation(rootElRef, Boolean(props.animate), {
classNames,
months,
focused,
dateLib,
});
const contextValue = {
dayPickerProps: props,
selected: selectedValue,
select: select,
isSelected,
months,
nextMonth,
previousMonth,
goToMonth,
getModifiers,
components,
classNames,
styles,
labels,
formatters,
};
return (external_React_.createElement(dayPickerContext.Provider, { value: contextValue },
external_React_.createElement(components.Root, { rootRef: props.animate ? rootElRef : undefined, className: className, style: style, dir: props.dir, id: props.id, lang: props.lang, nonce: props.nonce, title: props.title, role: props.role, "aria-label": props["aria-label"], "aria-labelledby": props["aria-labelledby"], ...dataAttributes },
external_React_.createElement(components.Months, { className: classNames[UI_UI.Months], style: styles?.[UI_UI.Months] },
!props.hideNavigation && !navLayout && (external_React_.createElement(components.Nav, { "data-animated-nav": props.animate ? "true" : undefined, className: classNames[UI_UI.Nav], style: styles?.[UI_UI.Nav], "aria-label": labelNav(), onPreviousClick: handlePreviousClick, onNextClick: handleNextClick, previousMonth: previousMonth, nextMonth: nextMonth })),
months.map((calendarMonth, displayIndex) => {
return (external_React_.createElement(components.Month, { "data-animated-month": props.animate ? "true" : undefined, className: classNames[UI_UI.Month], style: styles?.[UI_UI.Month],
// biome-ignore lint/suspicious/noArrayIndexKey: breaks animation
key: displayIndex, displayIndex: displayIndex, calendarMonth: calendarMonth },
navLayout === "around" &&
!props.hideNavigation &&
displayIndex === 0 && (external_React_.createElement(components.PreviousMonthButton, { type: "button", className: classNames[UI_UI.PreviousMonthButton], tabIndex: previousMonth ? undefined : -1, "aria-disabled": previousMonth ? undefined : true, "aria-label": labelPrevious(previousMonth), onClick: handlePreviousClick, "data-animated-button": props.animate ? "true" : undefined },
external_React_.createElement(components.Chevron, { disabled: previousMonth ? undefined : true, className: classNames[UI_UI.Chevron], orientation: props.dir === "rtl" ? "right" : "left" }))),
external_React_.createElement(components.MonthCaption, { "data-animated-caption": props.animate ? "true" : undefined, className: classNames[UI_UI.MonthCaption], style: styles?.[UI_UI.MonthCaption], calendarMonth: calendarMonth, displayIndex: displayIndex }, captionLayout?.startsWith("dropdown") ? (external_React_.createElement(components.DropdownNav, { className: classNames[UI_UI.Dropdowns], style: styles?.[UI_UI.Dropdowns] },
(() => {
const monthControl = captionLayout === "dropdown" ||
captionLayout === "dropdown-months" ? (external_React_.createElement(components.MonthsDropdown, { key: "month", className: classNames[UI_UI.MonthsDropdown], "aria-label": labelMonthDropdown(), classNames: classNames, components: components, disabled: Boolean(props.disableNavigation), onChange: handleMonthChange(calendarMonth.date), options: getMonthOptions(calendarMonth.date, navStart, navEnd, formatters, dateLib), style: styles?.[UI_UI.Dropdown], value: dateLib.getMonth(calendarMonth.date) })) : (external_React_.createElement("span", { key: "month" }, formatMonthDropdown(calendarMonth.date, dateLib)));
const yearControl = captionLayout === "dropdown" ||
captionLayout === "dropdown-years" ? (external_React_.createElement(components.YearsDropdown, { key: "year", className: classNames[UI_UI.YearsDropdown], "aria-label": labelYearDropdown(dateLib.options), classNames: classNames, components: components, disabled: Boolean(props.disableNavigation), onChange: handleYearChange(calendarMonth.date), options: getYearOptions(navStart, navEnd, formatters, dateLib, Boolean(props.reverseYears)), style: styles?.[UI_UI.Dropdown], value: dateLib.getYear(calendarMonth.date) })) : (external_React_.createElement("span", { key: "year" }, formatYearDropdown(calendarMonth.date, dateLib)));
const controls = dateLib.getMonthYearOrder() === "year-first"
? [yearControl, monthControl]
: [monthControl, yearControl];
return controls;
})(),
external_React_.createElement("span", { role: "status", "aria-live": "polite", style: {
border: 0,
clip: "rect(0 0 0 0)",
height: "1px",
margin: "-1px",
overflow: "hidden",
padding: 0,
position: "absolute",
width: "1px",
whiteSpace: "nowrap",
wordWrap: "normal",
} }, formatCaption(calendarMonth.date, dateLib.options, dateLib)))) : (
// biome-ignore lint/a11y/useSemanticElements: breaking change
external_React_.createElement(components.CaptionLabel, { className: classNames[UI_UI.CaptionLabel], role: "status", "aria-live": "polite" }, formatCaption(calendarMonth.date, dateLib.options, dateLib)))),
navLayout === "around" &&
!props.hideNavigation &&
displayIndex === numberOfMonths - 1 && (external_React_.createElement(components.NextMonthButton, { type: "button", className: classNames[UI_UI.NextMonthButton], tabIndex: nextMonth ? undefined : -1, "aria-disabled": nextMonth ? undefined : true, "aria-label": labelNext(nextMonth), onClick: handleNextClick, "data-animated-button": props.animate ? "true" : undefined },
external_React_.createElement(components.Chevron, { disabled: nextMonth ? undefined : true, className: classNames[UI_UI.Chevron], orientation: props.dir === "rtl" ? "left" : "right" }))),
displayIndex === numberOfMonths - 1 &&
navLayout === "after" &&
!props.hideNavigation && (external_React_.createElement(components.Nav, { "data-animated-nav": props.animate ? "true" : undefined, className: classNames[UI_UI.Nav], style: styles?.[UI_UI.Nav], "aria-label": labelNav(), onPreviousClick: handlePreviousClick, onNextClick: handleNextClick, previousMonth: previousMonth, nextMonth: nextMonth })),
external_React_.createElement(components.MonthGrid, { role: "grid", "aria-multiselectable": mode === "multiple" || mode === "range", "aria-label": labelGrid(calendarMonth.date, dateLib.options, dateLib) ||
undefined, className: classNames[UI_UI.MonthGrid], style: styles?.[UI_UI.MonthGrid] },
!props.hideWeekdays && (external_React_.createElement(components.Weekdays, { "data-animated-weekdays": props.animate ? "true" : undefined, className: classNames[UI_UI.Weekdays], style: styles?.[UI_UI.Weekdays] },
showWeekNumber && (external_React_.createElement(components.WeekNumberHeader, { "aria-label": labelWeekNumberHeader(dateLib.options), className: classNames[UI_UI.WeekNumberHeader], style: styles?.[UI_UI.WeekNumberHeader], scope: "col" }, formatWeekNumberHeader())),
weekdays.map((weekday) => (external_React_.createElement(components.Weekday, { "aria-label": labelWeekday(weekday, dateLib.options, dateLib), className: classNames[UI_UI.Weekday], key: String(weekday), style: styles?.[UI_UI.Weekday], scope: "col" }, formatWeekdayName(weekday, dateLib.options, dateLib)))))),
external_React_.createElement(components.Weeks, { "data-animated-weeks": props.animate ? "true" : undefined, className: classNames[UI_UI.Weeks], style: styles?.[UI_UI.Weeks] }, calendarMonth.weeks.map((week) => {
return (external_React_.createElement(components.Week, { className: classNames[UI_UI.Week], key: week.weekNumber, style: styles?.[UI_UI.Week], week: week },
showWeekNumber && (
// biome-ignore lint/a11y/useSemanticElements: react component
external_React_.createElement(components.WeekNumber, { week: week, style: styles?.[UI_UI.WeekNumber], "aria-label": labelWeekNumber(week.weekNumber, {
locale,
}), className: classNames[UI_UI.WeekNumber], scope: "row", role: "rowheader" }, formatWeekNumber(week.weekNumber, dateLib))),
week.days.map((day) => {
const { date } = day;
const modifiers = getModifiers(day);
modifiers[DayFlag.focused] =
!modifiers.hidden &&
Boolean(focused?.isEqualTo(day));
modifiers[SelectionState.selected] =
isSelected?.(date) || modifiers.selected;
if (isDateRange(selectedValue)) {
// add range modifiers
const { from, to } = selectedValue;
modifiers[SelectionState.range_start] = Boolean(from && to && dateLib.isSameDay(date, from));
modifiers[SelectionState.range_end] = Boolean(from && to && dateLib.isSameDay(date, to));
modifiers[SelectionState.range_middle] =
rangeIncludesDate(selectedValue, date, true, dateLib);
}
const style = getStyleForModifiers(modifiers, styles, props.modifiersStyles);
const className = getClassNamesForModifiers(modifiers, classNames, props.modifiersClassNames);
const ariaLabel = !isInteractive && !modifiers.hidden
? labelGridcell(date, modifiers, dateLib.options, dateLib)
: undefined;
return (
// biome-ignore lint/a11y/useSemanticElements: react component
external_React_.createElement(components.Day, { key: `${dateLib.format(date, "yyyy-MM-dd")}_${dateLib.format(day.displayMonth, "yyyy-MM")}`, day: day, modifiers: modifiers, className: className.join(" "), style: style, role: "gridcell", "aria-selected": modifiers.selected || undefined, "aria-label": ariaLabel, "data-day": dateLib.format(date, "yyyy-MM-dd"), "data-month": day.outside
? dateLib.format(date, "yyyy-MM")
: undefined, "data-selected": modifiers.selected || undefined, "data-disabled": modifiers.disabled || undefined, "data-hidden": modifiers.hidden || undefined, "data-outside": day.outside || undefined, "data-focused": modifiers.focused || undefined, "data-today": modifiers.today || undefined }, !modifiers.hidden && isInteractive ? (external_React_.createElement(components.DayButton, { className: classNames[UI_UI.DayButton], style: styles?.[UI_UI.DayButton], type: "button", day: day, modifiers: modifiers, disabled: modifiers.disabled || undefined, tabIndex: isFocusTarget(day) ? 0 : -1, "aria-label": labelDayButton(date, modifiers, dateLib.options, dateLib), onClick: handleDayClick(day, modifiers), onBlur: handleDayBlur(day, modifiers), onFocus: handleDayFocus(day, modifiers), onKeyDown: handleDayKeyDown(day, modifiers), onMouseEnter: handleDayMouseEnter(day, modifiers), onMouseLeave: handleDayMouseLeave(day, modifiers) }, formatDay(date, dateLib.options, dateLib))) : (!modifiers.hidden &&
formatDay(day.date, dateLib.options, dateLib))));
})));
})))));
})),
props.footer && (
// biome-ignore lint/a11y/useSemanticElements: react component
external_React_.createElement(components.Footer, { className: classNames[UI_UI.Footer], style: styles?.[UI_UI.Footer], role: "status", "aria-live": "polite" }, props.footer)))));
}
;// ./node_modules/@wordpress/components/build-module/calendar/utils/day-cell.js
const PreviewDashStartAndEnd = () => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("svg", {
viewBox: "0 0 32 32",
xmlns: "http://www.w3.org/2000/svg",
fill: "none",
stroke: "currentColor",
strokeDasharray: "3.7677",
strokeDashoffset: "3.2",
strokeWidth: "1",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("path", {
d: "M29.5,0.5 h-27 a2,2 0 0 0 -2,2 v27 a2,2 0 0 0 2,2 h27 a2,2 0 0 0 2,-2 v-27 a2,2 0 0 0 -2,-2"
})
});
};
const PreviewDashStart = () => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("svg", {
viewBox: "0 0 32 32",
xmlns: "http://www.w3.org/2000/svg",
fill: "none",
stroke: "currentColor",
strokeDasharray: "3.84516",
strokeDashoffset: "1.9226",
strokeWidth: "1",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("path", {
d: "M32,0.5 h-29.5 a2,2 0 0 0 -2,2 v27 a2,2 0 0 0 2,2 h30"
})
});
};
const PreviewDashMiddle = () => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("svg", {
viewBox: "0 0 32 32",
xmlns: "http://www.w3.org/2000/svg",
fill: "none",
stroke: "currentColor",
strokeDasharray: "3.9 4",
strokeDashoffset: "2",
strokeWidth: "1",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("line", {
x1: "0",
y1: "0.5",
x2: "100",
y2: "0.5"
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("line", {
x1: "0",
y1: "31.5",
x2: "100",
y2: "31.5"
})]
});
};
const PreviewDashEnd = () => {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("svg", {
viewBox: "0 0 32 32",
xmlns: "http://www.w3.org/2000/svg",
fill: "none",
stroke: "currentColor",
strokeDasharray: "3.84516",
strokeDashoffset: "1.9226",
strokeWidth: "1",
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("path", {
d: "M0,0.5 h29.5 a2,2 0 0 1 2,2 v27 a2,2 0 0 1 -2,2 h-29.5"
})
});
};
function day_cell_Day(props) {
const {
day,
modifiers,
children,
...tdProps
} = props;
let PreviewDash;
if (modifiers.preview_start && modifiers.preview_end) {
PreviewDash = PreviewDashStartAndEnd;
} else if (modifiers.preview_start) {
PreviewDash = PreviewDashStart;
} else if (modifiers.preview_end) {
PreviewDash = PreviewDashEnd;
} else if (modifiers.preview) {
PreviewDash = PreviewDashMiddle;
}
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("td", {
...tdProps,
children: [PreviewDash && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(PreviewDash, {}), children]
});
}
;// ./node_modules/@wordpress/components/build-module/calendar/utils/constants.js
const CLASSNAMES = {
root: "components-calendar",
day: "components-calendar__day",
day_button: "components-calendar__day-button",
caption_label: "components-calendar__caption-label",
button_next: "components-calendar__button-next",
button_previous: "components-calendar__button-previous",
chevron: "components-calendar__chevron",
nav: "components-calendar__nav",
month_caption: "components-calendar__month-caption",
months: "components-calendar__months",
month_grid: "components-calendar__month-grid",
weekday: "components-calendar__weekday",
today: "components-calendar__day--today",
selected: "components-calendar__day--selected",
disabled: "components-calendar__day--disabled",
hidden: "components-calendar__day--hidden",
range_start: "components-calendar__range-start",
range_end: "components-calendar__range-end",
range_middle: "components-calendar__range-middle",
weeks_before_enter: "components-calendar__weeks-before-enter",
weeks_before_exit: "components-calendar__weeks-before-exit",
weeks_after_enter: "components-calendar__weeks-after-enter",
weeks_after_exit: "components-calendar__weeks-after-exit",
caption_after_enter: "components-calendar__caption-after-enter",
caption_after_exit: "components-calendar__caption-after-exit",
caption_before_enter: "components-calendar__caption-before-enter",
caption_before_exit: "components-calendar__caption-before-exit"
};
const MODIFIER_CLASSNAMES = {
preview: "components-calendar__day--preview",
preview_start: "components-calendar__day--preview-start",
preview_end: "components-calendar__day--preview-end"
};
const COMMON_PROPS = {
animate: true,
// Only show days in the current month
showOutsideDays: false,
// Hide week number column
showWeekNumber: false,
// Show weekdays row
hideWeekdays: false,
// Month and year caption are not interactive
captionLayout: "label",
// Show a variable number of weeks depending on the month
fixedWeeks: false,
// Show navigation buttons
hideNavigation: false,
// Class names
classNames: CLASSNAMES,
// Default role
role: "application",
components: {
Day: day_cell_Day
}
};
;// ./node_modules/@wordpress/components/build-module/calendar/utils/misc.js
function clampNumberOfMonths(numberOfMonths) {
return Math.min(3, Math.max(1, numberOfMonths));
}
;// ./node_modules/@wordpress/components/build-module/calendar/utils/use-localization-props.js
function isLocaleRTL(localeCode) {
const localeObj = new Intl.Locale(localeCode);
if ("getTextInfo" in localeObj) {
return localeObj.getTextInfo().direction === "rtl";
}
return [
"ar",
// Arabic
"he",
// Hebrew
"fa",
// Persian (Farsi)
"ur",
// Urdu
"ps",
// Pashto
"syr",
// Syriac
"dv",
// Divehi
"ku",
// Kurdish (Sorani)
"yi"
// Yiddish
].includes(localeObj.language);
}
const useLocalizationProps = ({
locale,
timeZone,
mode
}) => {
return (0,external_wp_element_namespaceObject.useMemo)(() => {
const monthNameFormatter = new Intl.DateTimeFormat(locale.code, {
year: "numeric",
month: "long",
timeZone
});
const weekdayNarrowFormatter = new Intl.DateTimeFormat(locale.code, {
weekday: "narrow",
timeZone
});
const weekdayLongFormatter = new Intl.DateTimeFormat(locale.code, {
weekday: "long",
timeZone
});
const fullDateFormatter = new Intl.DateTimeFormat(locale.code, {
weekday: "long",
year: "numeric",
month: "long",
day: "numeric",
timeZone
});
return {
"aria-label": mode === "single" ? (0,external_wp_i18n_namespaceObject.__)("Date calendar") : (0,external_wp_i18n_namespaceObject.__)("Date range calendar"),
labels: {
/**
* The label for the month grid.
* @param date
*/
labelGrid: (date) => monthNameFormatter.format(date),
/**
* The label for the gridcell, when the calendar is not interactive.
* @param date
* @param modifiers
*/
labelGridcell: (date, modifiers) => {
const formattedDate = fullDateFormatter.format(date);
let label = formattedDate;
if (modifiers?.today) {
label = (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s is the full date (e.g. "Monday, April 29, 2025")
(0,external_wp_i18n_namespaceObject.__)("Today, %s"),
formattedDate
);
}
return label;
},
/** The label for the "next month" button. */
labelNext: () => (0,external_wp_i18n_namespaceObject.__)("Go to the Next Month"),
/** The label for the "previous month" button. */
labelPrevious: () => (0,external_wp_i18n_namespaceObject.__)("Go to the Previous Month"),
/**
* The label for the day button.
* @param date
* @param modifiers
*/
labelDayButton: (date, modifiers) => {
const formattedDate = fullDateFormatter.format(date);
let label = formattedDate;
if (modifiers?.today) {
label = (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s is the full date (e.g. "Monday, April 29, 2025")
(0,external_wp_i18n_namespaceObject.__)("Today, %s"),
formattedDate
);
}
if (modifiers?.selected) {
label = (0,external_wp_i18n_namespaceObject.sprintf)(
// translators: %s is the full date (e.g. "Monday, April 29, 2025")
(0,external_wp_i18n_namespaceObject.__)("%s, selected"),
formattedDate
);
}
return label;
},
/**
* The label for the weekday.
* @param date
*/
labelWeekday: (date) => weekdayLongFormatter.format(date)
},
locale,
dir: isLocaleRTL(locale.code) ? "rtl" : "ltr",
formatters: {
formatWeekdayName: (date) => {
return weekdayNarrowFormatter.format(date);
},
formatCaption: (date) => {
return monthNameFormatter.format(date);
}
},
timeZone
};
}, [locale, timeZone, mode]);
};
;// ./node_modules/@wordpress/components/build-module/calendar/date-calendar/index.js
const DateCalendar = ({
defaultSelected,
selected: selectedProp,
onSelect,
numberOfMonths = 1,
locale = en_US_enUS,
timeZone,
...props
}) => {
const localizationProps = useLocalizationProps({
locale,
timeZone,
mode: "single"
});
const onChange = (0,external_wp_element_namespaceObject.useCallback)((selected2, triggerDate, modifiers, e) => {
onSelect?.(selected2 !== null && selected2 !== void 0 ? selected2 : void 0, triggerDate, modifiers, e);
}, [onSelect]);
const [selected, setSelected] = useControlledValue({
defaultValue: defaultSelected,
value: selectedProp,
onChange
});
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DayPicker, {
...COMMON_PROPS,
...localizationProps,
...props,
mode: "single",
numberOfMonths: clampNumberOfMonths(numberOfMonths),
selected: selected !== null && selected !== void 0 ? selected : void 0,
onSelect: setSelected
});
};
;// ./node_modules/@wordpress/components/build-module/calendar/date-range-calendar/index.js
function usePreviewRange({
selected,
hoveredDate,
excludeDisabled,
min,
max,
disabled
}) {
return (0,external_wp_element_namespaceObject.useMemo)(() => {
if (!hoveredDate || !selected?.from) {
return;
}
let previewHighlight;
let potentialNewRange;
if (hoveredDate < selected.from) {
var _selected$to;
previewHighlight = {
from: hoveredDate,
to: selected.from
};
potentialNewRange = {
from: hoveredDate,
to: (_selected$to = selected.to) !== null && _selected$to !== void 0 ? _selected$to : selected.from
};
} else if (selected.to && hoveredDate > selected.from && hoveredDate < selected.to) {
previewHighlight = {
from: selected.from,
to: hoveredDate
};
potentialNewRange = {
from: selected.from,
to: hoveredDate
};
} else if (hoveredDate > selected.from) {
var _selected$to2;
previewHighlight = {
from: (_selected$to2 = selected.to) !== null && _selected$to2 !== void 0 ? _selected$to2 : selected.from,
to: hoveredDate
};
potentialNewRange = {
from: selected.from,
to: hoveredDate
};
}
if (min !== void 0 && min > 0 && potentialNewRange && differenceInCalendarDays(potentialNewRange.to, potentialNewRange.from) < min) {
previewHighlight = {
from: hoveredDate,
to: hoveredDate
};
}
if (max !== void 0 && max > 0 && potentialNewRange && differenceInCalendarDays(potentialNewRange.to, potentialNewRange.from) > max) {
previewHighlight = {
from: hoveredDate,
to: hoveredDate
};
}
if (excludeDisabled && disabled && potentialNewRange && rangeContainsModifiers(potentialNewRange, disabled)) {
previewHighlight = {
from: hoveredDate,
to: hoveredDate
};
}
return previewHighlight;
}, [selected, hoveredDate, excludeDisabled, min, max, disabled]);
}
const DateRangeCalendar = ({
defaultSelected,
selected: selectedProp,
onSelect,
numberOfMonths = 1,
excludeDisabled,
min,
max,
disabled,
locale = en_US_enUS,
timeZone,
...props
}) => {
const localizationProps = useLocalizationProps({
locale,
timeZone,
mode: "range"
});
const onChange = (0,external_wp_element_namespaceObject.useCallback)((selected2, triggerDate, modifiers2, e) => {
onSelect?.(selected2 !== null && selected2 !== void 0 ? selected2 : void 0, triggerDate, modifiers2, e);
}, [onSelect]);
const [selected, setSelected] = useControlledValue({
defaultValue: defaultSelected,
value: selectedProp,
onChange
});
const [hoveredDate, setHoveredDate] = (0,external_wp_element_namespaceObject.useState)(void 0);
const previewRange = usePreviewRange({
selected,
hoveredDate,
excludeDisabled,
min,
max,
disabled
});
const modifiers = (0,external_wp_element_namespaceObject.useMemo)(() => {
return {
preview: previewRange,
preview_start: previewRange?.from,
preview_end: previewRange?.to
};
}, [previewRange]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(DayPicker, {
...COMMON_PROPS,
...localizationProps,
...props,
mode: "range",
numberOfMonths: clampNumberOfMonths(numberOfMonths),
disabled,
excludeDisabled,
min,
max,
selected: selected !== null && selected !== void 0 ? selected : void 0,
onSelect: setSelected,
onDayMouseEnter: (date) => setHoveredDate(date),
onDayMouseLeave: () => setHoveredDate(void 0),
modifiers,
modifiersClassNames: MODIFIER_CLASSNAMES
});
};
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/validity-indicator.js
function ValidityIndicator({
type,
message
}) {
const ICON = {
valid: published_default,
invalid: error_default
};
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("p", {
className: dist_clsx("components-validated-control__indicator", `is-${type}`),
children: [type === "validating" ? /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(spinner_default, {
className: "components-validated-control__indicator-spinner"
}) : /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(icon_icon_default, {
className: "components-validated-control__indicator-icon",
icon: ICON[type],
size: 16,
fill: "currentColor"
}), message]
});
}
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/control-with-error.js
function appendRequiredIndicator(label, required, markWhenOptional) {
if (required && !markWhenOptional) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [label, " ", `(${(0,external_wp_i18n_namespaceObject.__)("Required")})`]
});
}
if (!required && markWhenOptional) {
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)(external_ReactJSXRuntime_namespaceObject.Fragment, {
children: [label, " ", `(${(0,external_wp_i18n_namespaceObject.__)("Optional")})`]
});
}
return label;
}
function UnforwardedControlWithError({
required,
markWhenOptional,
onValidate,
customValidity,
getValidityTarget,
children
}, forwardedRef) {
const [errorMessage, setErrorMessage] = (0,external_wp_element_namespaceObject.useState)();
const [statusMessage, setStatusMessage] = (0,external_wp_element_namespaceObject.useState)();
const [isTouched, setIsTouched] = (0,external_wp_element_namespaceObject.useState)(false);
const previousCustomValidityType = (0,external_wp_compose_namespaceObject.usePrevious)(customValidity?.type);
(0,external_wp_element_namespaceObject.useEffect)(() => {
const validityTarget = getValidityTarget();
const showValidationMessage = () => setErrorMessage(validityTarget?.validationMessage);
validityTarget?.addEventListener("invalid", showValidationMessage);
return () => {
validityTarget?.removeEventListener("invalid", showValidationMessage);
};
});
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (!isTouched) {
return;
}
const validityTarget = getValidityTarget();
if (!customValidity?.type) {
validityTarget?.setCustomValidity("");
setErrorMessage(validityTarget?.validationMessage);
setStatusMessage(void 0);
return;
}
switch (customValidity.type) {
case "validating": {
const timer = setTimeout(() => {
validityTarget?.setCustomValidity("");
setErrorMessage(void 0);
setStatusMessage({
type: "validating",
message: customValidity.message
});
}, 1e3);
return () => clearTimeout(timer);
}
case "valid": {
if (previousCustomValidityType === "valid") {
break;
}
validityTarget?.setCustomValidity("");
setErrorMessage(validityTarget?.validationMessage);
setStatusMessage({
type: "valid",
message: customValidity.message
});
break;
}
case "invalid": {
var _customValidity$messa;
validityTarget?.setCustomValidity((_customValidity$messa = customValidity.message) !== null && _customValidity$messa !== void 0 ? _customValidity$messa : "");
setErrorMessage(validityTarget?.validationMessage);
setStatusMessage(void 0);
break;
}
}
}, [isTouched, customValidity?.type, customValidity?.message, getValidityTarget, previousCustomValidityType]);
const onBlur = (event) => {
if (isTouched) {
return;
}
if (!event.relatedTarget || !event.currentTarget.contains(event.relatedTarget)) {
setIsTouched(true);
onValidate?.();
}
};
const onChange = (...args) => {
children.props.onChange?.(...args);
if (isTouched || errorMessage) {
onValidate?.();
}
};
const onKeyDown = (event) => {
if (event.key === "Enter") {
onValidate?.();
}
};
return (
// Disable reason: Just listening to a bubbled event, not for interaction.
// eslint-disable-next-line jsx-a11y/no-static-element-interactions
/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-validated-control",
ref: forwardedRef,
onBlur,
onKeyDown: withIgnoreIMEEvents(onKeyDown),
children: [(0,external_wp_element_namespaceObject.cloneElement)(children, {
label: appendRequiredIndicator(children.props.label, required, markWhenOptional),
onChange,
required
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
"aria-live": "polite",
children: [errorMessage && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ValidityIndicator, {
type: "invalid",
message: errorMessage
}), !errorMessage && statusMessage && /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ValidityIndicator, {
type: statusMessage.type,
message: statusMessage.message
})]
})]
})
);
}
const ControlWithError = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedControlWithError);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/input-control.js
const UnforwardedValidatedInputControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(input_control_default, {
__next40pxDefaultSize: true,
ref: mergedRefs,
onChange: (value, ...args) => {
valueRef.current = value;
onChange?.(value, ...args);
},
...restProps
})
});
};
const ValidatedInputControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedInputControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/checkbox-control.js
const UnforwardedValidatedCheckboxControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.checked);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
ref: mergedRefs,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current?.querySelector('input[type="checkbox"]'),
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(checkbox_control_default, {
__nextHasNoMarginBottom: true,
onChange: (value) => {
valueRef.current = value;
onChange?.(value);
},
...restProps
})
});
};
const ValidatedCheckboxControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedCheckboxControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/number-control.js
const UnforwardedValidatedNumberControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(number_control_default, {
__next40pxDefaultSize: true,
ref: mergedRefs,
onChange: (value, ...args) => {
valueRef.current = value;
onChange?.(value, ...args);
},
...restProps
})
});
};
const ValidatedNumberControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedNumberControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/select-control.js
const UnforwardedValidatedSelectControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(select_control_default, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize: true,
ref: mergedRefs,
onChange: (value) => {
valueRef.current = value;
onChange?.(value);
},
...restProps
})
});
};
const ValidatedSelectControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedSelectControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/radio-control.js
const UnforwardedValidatedRadioControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.selected);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
ref: mergedRefs,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current?.querySelector('input[type="radio"]'),
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(radio_control_default, {
onChange: (value) => {
valueRef.current = value;
onChange?.(value);
},
...restProps
})
});
};
const ValidatedRadioControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedRadioControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/text-control.js
const UnforwardedValidatedTextControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(text_control_default, {
__next40pxDefaultSize: true,
__nextHasNoMarginBottom: true,
ref: mergedRefs,
onChange: (value) => {
valueRef.current = value;
onChange?.(value);
},
...restProps
})
});
};
const ValidatedTextControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedTextControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/textarea-control.js
const UnforwardedValidatedTextareaControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(textarea_control_default, {
__nextHasNoMarginBottom: true,
ref: mergedRefs,
onChange: (value) => {
valueRef.current = value;
onChange?.(value);
},
...restProps
})
});
};
const ValidatedTextareaControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedTextareaControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/toggle-control.js
const UnforwardedValidatedToggleControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const mergedRefs = (0,external_wp_compose_namespaceObject.useMergeRefs)([forwardedRef, validityTargetRef]);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.checked);
(0,external_wp_element_namespaceObject.useEffect)(() => {
if (validityTargetRef.current) {
validityTargetRef.current.required = required !== null && required !== void 0 ? required : false;
}
}, [required]);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_control_default, {
__nextHasNoMarginBottom: true,
ref: mergedRefs,
onChange: (value) => {
valueRef.current = value;
onChange?.(value);
},
...restProps
})
});
};
const ValidatedToggleControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedToggleControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/toggle-group-control.js
const UnforwardedValidatedToggleGroupControl = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.value);
const nameAttr = (0,external_wp_element_namespaceObject.useId)();
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-validated-control__wrapper-with-error-delegate",
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(toggle_group_control_component_component_default, {
__nextHasNoMarginBottom: true,
__next40pxDefaultSize: true,
ref: forwardedRef,
onChange: (value) => {
valueRef.current = value;
onChange?.(value);
},
...restProps
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
className: "components-validated-control__error-delegate",
type: "radio",
ref: validityTargetRef,
required,
checked: restProps.value !== void 0,
tabIndex: -1,
name: nameAttr,
onChange: () => {
},
onFocus: (e) => {
e.target.previousElementSibling?.querySelector('[data-active-item="true"]')?.focus();
}
})]
});
};
const ValidatedToggleGroupControl = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedToggleGroupControl);
;// ./node_modules/@wordpress/components/build-module/validated-form-controls/components/form-token-field.js
const UnforwardedValidatedFormTokenField = ({
required,
onValidate,
customValidity,
onChange,
markWhenOptional,
...restProps
}, forwardedRef) => {
const validityTargetRef = (0,external_wp_element_namespaceObject.useRef)(null);
const valueRef = (0,external_wp_element_namespaceObject.useRef)(restProps.value);
return /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsxs)("div", {
className: "components-validated-control__wrapper-with-error-delegate",
ref: forwardedRef,
children: [/* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(ControlWithError, {
required,
markWhenOptional,
onValidate: () => {
return onValidate?.(valueRef.current);
},
customValidity,
getValidityTarget: () => validityTargetRef.current,
children: /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)(FormTokenField, {
__next40pxDefaultSize: true,
__nextHasNoMarginBottom: true,
...restProps,
onChange: (value, ...args) => {
valueRef.current = value;
onChange?.(value, ...args);
}
})
}), /* @__PURE__ */ (0,external_ReactJSXRuntime_namespaceObject.jsx)("input", {
className: "components-validated-control__error-delegate",
type: "text",
ref: validityTargetRef,
required,
value: valueRef.current && valueRef.current.length > 0 ? "hasvalue" : "",
tabIndex: -1,
onChange: () => {
},
onFocus: (e) => {
e.target.previousElementSibling?.querySelector('input[type="text"]')?.focus();
}
})]
});
};
const ValidatedFormTokenField = (0,external_wp_element_namespaceObject.forwardRef)(UnforwardedValidatedFormTokenField);
;// ./node_modules/@wordpress/components/build-module/private-apis.js
const privateApis = {};
lock(privateApis, {
__experimentalPopoverLegacyPositionToPlacement: positionToPlacement,
ComponentsContext: ComponentsContext,
Tabs: Tabs,
Theme: theme_default,
Menu: menu_Menu,
kebabCase: kebabCase,
withIgnoreIMEEvents: withIgnoreIMEEvents,
Badge: badge_default,
normalizeTextString: normalizeTextString,
DateCalendar: DateCalendar,
DateRangeCalendar: DateRangeCalendar,
TZDate: date_TZDate,
Picker: Picker,
ValidatedInputControl: ValidatedInputControl,
ValidatedCheckboxControl: ValidatedCheckboxControl,
ValidatedNumberControl: ValidatedNumberControl,
ValidatedSelectControl: ValidatedSelectControl,
ValidatedRadioControl: ValidatedRadioControl,
ValidatedTextControl: ValidatedTextControl,
ValidatedTextareaControl: ValidatedTextareaControl,
ValidatedToggleControl: ValidatedToggleControl,
ValidatedToggleGroupControl: ValidatedToggleGroupControl,
ValidatedFormTokenField: ValidatedFormTokenField
});
;// ./node_modules/@wordpress/components/build-module/index.js
})();
(window.wp = window.wp || {}).components = __webpack_exports__;
/******/ })()
;