From 85110e3e56047446fcaee06a1757ad10ebc1c198 Mon Sep 17 00:00:00 2001 From: Nazeeh21 Date: Fri, 22 Nov 2024 05:53:49 +0000 Subject: [PATCH] =?UTF-8?q?Deploy=20preview=20for=20PR=2018=20=F0=9F=9B=AB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- ...eCard-B3e90Ry2.js => HomeCard-DCnWW-uM.js} | 1274 +- .../pr-18/airdrop/assets/Text-BUUD0p9X.js | 3481 ++ .../pr-18/airdrop/assets/Text-DcZ5ZG-Q.js | 116 - ...azy-CXADy5F6.js => _slug.lazy-CjqJeyhI.js} | 113 +- .../{ccip-Dz828d1P.js => ccip-DpFDfZA_.js} | 2 +- ...zy-CSxM7rtj.js => create.lazy-qc-8-bQv.js} | 20163 +++++---- ...zy-rB4vKwtd.js => faucet.lazy-DesU0WKa.js} | 17 +- .../airdrop/assets/hooks.module-DYwlSVlQ.js | 504 + .../{index-QfC4KmC2.js => index-2lB61zir.js} | 14 +- .../pr-18/airdrop/assets/index-B28oGDIc.js | 14819 +++++++ .../{index-k8RMG5ai.js => index-BipEaFpl.js} | 2 +- .../pr-18/airdrop/assets/index-BybM-qLE.js | 3353 ++ .../{index-D2rmE0Ge.js => index-Bzt_1Xzz.js} | 160 +- .../{index-OViWMWHH.js => index-CUJp9d5D.js} | 34879 +++++++++------- .../{index-zG3-WPy4.js => index-CdB9gNLi.js} | 2 +- ...{index-ZzfqWl4c.css => index-CvaSZn0p.css} | 331 + .../pr-18/airdrop/assets/index-CzjhlQMJ.js | 3823 ++ .../{index-DkKLiZ7O.js => index-_uALCXYc.js} | 2 +- .../pr-18/airdrop/assets/index-f4jwF-kE.js | 558 + .../pr-18/airdrop/assets/index.es-Dbw4665J.js | 17302 ++++++++ .../airdrop/assets/index.lazy-B5pMb-IZ.js | 63 + ...azy-CxydH9L_.js => index.lazy-BjF66Pk2.js} | 31 +- .../airdrop/assets/index.lazy-C3fG7Gru.js | 47 - ...L0.js => useInitializeAirdrop-CG8cXfI3.js} | 2582 +- pr-preview/pr-18/airdrop/index.html | 4 +- .../assets/ccip-Dmg6vLqz.js} | 2 +- .../assets/hooks.module-D8HQXNV3.js} | 2 +- .../{index-JbsZBZS1.js => index-B9gN2i-u.js} | 71 +- .../{index-BSa15Sq5.js => index-BGPhfwK5.js} | 6 +- .../{index-CX-dSKcI.js => index-CcBW1TDP.js} | 4 +- .../{index-DG3LKzXw.js => index-D8JgdFDg.js} | 4 +- .../assets/index-D9BXDbiZ.js} | 2 +- .../{index-h02td9ek.js => index-DZgtdGEH.js} | 8 +- .../assets/index-vwHUmZkR.js} | 4 +- pr-preview/pr-18/counter/index.html | 2 +- .../assets/ccip-Dg2WsaJ5.js} | 2 +- .../assets/hooks.module-B8KmTTSH.js} | 2 +- .../{index-DLnLZoYS.js => index-BTz10lx0.js} | 61 +- .../assets/index-Bj008S16.js} | 2 +- .../{index-ByHd_ulF.js => index-C7iFs5mH.js} | 4 +- .../assets/index-CVYqMJhC.js} | 4 +- .../{index-CcpJqqKG.js => index-Cn9z8n0i.js} | 6 +- .../{index-BPR1oSZP.js => index-Db3H1vvu.js} | 4 +- .../{index-B7N3rW4p.js => index-MUqciiLU.js} | 4 +- pr-preview/pr-18/nft/index.html | 2 +- 45 files changed, 74528 insertions(+), 29310 deletions(-) rename pr-preview/pr-18/airdrop/assets/{HomeCard-B3e90Ry2.js => HomeCard-DCnWW-uM.js} (70%) create mode 100644 pr-preview/pr-18/airdrop/assets/Text-BUUD0p9X.js delete mode 100644 pr-preview/pr-18/airdrop/assets/Text-DcZ5ZG-Q.js rename pr-preview/pr-18/airdrop/assets/{_slug.lazy-CXADy5F6.js => _slug.lazy-CjqJeyhI.js} (70%) rename pr-preview/pr-18/airdrop/assets/{ccip-Dz828d1P.js => ccip-DpFDfZA_.js} (94%) rename pr-preview/pr-18/airdrop/assets/{create.lazy-CSxM7rtj.js => create.lazy-qc-8-bQv.js} (95%) rename pr-preview/pr-18/airdrop/assets/{faucet.lazy-rB4vKwtd.js => faucet.lazy-DesU0WKa.js} (54%) create mode 100644 pr-preview/pr-18/airdrop/assets/hooks.module-DYwlSVlQ.js rename pr-preview/pr-18/airdrop/assets/{index-QfC4KmC2.js => index-2lB61zir.js} (99%) create mode 100644 pr-preview/pr-18/airdrop/assets/index-B28oGDIc.js rename pr-preview/pr-18/airdrop/assets/{index-k8RMG5ai.js => index-BipEaFpl.js} (99%) create mode 100644 pr-preview/pr-18/airdrop/assets/index-BybM-qLE.js rename pr-preview/pr-18/airdrop/assets/{index-D2rmE0Ge.js => index-Bzt_1Xzz.js} (80%) rename pr-preview/pr-18/airdrop/assets/{index-OViWMWHH.js => index-CUJp9d5D.js} (90%) rename pr-preview/pr-18/airdrop/assets/{index-zG3-WPy4.js => index-CdB9gNLi.js} (99%) rename pr-preview/pr-18/airdrop/assets/{index-ZzfqWl4c.css => index-CvaSZn0p.css} (83%) create mode 100644 pr-preview/pr-18/airdrop/assets/index-CzjhlQMJ.js rename pr-preview/pr-18/airdrop/assets/{index-DkKLiZ7O.js => index-_uALCXYc.js} (99%) create mode 100644 pr-preview/pr-18/airdrop/assets/index-f4jwF-kE.js create mode 100644 pr-preview/pr-18/airdrop/assets/index.es-Dbw4665J.js create mode 100644 pr-preview/pr-18/airdrop/assets/index.lazy-B5pMb-IZ.js rename pr-preview/pr-18/airdrop/assets/{index.lazy-CxydH9L_.js => index.lazy-BjF66Pk2.js} (66%) delete mode 100644 pr-preview/pr-18/airdrop/assets/index.lazy-C3fG7Gru.js rename pr-preview/pr-18/airdrop/assets/{button-Bb_5GoL0.js => useInitializeAirdrop-CG8cXfI3.js} (50%) rename pr-preview/pr-18/{nft/assets/ccip-CPuws-wB.js => counter/assets/ccip-Dmg6vLqz.js} (98%) rename pr-preview/pr-18/{nft/assets/hooks.module-BAG2NLEQ.js => counter/assets/hooks.module-D8HQXNV3.js} (99%) rename pr-preview/pr-18/counter/assets/{index-JbsZBZS1.js => index-B9gN2i-u.js} (99%) rename pr-preview/pr-18/counter/assets/{index-BSa15Sq5.js => index-BGPhfwK5.js} (98%) rename pr-preview/pr-18/counter/assets/{index-CX-dSKcI.js => index-CcBW1TDP.js} (99%) rename pr-preview/pr-18/counter/assets/{index-DG3LKzXw.js => index-D8JgdFDg.js} (99%) rename pr-preview/pr-18/{nft/assets/index-BvZxlK9g.js => counter/assets/index-D9BXDbiZ.js} (99%) rename pr-preview/pr-18/counter/assets/{index-h02td9ek.js => index-DZgtdGEH.js} (95%) rename pr-preview/pr-18/{nft/assets/index-DPwySeP8.js => counter/assets/index-vwHUmZkR.js} (98%) rename pr-preview/pr-18/{counter/assets/ccip-DPcoRxRw.js => nft/assets/ccip-Dg2WsaJ5.js} (98%) rename pr-preview/pr-18/{counter/assets/hooks.module-Bor_rW54.js => nft/assets/hooks.module-B8KmTTSH.js} (99%) rename pr-preview/pr-18/nft/assets/{index-DLnLZoYS.js => index-BTz10lx0.js} (99%) rename pr-preview/pr-18/{counter/assets/index-BvWy6Y1h.js => nft/assets/index-Bj008S16.js} (99%) rename pr-preview/pr-18/nft/assets/{index-ByHd_ulF.js => index-C7iFs5mH.js} (99%) rename pr-preview/pr-18/{counter/assets/index-CNa-k8Xo.js => nft/assets/index-CVYqMJhC.js} (98%) rename pr-preview/pr-18/nft/assets/{index-CcpJqqKG.js => index-Cn9z8n0i.js} (98%) rename pr-preview/pr-18/nft/assets/{index-BPR1oSZP.js => index-Db3H1vvu.js} (99%) rename pr-preview/pr-18/nft/assets/{index-B7N3rW4p.js => index-MUqciiLU.js} (99%) diff --git a/pr-preview/pr-18/airdrop/assets/HomeCard-B3e90Ry2.js b/pr-preview/pr-18/airdrop/assets/HomeCard-DCnWW-uM.js similarity index 70% rename from pr-preview/pr-18/airdrop/assets/HomeCard-B3e90Ry2.js rename to pr-preview/pr-18/airdrop/assets/HomeCard-DCnWW-uM.js index 4f81d11..ee6e965 100644 --- a/pr-preview/pr-18/airdrop/assets/HomeCard-B3e90Ry2.js +++ b/pr-preview/pr-18/airdrop/assets/HomeCard-DCnWW-uM.js @@ -1,5 +1,5 @@ -import { r as reactExports, d as ThemeContext, e as createTheme, f as THEME_ID, h as defaultTheme, i as generateUtilityClasses, k as generateUtilityClass, s as styled, l as _extends, m as alpha_1, n as useDefaultProps, o as _objectWithoutPropertiesLoose, j as jsxRuntimeExports, p as clsx, q as composeClasses, t as ButtonBase, v as extendSxProp, w as resolveBreakpointValues, x as handleBreakpoints, y as __vitePreload, P as PINATA_JWT, z as useQuery, b as useNavigate } from "./index-OViWMWHH.js"; -import { T as Text } from "./Text-DcZ5ZG-Q.js"; +import { c as createTheme, a as THEME_ID, d as defaultTheme, _ as _extends, b as _objectWithoutPropertiesLoose, g as generateUtilityClasses, e as generateUtilityClass, s as styled, f as alpha_1, u as useDefaultProps, h as composeClasses, k as keyframes, r as rootShouldForwardProp, i as capitalize, j as resolveProps, l as extendSxProp, m as resolveBreakpointValues, n as handleBreakpoints, T as Text } from "./Text-BUUD0p9X.js"; +import { r as reactExports, d as ThemeContext, R as React, j as jsxRuntimeExports, e as clsx, f as __vitePreload, h as PINATA_JWT, i as useQuery, b as useNavigate } from "./index-CUJp9d5D.js"; function isObjectEmpty(obj) { return Object.keys(obj).length === 0; } @@ -11,6 +11,179 @@ const systemDefaultTheme = createTheme(); function useTheme$1(defaultTheme2 = systemDefaultTheme) { return useTheme$2(defaultTheme2); } +const useEnhancedEffect = typeof window !== "undefined" ? reactExports.useLayoutEffect : reactExports.useEffect; +function setRef(ref, value) { + if (typeof ref === "function") { + ref(value); + } else if (ref) { + ref.current = value; + } +} +function useEventCallback(fn) { + const ref = reactExports.useRef(fn); + useEnhancedEffect(() => { + ref.current = fn; + }); + return reactExports.useRef((...args) => ( + // @ts-expect-error hide `this` + (0, ref.current)(...args) + )).current; +} +function useForkRef(...refs) { + return reactExports.useMemo(() => { + if (refs.every((ref) => ref == null)) { + return null; + } + return (instance) => { + refs.forEach((ref) => { + setRef(ref, instance); + }); + }; + }, refs); +} +const UNINITIALIZED = {}; +function useLazyRef(init, initArg) { + const ref = reactExports.useRef(UNINITIALIZED); + if (ref.current === UNINITIALIZED) { + ref.current = init(initArg); + } + return ref; +} +const EMPTY = []; +function useOnMount(fn) { + reactExports.useEffect(fn, EMPTY); +} +class Timeout { + constructor() { + this.currentId = null; + this.clear = () => { + if (this.currentId !== null) { + clearTimeout(this.currentId); + this.currentId = null; + } + }; + this.disposeEffect = () => { + return this.clear; + }; + } + static create() { + return new Timeout(); + } + /** + * Executes `fn` after `delay`, clearing any previously scheduled call. + */ + start(delay, fn) { + this.clear(); + this.currentId = setTimeout(() => { + this.currentId = null; + fn(); + }, delay); + } +} +function useTimeout() { + const timeout = useLazyRef(Timeout.create).current; + useOnMount(timeout.disposeEffect); + return timeout; +} +let hadKeyboardEvent = true; +let hadFocusVisibleRecently = false; +const hadFocusVisibleRecentlyTimeout = new Timeout(); +const inputTypesWhitelist = { + text: true, + search: true, + url: true, + tel: true, + email: true, + password: true, + number: true, + date: true, + month: true, + week: true, + time: true, + datetime: true, + "datetime-local": true +}; +function focusTriggersKeyboardModality(node) { + const { + type, + tagName + } = node; + if (tagName === "INPUT" && inputTypesWhitelist[type] && !node.readOnly) { + return true; + } + if (tagName === "TEXTAREA" && !node.readOnly) { + return true; + } + if (node.isContentEditable) { + return true; + } + return false; +} +function handleKeyDown(event) { + if (event.metaKey || event.altKey || event.ctrlKey) { + return; + } + hadKeyboardEvent = true; +} +function handlePointerDown() { + hadKeyboardEvent = false; +} +function handleVisibilityChange() { + if (this.visibilityState === "hidden") { + if (hadFocusVisibleRecently) { + hadKeyboardEvent = true; + } + } +} +function prepare(doc) { + doc.addEventListener("keydown", handleKeyDown, true); + doc.addEventListener("mousedown", handlePointerDown, true); + doc.addEventListener("pointerdown", handlePointerDown, true); + doc.addEventListener("touchstart", handlePointerDown, true); + doc.addEventListener("visibilitychange", handleVisibilityChange, true); +} +function isFocusVisible(event) { + const { + target + } = event; + try { + return target.matches(":focus-visible"); + } catch (error) { + } + return hadKeyboardEvent || focusTriggersKeyboardModality(target); +} +function useIsFocusVisible() { + const ref = reactExports.useCallback((node) => { + if (node != null) { + prepare(node.ownerDocument); + } + }, []); + const isFocusVisibleRef = reactExports.useRef(false); + function handleBlurVisible() { + if (isFocusVisibleRef.current) { + hadFocusVisibleRecently = true; + hadFocusVisibleRecentlyTimeout.start(100, () => { + hadFocusVisibleRecently = false; + }); + isFocusVisibleRef.current = false; + return true; + } + return false; + } + function handleFocusVisible(event) { + if (isFocusVisible(event)) { + isFocusVisibleRef.current = true; + return true; + } + return false; + } + return { + isFocusVisibleRef, + onFocus: handleFocusVisible, + onBlur: handleBlurVisible, + ref + }; +} function useTheme() { const theme = useTheme$1(defaultTheme); return theme[THEME_ID] || theme; @@ -24,12 +197,198 @@ const getOverlayAlpha = (elevation) => { } return (alphaValue / 100).toFixed(2); }; +function _setPrototypeOf(t, e) { + return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) { + return t2.__proto__ = e2, t2; + }, _setPrototypeOf(t, e); +} +function _inheritsLoose(t, o) { + t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); +} +const TransitionGroupContext = React.createContext(null); +function _assertThisInitialized(e) { + if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return e; +} +function getChildMapping(children, mapFn) { + var mapper = function mapper2(child) { + return mapFn && reactExports.isValidElement(child) ? mapFn(child) : child; + }; + var result = /* @__PURE__ */ Object.create(null); + if (children) reactExports.Children.map(children, function(c) { + return c; + }).forEach(function(child) { + result[child.key] = mapper(child); + }); + return result; +} +function mergeChildMappings(prev, next) { + prev = prev || {}; + next = next || {}; + function getValueForKey(key) { + return key in next ? next[key] : prev[key]; + } + var nextKeysPending = /* @__PURE__ */ Object.create(null); + var pendingKeys = []; + for (var prevKey in prev) { + if (prevKey in next) { + if (pendingKeys.length) { + nextKeysPending[prevKey] = pendingKeys; + pendingKeys = []; + } + } else { + pendingKeys.push(prevKey); + } + } + var i; + var childMapping = {}; + for (var nextKey in next) { + if (nextKeysPending[nextKey]) { + for (i = 0; i < nextKeysPending[nextKey].length; i++) { + var pendingNextKey = nextKeysPending[nextKey][i]; + childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey); + } + } + childMapping[nextKey] = getValueForKey(nextKey); + } + for (i = 0; i < pendingKeys.length; i++) { + childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]); + } + return childMapping; +} +function getProp(child, prop, props) { + return props[prop] != null ? props[prop] : child.props[prop]; +} +function getInitialChildMapping(props, onExited) { + return getChildMapping(props.children, function(child) { + return reactExports.cloneElement(child, { + onExited: onExited.bind(null, child), + in: true, + appear: getProp(child, "appear", props), + enter: getProp(child, "enter", props), + exit: getProp(child, "exit", props) + }); + }); +} +function getNextChildMapping(nextProps, prevChildMapping, onExited) { + var nextChildMapping = getChildMapping(nextProps.children); + var children = mergeChildMappings(prevChildMapping, nextChildMapping); + Object.keys(children).forEach(function(key) { + var child = children[key]; + if (!reactExports.isValidElement(child)) return; + var hasPrev = key in prevChildMapping; + var hasNext = key in nextChildMapping; + var prevChild = prevChildMapping[key]; + var isLeaving = reactExports.isValidElement(prevChild) && !prevChild.props.in; + if (hasNext && (!hasPrev || isLeaving)) { + children[key] = reactExports.cloneElement(child, { + onExited: onExited.bind(null, child), + in: true, + exit: getProp(child, "exit", nextProps), + enter: getProp(child, "enter", nextProps) + }); + } else if (!hasNext && hasPrev && !isLeaving) { + children[key] = reactExports.cloneElement(child, { + in: false + }); + } else if (hasNext && hasPrev && reactExports.isValidElement(prevChild)) { + children[key] = reactExports.cloneElement(child, { + onExited: onExited.bind(null, child), + in: prevChild.props.in, + exit: getProp(child, "exit", nextProps), + enter: getProp(child, "enter", nextProps) + }); + } + }); + return children; +} +var values = Object.values || function(obj) { + return Object.keys(obj).map(function(k) { + return obj[k]; + }); +}; +var defaultProps = { + component: "div", + childFactory: function childFactory(child) { + return child; + } +}; +var TransitionGroup = /* @__PURE__ */ function(_React$Component) { + _inheritsLoose(TransitionGroup2, _React$Component); + function TransitionGroup2(props, context) { + var _this; + _this = _React$Component.call(this, props, context) || this; + var handleExited = _this.handleExited.bind(_assertThisInitialized(_this)); + _this.state = { + contextValue: { + isMounting: true + }, + handleExited, + firstRender: true + }; + return _this; + } + var _proto = TransitionGroup2.prototype; + _proto.componentDidMount = function componentDidMount() { + this.mounted = true; + this.setState({ + contextValue: { + isMounting: false + } + }); + }; + _proto.componentWillUnmount = function componentWillUnmount() { + this.mounted = false; + }; + TransitionGroup2.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) { + var prevChildMapping = _ref.children, handleExited = _ref.handleExited, firstRender = _ref.firstRender; + return { + children: firstRender ? getInitialChildMapping(nextProps, handleExited) : getNextChildMapping(nextProps, prevChildMapping, handleExited), + firstRender: false + }; + }; + _proto.handleExited = function handleExited(child, node) { + var currentChildMapping = getChildMapping(this.props.children); + if (child.key in currentChildMapping) return; + if (child.props.onExited) { + child.props.onExited(node); + } + if (this.mounted) { + this.setState(function(state) { + var children = _extends({}, state.children); + delete children[child.key]; + return { + children + }; + }); + } + }; + _proto.render = function render() { + var _this$props = this.props, Component = _this$props.component, childFactory2 = _this$props.childFactory, props = _objectWithoutPropertiesLoose(_this$props, ["component", "childFactory"]); + var contextValue = this.state.contextValue; + var children = values(this.state.children).map(childFactory2); + delete props.appear; + delete props.enter; + delete props.exit; + if (Component === null) { + return /* @__PURE__ */ React.createElement(TransitionGroupContext.Provider, { + value: contextValue + }, children); + } + return /* @__PURE__ */ React.createElement(TransitionGroupContext.Provider, { + value: contextValue + }, /* @__PURE__ */ React.createElement(Component, props, children)); + }; + return TransitionGroup2; +}(React.Component); +TransitionGroup.propTypes = {}; +TransitionGroup.defaultProps = defaultProps; function getPaperUtilityClass(slot) { return generateUtilityClass("MuiPaper", slot); } generateUtilityClasses("MuiPaper", ["root", "rounded", "outlined", "elevation", "elevation0", "elevation1", "elevation2", "elevation3", "elevation4", "elevation5", "elevation6", "elevation7", "elevation8", "elevation9", "elevation10", "elevation11", "elevation12", "elevation13", "elevation14", "elevation15", "elevation16", "elevation17", "elevation18", "elevation19", "elevation20", "elevation21", "elevation22", "elevation23", "elevation24"]); -const _excluded$4 = ["className", "component", "elevation", "square", "variant"]; -const useUtilityClasses$4 = (ownerState) => { +const _excluded$7 = ["className", "component", "elevation", "square", "variant"]; +const useUtilityClasses$6 = (ownerState) => { const { square, elevation, @@ -82,14 +441,14 @@ const Paper = /* @__PURE__ */ reactExports.forwardRef(function Paper2(inProps, r elevation = 1, square = false, variant = "elevation" - } = props, other = _objectWithoutPropertiesLoose(props, _excluded$4); + } = props, other = _objectWithoutPropertiesLoose(props, _excluded$7); const ownerState = _extends({}, props, { component, elevation, square, variant }); - const classes = useUtilityClasses$4(ownerState); + const classes = useUtilityClasses$6(ownerState); return /* @__PURE__ */ jsxRuntimeExports.jsx(PaperRoot, _extends({ as: component, ownerState, @@ -97,6 +456,864 @@ const Paper = /* @__PURE__ */ reactExports.forwardRef(function Paper2(inProps, r ref }, other)); }); +function Ripple(props) { + const { + className, + classes, + pulsate = false, + rippleX, + rippleY, + rippleSize, + in: inProp, + onExited, + timeout + } = props; + const [leaving, setLeaving] = reactExports.useState(false); + const rippleClassName = clsx(className, classes.ripple, classes.rippleVisible, pulsate && classes.ripplePulsate); + const rippleStyles = { + width: rippleSize, + height: rippleSize, + top: -(rippleSize / 2) + rippleY, + left: -(rippleSize / 2) + rippleX + }; + const childClassName = clsx(classes.child, leaving && classes.childLeaving, pulsate && classes.childPulsate); + if (!inProp && !leaving) { + setLeaving(true); + } + reactExports.useEffect(() => { + if (!inProp && onExited != null) { + const timeoutId = setTimeout(onExited, timeout); + return () => { + clearTimeout(timeoutId); + }; + } + return void 0; + }, [onExited, inProp, timeout]); + return /* @__PURE__ */ jsxRuntimeExports.jsx("span", { + className: rippleClassName, + style: rippleStyles, + children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { + className: childClassName + }) + }); +} +const touchRippleClasses = generateUtilityClasses("MuiTouchRipple", ["root", "ripple", "rippleVisible", "ripplePulsate", "child", "childLeaving", "childPulsate"]); +const _excluded$6 = ["center", "classes", "className"]; +let _ = (t) => t, _t, _t2, _t3, _t4; +const DURATION = 550; +const DELAY_RIPPLE = 80; +const enterKeyframe = keyframes(_t || (_t = _` + 0% { + transform: scale(0); + opacity: 0.1; + } + + 100% { + transform: scale(1); + opacity: 0.3; + } +`)); +const exitKeyframe = keyframes(_t2 || (_t2 = _` + 0% { + opacity: 1; + } + + 100% { + opacity: 0; + } +`)); +const pulsateKeyframe = keyframes(_t3 || (_t3 = _` + 0% { + transform: scale(1); + } + + 50% { + transform: scale(0.92); + } + + 100% { + transform: scale(1); + } +`)); +const TouchRippleRoot = styled("span", { + name: "MuiTouchRipple", + slot: "Root" +})({ + overflow: "hidden", + pointerEvents: "none", + position: "absolute", + zIndex: 0, + top: 0, + right: 0, + bottom: 0, + left: 0, + borderRadius: "inherit" +}); +const TouchRippleRipple = styled(Ripple, { + name: "MuiTouchRipple", + slot: "Ripple" +})(_t4 || (_t4 = _` + opacity: 0; + position: absolute; + + &.${0} { + opacity: 0.3; + transform: scale(1); + animation-name: ${0}; + animation-duration: ${0}ms; + animation-timing-function: ${0}; + } + + &.${0} { + animation-duration: ${0}ms; + } + + & .${0} { + opacity: 1; + display: block; + width: 100%; + height: 100%; + border-radius: 50%; + background-color: currentColor; + } + + & .${0} { + opacity: 0; + animation-name: ${0}; + animation-duration: ${0}ms; + animation-timing-function: ${0}; + } + + & .${0} { + position: absolute; + /* @noflip */ + left: 0px; + top: 0; + animation-name: ${0}; + animation-duration: 2500ms; + animation-timing-function: ${0}; + animation-iteration-count: infinite; + animation-delay: 200ms; + } +`), touchRippleClasses.rippleVisible, enterKeyframe, DURATION, ({ + theme +}) => theme.transitions.easing.easeInOut, touchRippleClasses.ripplePulsate, ({ + theme +}) => theme.transitions.duration.shorter, touchRippleClasses.child, touchRippleClasses.childLeaving, exitKeyframe, DURATION, ({ + theme +}) => theme.transitions.easing.easeInOut, touchRippleClasses.childPulsate, pulsateKeyframe, ({ + theme +}) => theme.transitions.easing.easeInOut); +const TouchRipple = /* @__PURE__ */ reactExports.forwardRef(function TouchRipple2(inProps, ref) { + const props = useDefaultProps({ + props: inProps, + name: "MuiTouchRipple" + }); + const { + center: centerProp = false, + classes = {}, + className + } = props, other = _objectWithoutPropertiesLoose(props, _excluded$6); + const [ripples, setRipples] = reactExports.useState([]); + const nextKey = reactExports.useRef(0); + const rippleCallback = reactExports.useRef(null); + reactExports.useEffect(() => { + if (rippleCallback.current) { + rippleCallback.current(); + rippleCallback.current = null; + } + }, [ripples]); + const ignoringMouseDown = reactExports.useRef(false); + const startTimer = useTimeout(); + const startTimerCommit = reactExports.useRef(null); + const container = reactExports.useRef(null); + const startCommit = reactExports.useCallback((params) => { + const { + pulsate: pulsate2, + rippleX, + rippleY, + rippleSize, + cb + } = params; + setRipples((oldRipples) => [...oldRipples, /* @__PURE__ */ jsxRuntimeExports.jsx(TouchRippleRipple, { + classes: { + ripple: clsx(classes.ripple, touchRippleClasses.ripple), + rippleVisible: clsx(classes.rippleVisible, touchRippleClasses.rippleVisible), + ripplePulsate: clsx(classes.ripplePulsate, touchRippleClasses.ripplePulsate), + child: clsx(classes.child, touchRippleClasses.child), + childLeaving: clsx(classes.childLeaving, touchRippleClasses.childLeaving), + childPulsate: clsx(classes.childPulsate, touchRippleClasses.childPulsate) + }, + timeout: DURATION, + pulsate: pulsate2, + rippleX, + rippleY, + rippleSize + }, nextKey.current)]); + nextKey.current += 1; + rippleCallback.current = cb; + }, [classes]); + const start = reactExports.useCallback((event = {}, options = {}, cb = () => { + }) => { + const { + pulsate: pulsate2 = false, + center = centerProp || options.pulsate, + fakeElement = false + // For test purposes + } = options; + if ((event == null ? void 0 : event.type) === "mousedown" && ignoringMouseDown.current) { + ignoringMouseDown.current = false; + return; + } + if ((event == null ? void 0 : event.type) === "touchstart") { + ignoringMouseDown.current = true; + } + const element = fakeElement ? null : container.current; + const rect = element ? element.getBoundingClientRect() : { + width: 0, + height: 0, + left: 0, + top: 0 + }; + let rippleX; + let rippleY; + let rippleSize; + if (center || event === void 0 || event.clientX === 0 && event.clientY === 0 || !event.clientX && !event.touches) { + rippleX = Math.round(rect.width / 2); + rippleY = Math.round(rect.height / 2); + } else { + const { + clientX, + clientY + } = event.touches && event.touches.length > 0 ? event.touches[0] : event; + rippleX = Math.round(clientX - rect.left); + rippleY = Math.round(clientY - rect.top); + } + if (center) { + rippleSize = Math.sqrt((2 * rect.width ** 2 + rect.height ** 2) / 3); + if (rippleSize % 2 === 0) { + rippleSize += 1; + } + } else { + const sizeX = Math.max(Math.abs((element ? element.clientWidth : 0) - rippleX), rippleX) * 2 + 2; + const sizeY = Math.max(Math.abs((element ? element.clientHeight : 0) - rippleY), rippleY) * 2 + 2; + rippleSize = Math.sqrt(sizeX ** 2 + sizeY ** 2); + } + if (event != null && event.touches) { + if (startTimerCommit.current === null) { + startTimerCommit.current = () => { + startCommit({ + pulsate: pulsate2, + rippleX, + rippleY, + rippleSize, + cb + }); + }; + startTimer.start(DELAY_RIPPLE, () => { + if (startTimerCommit.current) { + startTimerCommit.current(); + startTimerCommit.current = null; + } + }); + } + } else { + startCommit({ + pulsate: pulsate2, + rippleX, + rippleY, + rippleSize, + cb + }); + } + }, [centerProp, startCommit, startTimer]); + const pulsate = reactExports.useCallback(() => { + start({}, { + pulsate: true + }); + }, [start]); + const stop = reactExports.useCallback((event, cb) => { + startTimer.clear(); + if ((event == null ? void 0 : event.type) === "touchend" && startTimerCommit.current) { + startTimerCommit.current(); + startTimerCommit.current = null; + startTimer.start(0, () => { + stop(event, cb); + }); + return; + } + startTimerCommit.current = null; + setRipples((oldRipples) => { + if (oldRipples.length > 0) { + return oldRipples.slice(1); + } + return oldRipples; + }); + rippleCallback.current = cb; + }, [startTimer]); + reactExports.useImperativeHandle(ref, () => ({ + pulsate, + start, + stop + }), [pulsate, start, stop]); + return /* @__PURE__ */ jsxRuntimeExports.jsx(TouchRippleRoot, _extends({ + className: clsx(touchRippleClasses.root, classes.root, className), + ref: container + }, other, { + children: /* @__PURE__ */ jsxRuntimeExports.jsx(TransitionGroup, { + component: null, + exit: true, + children: ripples + }) + })); +}); +function getButtonBaseUtilityClass(slot) { + return generateUtilityClass("MuiButtonBase", slot); +} +const buttonBaseClasses = generateUtilityClasses("MuiButtonBase", ["root", "disabled", "focusVisible"]); +const _excluded$5 = ["action", "centerRipple", "children", "className", "component", "disabled", "disableRipple", "disableTouchRipple", "focusRipple", "focusVisibleClassName", "LinkComponent", "onBlur", "onClick", "onContextMenu", "onDragLeave", "onFocus", "onFocusVisible", "onKeyDown", "onKeyUp", "onMouseDown", "onMouseLeave", "onMouseUp", "onTouchEnd", "onTouchMove", "onTouchStart", "tabIndex", "TouchRippleProps", "touchRippleRef", "type"]; +const useUtilityClasses$5 = (ownerState) => { + const { + disabled, + focusVisible, + focusVisibleClassName, + classes + } = ownerState; + const slots = { + root: ["root", disabled && "disabled", focusVisible && "focusVisible"] + }; + const composedClasses = composeClasses(slots, getButtonBaseUtilityClass, classes); + if (focusVisible && focusVisibleClassName) { + composedClasses.root += ` ${focusVisibleClassName}`; + } + return composedClasses; +}; +const ButtonBaseRoot = styled("button", { + name: "MuiButtonBase", + slot: "Root", + overridesResolver: (props, styles) => styles.root +})({ + display: "inline-flex", + alignItems: "center", + justifyContent: "center", + position: "relative", + boxSizing: "border-box", + WebkitTapHighlightColor: "transparent", + backgroundColor: "transparent", + // Reset default value + // We disable the focus ring for mouse, touch and keyboard users. + outline: 0, + border: 0, + margin: 0, + // Remove the margin in Safari + borderRadius: 0, + padding: 0, + // Remove the padding in Firefox + cursor: "pointer", + userSelect: "none", + verticalAlign: "middle", + MozAppearance: "none", + // Reset + WebkitAppearance: "none", + // Reset + textDecoration: "none", + // So we take precedent over the style of a native element. + color: "inherit", + "&::-moz-focus-inner": { + borderStyle: "none" + // Remove Firefox dotted outline. + }, + [`&.${buttonBaseClasses.disabled}`]: { + pointerEvents: "none", + // Disable link interactions + cursor: "default" + }, + "@media print": { + colorAdjust: "exact" + } +}); +const ButtonBase = /* @__PURE__ */ reactExports.forwardRef(function ButtonBase2(inProps, ref) { + const props = useDefaultProps({ + props: inProps, + name: "MuiButtonBase" + }); + const { + action, + centerRipple = false, + children, + className, + component = "button", + disabled = false, + disableRipple = false, + disableTouchRipple = false, + focusRipple = false, + LinkComponent = "a", + onBlur, + onClick, + onContextMenu, + onDragLeave, + onFocus, + onFocusVisible, + onKeyDown, + onKeyUp, + onMouseDown, + onMouseLeave, + onMouseUp, + onTouchEnd, + onTouchMove, + onTouchStart, + tabIndex = 0, + TouchRippleProps, + touchRippleRef, + type + } = props, other = _objectWithoutPropertiesLoose(props, _excluded$5); + const buttonRef = reactExports.useRef(null); + const rippleRef = reactExports.useRef(null); + const handleRippleRef = useForkRef(rippleRef, touchRippleRef); + const { + isFocusVisibleRef, + onFocus: handleFocusVisible, + onBlur: handleBlurVisible, + ref: focusVisibleRef + } = useIsFocusVisible(); + const [focusVisible, setFocusVisible] = reactExports.useState(false); + if (disabled && focusVisible) { + setFocusVisible(false); + } + reactExports.useImperativeHandle(action, () => ({ + focusVisible: () => { + setFocusVisible(true); + buttonRef.current.focus(); + } + }), []); + const [mountedState, setMountedState] = reactExports.useState(false); + reactExports.useEffect(() => { + setMountedState(true); + }, []); + const enableTouchRipple = mountedState && !disableRipple && !disabled; + reactExports.useEffect(() => { + if (focusVisible && focusRipple && !disableRipple && mountedState) { + rippleRef.current.pulsate(); + } + }, [disableRipple, focusRipple, focusVisible, mountedState]); + function useRippleHandler(rippleAction, eventCallback, skipRippleAction = disableTouchRipple) { + return useEventCallback((event) => { + if (eventCallback) { + eventCallback(event); + } + const ignore = skipRippleAction; + if (!ignore && rippleRef.current) { + rippleRef.current[rippleAction](event); + } + return true; + }); + } + const handleMouseDown = useRippleHandler("start", onMouseDown); + const handleContextMenu = useRippleHandler("stop", onContextMenu); + const handleDragLeave = useRippleHandler("stop", onDragLeave); + const handleMouseUp = useRippleHandler("stop", onMouseUp); + const handleMouseLeave = useRippleHandler("stop", (event) => { + if (focusVisible) { + event.preventDefault(); + } + if (onMouseLeave) { + onMouseLeave(event); + } + }); + const handleTouchStart = useRippleHandler("start", onTouchStart); + const handleTouchEnd = useRippleHandler("stop", onTouchEnd); + const handleTouchMove = useRippleHandler("stop", onTouchMove); + const handleBlur = useRippleHandler("stop", (event) => { + handleBlurVisible(event); + if (isFocusVisibleRef.current === false) { + setFocusVisible(false); + } + if (onBlur) { + onBlur(event); + } + }, false); + const handleFocus = useEventCallback((event) => { + if (!buttonRef.current) { + buttonRef.current = event.currentTarget; + } + handleFocusVisible(event); + if (isFocusVisibleRef.current === true) { + setFocusVisible(true); + if (onFocusVisible) { + onFocusVisible(event); + } + } + if (onFocus) { + onFocus(event); + } + }); + const isNonNativeButton = () => { + const button = buttonRef.current; + return component && component !== "button" && !(button.tagName === "A" && button.href); + }; + const keydownRef = reactExports.useRef(false); + const handleKeyDown2 = useEventCallback((event) => { + if (focusRipple && !keydownRef.current && focusVisible && rippleRef.current && event.key === " ") { + keydownRef.current = true; + rippleRef.current.stop(event, () => { + rippleRef.current.start(event); + }); + } + if (event.target === event.currentTarget && isNonNativeButton() && event.key === " ") { + event.preventDefault(); + } + if (onKeyDown) { + onKeyDown(event); + } + if (event.target === event.currentTarget && isNonNativeButton() && event.key === "Enter" && !disabled) { + event.preventDefault(); + if (onClick) { + onClick(event); + } + } + }); + const handleKeyUp = useEventCallback((event) => { + if (focusRipple && event.key === " " && rippleRef.current && focusVisible && !event.defaultPrevented) { + keydownRef.current = false; + rippleRef.current.stop(event, () => { + rippleRef.current.pulsate(event); + }); + } + if (onKeyUp) { + onKeyUp(event); + } + if (onClick && event.target === event.currentTarget && isNonNativeButton() && event.key === " " && !event.defaultPrevented) { + onClick(event); + } + }); + let ComponentProp = component; + if (ComponentProp === "button" && (other.href || other.to)) { + ComponentProp = LinkComponent; + } + const buttonProps = {}; + if (ComponentProp === "button") { + buttonProps.type = type === void 0 ? "button" : type; + buttonProps.disabled = disabled; + } else { + if (!other.href && !other.to) { + buttonProps.role = "button"; + } + if (disabled) { + buttonProps["aria-disabled"] = disabled; + } + } + const handleRef = useForkRef(ref, focusVisibleRef, buttonRef); + const ownerState = _extends({}, props, { + centerRipple, + component, + disabled, + disableRipple, + disableTouchRipple, + focusRipple, + tabIndex, + focusVisible + }); + const classes = useUtilityClasses$5(ownerState); + return /* @__PURE__ */ jsxRuntimeExports.jsxs(ButtonBaseRoot, _extends({ + as: ComponentProp, + className: clsx(classes.root, className), + ownerState, + onBlur: handleBlur, + onClick, + onContextMenu: handleContextMenu, + onFocus: handleFocus, + onKeyDown: handleKeyDown2, + onKeyUp: handleKeyUp, + onMouseDown: handleMouseDown, + onMouseLeave: handleMouseLeave, + onMouseUp: handleMouseUp, + onDragLeave: handleDragLeave, + onTouchEnd: handleTouchEnd, + onTouchMove: handleTouchMove, + onTouchStart: handleTouchStart, + ref: handleRef, + tabIndex: disabled ? -1 : tabIndex, + type + }, buttonProps, other, { + children: [children, enableTouchRipple ? ( + /* TouchRipple is only needed client-side, x2 boost on the server. */ + /* @__PURE__ */ jsxRuntimeExports.jsx(TouchRipple, _extends({ + ref: handleRippleRef, + center: centerRipple + }, TouchRippleProps)) + ) : null] + })); +}); +function getButtonUtilityClass(slot) { + return generateUtilityClass("MuiButton", slot); +} +const buttonClasses = generateUtilityClasses("MuiButton", ["root", "text", "textInherit", "textPrimary", "textSecondary", "textSuccess", "textError", "textInfo", "textWarning", "outlined", "outlinedInherit", "outlinedPrimary", "outlinedSecondary", "outlinedSuccess", "outlinedError", "outlinedInfo", "outlinedWarning", "contained", "containedInherit", "containedPrimary", "containedSecondary", "containedSuccess", "containedError", "containedInfo", "containedWarning", "disableElevation", "focusVisible", "disabled", "colorInherit", "colorPrimary", "colorSecondary", "colorSuccess", "colorError", "colorInfo", "colorWarning", "textSizeSmall", "textSizeMedium", "textSizeLarge", "outlinedSizeSmall", "outlinedSizeMedium", "outlinedSizeLarge", "containedSizeSmall", "containedSizeMedium", "containedSizeLarge", "sizeMedium", "sizeSmall", "sizeLarge", "fullWidth", "startIcon", "endIcon", "icon", "iconSizeSmall", "iconSizeMedium", "iconSizeLarge"]); +const ButtonGroupContext = /* @__PURE__ */ reactExports.createContext({}); +const ButtonGroupButtonContext = /* @__PURE__ */ reactExports.createContext(void 0); +const _excluded$4 = ["children", "color", "component", "className", "disabled", "disableElevation", "disableFocusRipple", "endIcon", "focusVisibleClassName", "fullWidth", "size", "startIcon", "type", "variant"]; +const useUtilityClasses$4 = (ownerState) => { + const { + color, + disableElevation, + fullWidth, + size, + variant, + classes + } = ownerState; + const slots = { + root: ["root", variant, `${variant}${capitalize(color)}`, `size${capitalize(size)}`, `${variant}Size${capitalize(size)}`, `color${capitalize(color)}`, disableElevation && "disableElevation", fullWidth && "fullWidth"], + label: ["label"], + startIcon: ["icon", "startIcon", `iconSize${capitalize(size)}`], + endIcon: ["icon", "endIcon", `iconSize${capitalize(size)}`] + }; + const composedClasses = composeClasses(slots, getButtonUtilityClass, classes); + return _extends({}, classes, composedClasses); +}; +const commonIconStyles = (ownerState) => _extends({}, ownerState.size === "small" && { + "& > *:nth-of-type(1)": { + fontSize: 18 + } +}, ownerState.size === "medium" && { + "& > *:nth-of-type(1)": { + fontSize: 20 + } +}, ownerState.size === "large" && { + "& > *:nth-of-type(1)": { + fontSize: 22 + } +}); +const ButtonRoot = styled(ButtonBase, { + shouldForwardProp: (prop) => rootShouldForwardProp(prop) || prop === "classes", + name: "MuiButton", + slot: "Root", + overridesResolver: (props, styles) => { + const { + ownerState + } = props; + return [styles.root, styles[ownerState.variant], styles[`${ownerState.variant}${capitalize(ownerState.color)}`], styles[`size${capitalize(ownerState.size)}`], styles[`${ownerState.variant}Size${capitalize(ownerState.size)}`], ownerState.color === "inherit" && styles.colorInherit, ownerState.disableElevation && styles.disableElevation, ownerState.fullWidth && styles.fullWidth]; + } +})(({ + theme, + ownerState +}) => { + var _theme$palette$getCon, _theme$palette; + const inheritContainedBackgroundColor = theme.palette.mode === "light" ? theme.palette.grey[300] : theme.palette.grey[800]; + const inheritContainedHoverBackgroundColor = theme.palette.mode === "light" ? theme.palette.grey.A100 : theme.palette.grey[700]; + return _extends({}, theme.typography.button, { + minWidth: 64, + padding: "6px 16px", + borderRadius: (theme.vars || theme).shape.borderRadius, + transition: theme.transitions.create(["background-color", "box-shadow", "border-color", "color"], { + duration: theme.transitions.duration.short + }), + "&:hover": _extends({ + textDecoration: "none", + backgroundColor: theme.vars ? `rgba(${theme.vars.palette.text.primaryChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha_1(theme.palette.text.primary, theme.palette.action.hoverOpacity), + // Reset on touch devices, it doesn't add specificity + "@media (hover: none)": { + backgroundColor: "transparent" + } + }, ownerState.variant === "text" && ownerState.color !== "inherit" && { + backgroundColor: theme.vars ? `rgba(${theme.vars.palette[ownerState.color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha_1(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity), + // Reset on touch devices, it doesn't add specificity + "@media (hover: none)": { + backgroundColor: "transparent" + } + }, ownerState.variant === "outlined" && ownerState.color !== "inherit" && { + border: `1px solid ${(theme.vars || theme).palette[ownerState.color].main}`, + backgroundColor: theme.vars ? `rgba(${theme.vars.palette[ownerState.color].mainChannel} / ${theme.vars.palette.action.hoverOpacity})` : alpha_1(theme.palette[ownerState.color].main, theme.palette.action.hoverOpacity), + // Reset on touch devices, it doesn't add specificity + "@media (hover: none)": { + backgroundColor: "transparent" + } + }, ownerState.variant === "contained" && { + backgroundColor: theme.vars ? theme.vars.palette.Button.inheritContainedHoverBg : inheritContainedHoverBackgroundColor, + boxShadow: (theme.vars || theme).shadows[4], + // Reset on touch devices, it doesn't add specificity + "@media (hover: none)": { + boxShadow: (theme.vars || theme).shadows[2], + backgroundColor: (theme.vars || theme).palette.grey[300] + } + }, ownerState.variant === "contained" && ownerState.color !== "inherit" && { + backgroundColor: (theme.vars || theme).palette[ownerState.color].dark, + // Reset on touch devices, it doesn't add specificity + "@media (hover: none)": { + backgroundColor: (theme.vars || theme).palette[ownerState.color].main + } + }), + "&:active": _extends({}, ownerState.variant === "contained" && { + boxShadow: (theme.vars || theme).shadows[8] + }), + [`&.${buttonClasses.focusVisible}`]: _extends({}, ownerState.variant === "contained" && { + boxShadow: (theme.vars || theme).shadows[6] + }), + [`&.${buttonClasses.disabled}`]: _extends({ + color: (theme.vars || theme).palette.action.disabled + }, ownerState.variant === "outlined" && { + border: `1px solid ${(theme.vars || theme).palette.action.disabledBackground}` + }, ownerState.variant === "contained" && { + color: (theme.vars || theme).palette.action.disabled, + boxShadow: (theme.vars || theme).shadows[0], + backgroundColor: (theme.vars || theme).palette.action.disabledBackground + }) + }, ownerState.variant === "text" && { + padding: "6px 8px" + }, ownerState.variant === "text" && ownerState.color !== "inherit" && { + color: (theme.vars || theme).palette[ownerState.color].main + }, ownerState.variant === "outlined" && { + padding: "5px 15px", + border: "1px solid currentColor" + }, ownerState.variant === "outlined" && ownerState.color !== "inherit" && { + color: (theme.vars || theme).palette[ownerState.color].main, + border: theme.vars ? `1px solid rgba(${theme.vars.palette[ownerState.color].mainChannel} / 0.5)` : `1px solid ${alpha_1(theme.palette[ownerState.color].main, 0.5)}` + }, ownerState.variant === "contained" && { + color: theme.vars ? ( + // this is safe because grey does not change between default light/dark mode + theme.vars.palette.text.primary + ) : (_theme$palette$getCon = (_theme$palette = theme.palette).getContrastText) == null ? void 0 : _theme$palette$getCon.call(_theme$palette, theme.palette.grey[300]), + backgroundColor: theme.vars ? theme.vars.palette.Button.inheritContainedBg : inheritContainedBackgroundColor, + boxShadow: (theme.vars || theme).shadows[2] + }, ownerState.variant === "contained" && ownerState.color !== "inherit" && { + color: (theme.vars || theme).palette[ownerState.color].contrastText, + backgroundColor: (theme.vars || theme).palette[ownerState.color].main + }, ownerState.color === "inherit" && { + color: "inherit", + borderColor: "currentColor" + }, ownerState.size === "small" && ownerState.variant === "text" && { + padding: "4px 5px", + fontSize: theme.typography.pxToRem(13) + }, ownerState.size === "large" && ownerState.variant === "text" && { + padding: "8px 11px", + fontSize: theme.typography.pxToRem(15) + }, ownerState.size === "small" && ownerState.variant === "outlined" && { + padding: "3px 9px", + fontSize: theme.typography.pxToRem(13) + }, ownerState.size === "large" && ownerState.variant === "outlined" && { + padding: "7px 21px", + fontSize: theme.typography.pxToRem(15) + }, ownerState.size === "small" && ownerState.variant === "contained" && { + padding: "4px 10px", + fontSize: theme.typography.pxToRem(13) + }, ownerState.size === "large" && ownerState.variant === "contained" && { + padding: "8px 22px", + fontSize: theme.typography.pxToRem(15) + }, ownerState.fullWidth && { + width: "100%" + }); +}, ({ + ownerState +}) => ownerState.disableElevation && { + boxShadow: "none", + "&:hover": { + boxShadow: "none" + }, + [`&.${buttonClasses.focusVisible}`]: { + boxShadow: "none" + }, + "&:active": { + boxShadow: "none" + }, + [`&.${buttonClasses.disabled}`]: { + boxShadow: "none" + } +}); +const ButtonStartIcon = styled("span", { + name: "MuiButton", + slot: "StartIcon", + overridesResolver: (props, styles) => { + const { + ownerState + } = props; + return [styles.startIcon, styles[`iconSize${capitalize(ownerState.size)}`]]; + } +})(({ + ownerState +}) => _extends({ + display: "inherit", + marginRight: 8, + marginLeft: -4 +}, ownerState.size === "small" && { + marginLeft: -2 +}, commonIconStyles(ownerState))); +const ButtonEndIcon = styled("span", { + name: "MuiButton", + slot: "EndIcon", + overridesResolver: (props, styles) => { + const { + ownerState + } = props; + return [styles.endIcon, styles[`iconSize${capitalize(ownerState.size)}`]]; + } +})(({ + ownerState +}) => _extends({ + display: "inherit", + marginRight: -4, + marginLeft: 8 +}, ownerState.size === "small" && { + marginRight: -2 +}, commonIconStyles(ownerState))); +const Button$1 = /* @__PURE__ */ reactExports.forwardRef(function Button2(inProps, ref) { + const contextProps = reactExports.useContext(ButtonGroupContext); + const buttonGroupButtonContextPositionClassName = reactExports.useContext(ButtonGroupButtonContext); + const resolvedProps = resolveProps(contextProps, inProps); + const props = useDefaultProps({ + props: resolvedProps, + name: "MuiButton" + }); + const { + children, + color = "primary", + component = "button", + className, + disabled = false, + disableElevation = false, + disableFocusRipple = false, + endIcon: endIconProp, + focusVisibleClassName, + fullWidth = false, + size = "medium", + startIcon: startIconProp, + type, + variant = "text" + } = props, other = _objectWithoutPropertiesLoose(props, _excluded$4); + const ownerState = _extends({}, props, { + color, + component, + disabled, + disableElevation, + disableFocusRipple, + fullWidth, + size, + type, + variant + }); + const classes = useUtilityClasses$4(ownerState); + const startIcon = startIconProp && /* @__PURE__ */ jsxRuntimeExports.jsx(ButtonStartIcon, { + className: classes.startIcon, + ownerState, + children: startIconProp + }); + const endIcon = endIconProp && /* @__PURE__ */ jsxRuntimeExports.jsx(ButtonEndIcon, { + className: classes.endIcon, + ownerState, + children: endIconProp + }); + const positionClassName = buttonGroupButtonContextPositionClassName || ""; + return /* @__PURE__ */ jsxRuntimeExports.jsxs(ButtonRoot, _extends({ + ownerState, + className: clsx(contextProps.className, classes.root, className, positionClassName), + component, + disabled, + focusRipple: !disableFocusRipple, + focusVisibleClassName: clsx(classes.focusVisible, focusVisibleClassName), + ref, + type + }, other, { + classes, + children: [startIcon, children, endIcon] + })); +}); function getCardUtilityClass(slot) { return generateUtilityClass("MuiCard", slot); } @@ -385,14 +1602,14 @@ function generateDirection({ } function extractZeroValueBreakpointKeys({ breakpoints, - values + values: values2 }) { let nonZeroKey = ""; - Object.keys(values).forEach((key) => { + Object.keys(values2).forEach((key) => { if (nonZeroKey !== "") { return; } - if (values[key] !== 0) { + if (values2[key] !== 0) { nonZeroKey = key; } }); @@ -660,6 +1877,41 @@ const Grid = /* @__PURE__ */ reactExports.forwardRef(function Grid2(inProps, ref }, otherFiltered)) }); }); +const Button = ({ + children, + className, + variant = "contained", + ...props +}) => { + return /* @__PURE__ */ jsxRuntimeExports.jsx( + Button$1, + { + ...props, + variant, + className: clsx("btn", "btn-primary", className), + children + } + ); +}; +const FuelLogo = () => { + return /* @__PURE__ */ jsxRuntimeExports.jsxs( + "svg", + { + viewBox: "0 0 344 344", + className: "PJLV PJLV-iiWunJk-css fuel_Logo w-[50px]", + children: [ + /* @__PURE__ */ jsxRuntimeExports.jsx("rect", { x: "25", y: "37", width: "292", height: "284", fill: "black" }), + /* @__PURE__ */ jsxRuntimeExports.jsx( + "path", + { + d: "M22.8744 0C10.2181 0 0 10.218 0 22.8744V344H284.626C294.246 344 303.497 340.179 310.308 333.368L333.368 310.308C340.179 303.497 344 294.246 344 284.626V0H22.8744ZM224.608 44.231L112.718 156.121C109.956 158.882 106.182 160.447 102.27 160.447C96.5631 160.447 91.3157 157.134 88.8763 151.978L45.5194 60.3402C41.9756 52.8383 47.4525 44.231 55.7374 44.231H224.608ZM44.231 299.769V190.916C44.231 185.117 48.9257 180.422 54.7249 180.422H163.577L44.231 299.769ZM172.598 160.447H136.559L244.998 52.0097C249.968 47.0382 256.734 44.231 263.776 44.231H299.814L191.377 152.668C186.407 157.64 179.64 160.447 172.598 160.447Z", + fill: "#00F58C" + } + ) + ] + } + ); +}; var PinataError = class extends Error { constructor(message, statusCode, details) { super(message); @@ -1383,7 +2635,7 @@ var updateMetadata = async (config, options) => { var isIPFSModule; async function getIsIPFS() { if (!isIPFSModule) { - isIPFSModule = await __vitePreload(() => import("./index-QfC4KmC2.js"), true ? [] : void 0); + isIPFSModule = await __vitePreload(() => import("./index-2lB61zir.js"), true ? [] : void 0); } return isIPFSModule; } @@ -3613,6 +4865,8 @@ const HomeCard = ({ ); }; export { + Button as B, + FuelLogo as F, Grid as G, HomeCard as H, useGetAirdropData as u diff --git a/pr-preview/pr-18/airdrop/assets/Text-BUUD0p9X.js b/pr-preview/pr-18/airdrop/assets/Text-BUUD0p9X.js new file mode 100644 index 0000000..e8aa4da --- /dev/null +++ b/pr-preview/pr-18/airdrop/assets/Text-BUUD0p9X.js @@ -0,0 +1,3481 @@ +import { r as reactExports, ag as React, ah as withEmotionCache, d as ThemeContext, j as jsxRuntimeExports, ai as StyledEngineProvider, aj as getAugmentedNamespace, e as clsx } from "./index-CUJp9d5D.js"; +const common = { + black: "#000", + white: "#fff" +}; +const red = { + 50: "#ffebee", + 100: "#ffcdd2", + 200: "#ef9a9a", + 300: "#e57373", + 400: "#ef5350", + 500: "#f44336", + 600: "#e53935", + 700: "#d32f2f", + 800: "#c62828", + 900: "#b71c1c", + A100: "#ff8a80", + A200: "#ff5252", + A400: "#ff1744", + A700: "#d50000" +}; +const purple = { + 50: "#f3e5f5", + 100: "#e1bee7", + 200: "#ce93d8", + 300: "#ba68c8", + 400: "#ab47bc", + 500: "#9c27b0", + 600: "#8e24aa", + 700: "#7b1fa2", + 800: "#6a1b9a", + 900: "#4a148c", + A100: "#ea80fc", + A200: "#e040fb", + A400: "#d500f9", + A700: "#aa00ff" +}; +const blue = { + 50: "#e3f2fd", + 100: "#bbdefb", + 200: "#90caf9", + 300: "#64b5f6", + 400: "#42a5f5", + 500: "#2196f3", + 600: "#1e88e5", + 700: "#1976d2", + 800: "#1565c0", + 900: "#0d47a1", + A100: "#82b1ff", + A200: "#448aff", + A400: "#2979ff", + A700: "#2962ff" +}; +const lightBlue = { + 50: "#e1f5fe", + 100: "#b3e5fc", + 200: "#81d4fa", + 300: "#4fc3f7", + 400: "#29b6f6", + 500: "#03a9f4", + 600: "#039be5", + 700: "#0288d1", + 800: "#0277bd", + 900: "#01579b", + A100: "#80d8ff", + A200: "#40c4ff", + A400: "#00b0ff", + A700: "#0091ea" +}; +const green = { + 50: "#e8f5e9", + 100: "#c8e6c9", + 200: "#a5d6a7", + 300: "#81c784", + 400: "#66bb6a", + 500: "#4caf50", + 600: "#43a047", + 700: "#388e3c", + 800: "#2e7d32", + 900: "#1b5e20", + A100: "#b9f6ca", + A200: "#69f0ae", + A400: "#00e676", + A700: "#00c853" +}; +const orange = { + 50: "#fff3e0", + 100: "#ffe0b2", + 200: "#ffcc80", + 300: "#ffb74d", + 400: "#ffa726", + 500: "#ff9800", + 600: "#fb8c00", + 700: "#f57c00", + 800: "#ef6c00", + 900: "#e65100", + A100: "#ffd180", + A200: "#ffab40", + A400: "#ff9100", + A700: "#ff6d00" +}; +const grey = { + 50: "#fafafa", + 100: "#f5f5f5", + 200: "#eeeeee", + 300: "#e0e0e0", + 400: "#bdbdbd", + 500: "#9e9e9e", + 600: "#757575", + 700: "#616161", + 800: "#424242", + 900: "#212121", + A100: "#f5f5f5", + A200: "#eeeeee", + A400: "#bdbdbd", + A700: "#616161" +}; +function formatMuiErrorMessage$1(code) { + let url = "https://mui.com/production-error/?code=" + code; + for (let i = 1; i < arguments.length; i += 1) { + url += "&args[]=" + encodeURIComponent(arguments[i]); + } + return "Minified MUI error #" + code + "; visit " + url + " for the full message."; +} +const formatMuiErrorMessage = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: formatMuiErrorMessage$1 +}, Symbol.toStringTag, { value: "Module" })); +const THEME_ID = "$$material"; +function _extends$1() { + return _extends$1 = Object.assign ? Object.assign.bind() : function(n2) { + for (var e2 = 1; e2 < arguments.length; e2++) { + var t2 = arguments[e2]; + for (var r2 in t2) ({}).hasOwnProperty.call(t2, r2) && (n2[r2] = t2[r2]); + } + return n2; + }, _extends$1.apply(null, arguments); +} +function _objectWithoutPropertiesLoose(r2, e2) { + if (null == r2) return {}; + var t2 = {}; + for (var n2 in r2) if ({}.hasOwnProperty.call(r2, n2)) { + if (e2.includes(n2)) continue; + t2[n2] = r2[n2]; + } + return t2; +} +function memoize$1(fn) { + var cache = /* @__PURE__ */ Object.create(null); + return function(arg) { + if (cache[arg] === void 0) cache[arg] = fn(arg); + return cache[arg]; + }; +} +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|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|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)-.*))$/; +var isPropValid = /* @__PURE__ */ memoize$1( + function(prop) { + return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111 && prop.charCodeAt(1) === 110 && prop.charCodeAt(2) < 91; + } + /* Z+1 */ +); +var reactIs$2 = { exports: {} }; +var reactIs_production_min$1 = {}; +/** @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$1 = "function" === typeof Symbol && Symbol.for, c$1 = b$1 ? Symbol.for("react.element") : 60103, d$1 = b$1 ? Symbol.for("react.portal") : 60106, e$1 = b$1 ? Symbol.for("react.fragment") : 60107, f$1 = b$1 ? Symbol.for("react.strict_mode") : 60108, g$1 = b$1 ? Symbol.for("react.profiler") : 60114, h$1 = b$1 ? Symbol.for("react.provider") : 60109, k$1 = b$1 ? Symbol.for("react.context") : 60110, l$1 = b$1 ? Symbol.for("react.async_mode") : 60111, m$1 = b$1 ? Symbol.for("react.concurrent_mode") : 60111, n$1 = b$1 ? Symbol.for("react.forward_ref") : 60112, p$1 = b$1 ? Symbol.for("react.suspense") : 60113, q$1 = b$1 ? Symbol.for("react.suspense_list") : 60120, r = b$1 ? Symbol.for("react.memo") : 60115, t$1 = b$1 ? Symbol.for("react.lazy") : 60116, v$1 = b$1 ? Symbol.for("react.block") : 60121, w = b$1 ? Symbol.for("react.fundamental") : 60117, x = b$1 ? Symbol.for("react.responder") : 60118, y = b$1 ? Symbol.for("react.scope") : 60119; +function z(a) { + if ("object" === typeof a && null !== a) { + var u2 = a.$$typeof; + switch (u2) { + case c$1: + switch (a = a.type, a) { + case l$1: + case m$1: + case e$1: + case g$1: + case f$1: + case p$1: + return a; + default: + switch (a = a && a.$$typeof, a) { + case k$1: + case n$1: + case t$1: + case r: + case h$1: + return a; + default: + return u2; + } + } + case d$1: + return u2; + } + } +} +function A(a) { + return z(a) === m$1; +} +reactIs_production_min$1.AsyncMode = l$1; +reactIs_production_min$1.ConcurrentMode = m$1; +reactIs_production_min$1.ContextConsumer = k$1; +reactIs_production_min$1.ContextProvider = h$1; +reactIs_production_min$1.Element = c$1; +reactIs_production_min$1.ForwardRef = n$1; +reactIs_production_min$1.Fragment = e$1; +reactIs_production_min$1.Lazy = t$1; +reactIs_production_min$1.Memo = r; +reactIs_production_min$1.Portal = d$1; +reactIs_production_min$1.Profiler = g$1; +reactIs_production_min$1.StrictMode = f$1; +reactIs_production_min$1.Suspense = p$1; +reactIs_production_min$1.isAsyncMode = function(a) { + return A(a) || z(a) === l$1; +}; +reactIs_production_min$1.isConcurrentMode = A; +reactIs_production_min$1.isContextConsumer = function(a) { + return z(a) === k$1; +}; +reactIs_production_min$1.isContextProvider = function(a) { + return z(a) === h$1; +}; +reactIs_production_min$1.isElement = function(a) { + return "object" === typeof a && null !== a && a.$$typeof === c$1; +}; +reactIs_production_min$1.isForwardRef = function(a) { + return z(a) === n$1; +}; +reactIs_production_min$1.isFragment = function(a) { + return z(a) === e$1; +}; +reactIs_production_min$1.isLazy = function(a) { + return z(a) === t$1; +}; +reactIs_production_min$1.isMemo = function(a) { + return z(a) === r; +}; +reactIs_production_min$1.isPortal = function(a) { + return z(a) === d$1; +}; +reactIs_production_min$1.isProfiler = function(a) { + return z(a) === g$1; +}; +reactIs_production_min$1.isStrictMode = function(a) { + return z(a) === f$1; +}; +reactIs_production_min$1.isSuspense = function(a) { + return z(a) === p$1; +}; +reactIs_production_min$1.isValidElementType = function(a) { + return "string" === typeof a || "function" === typeof a || a === e$1 || a === m$1 || a === g$1 || a === f$1 || a === p$1 || a === q$1 || "object" === typeof a && null !== a && (a.$$typeof === t$1 || a.$$typeof === r || a.$$typeof === h$1 || a.$$typeof === k$1 || a.$$typeof === n$1 || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v$1); +}; +reactIs_production_min$1.typeOf = z; +{ + reactIs$2.exports = reactIs_production_min$1; +} +var reactIsExports$1 = reactIs$2.exports; +var reactIs$1 = reactIsExports$1; +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$1.ForwardRef] = FORWARD_REF_STATICS; +TYPE_STATICS[reactIs$1.Memo] = MEMO_STATICS; +var isBrowser = true; +function getRegisteredStyles(registered, registeredStyles, classNames) { + var rawClassName = ""; + classNames.split(" ").forEach(function(className) { + if (registered[className] !== void 0) { + registeredStyles.push(registered[className] + ";"); + } else if (className) { + rawClassName += className + " "; + } + }); + return rawClassName; +} +var registerStyles = function registerStyles2(cache, serialized, isStringTag2) { + 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 + (isStringTag2 === 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] === void 0 + ) { + cache.registered[className] = serialized.styles; + } +}; +var insertStyles = function insertStyles2(cache, serialized, isStringTag2) { + registerStyles(cache, serialized, isStringTag2); + var className = cache.key + "-" + serialized.name; + if (cache.inserted[serialized.name] === void 0) { + var current = serialized; + do { + cache.insert(serialized === current ? "." + className : "", current, cache.sheet, true); + current = current.next; + } while (current !== void 0); + } +}; +function murmur2(str) { + var h2 = 0; + var k2, i = 0, len = str.length; + for (; len >= 4; ++i, len -= 4) { + k2 = str.charCodeAt(i) & 255 | (str.charCodeAt(++i) & 255) << 8 | (str.charCodeAt(++i) & 255) << 16 | (str.charCodeAt(++i) & 255) << 24; + k2 = /* Math.imul(k, m): */ + (k2 & 65535) * 1540483477 + ((k2 >>> 16) * 59797 << 16); + k2 ^= /* k >>> r: */ + k2 >>> 24; + h2 = /* Math.imul(k, m): */ + (k2 & 65535) * 1540483477 + ((k2 >>> 16) * 59797 << 16) ^ /* Math.imul(h, m): */ + (h2 & 65535) * 1540483477 + ((h2 >>> 16) * 59797 << 16); + } + switch (len) { + case 3: + h2 ^= (str.charCodeAt(i + 2) & 255) << 16; + case 2: + h2 ^= (str.charCodeAt(i + 1) & 255) << 8; + case 1: + h2 ^= str.charCodeAt(i) & 255; + h2 = /* Math.imul(h, m): */ + (h2 & 65535) * 1540483477 + ((h2 >>> 16) * 59797 << 16); + } + h2 ^= h2 >>> 13; + h2 = /* Math.imul(h, m): */ + (h2 & 65535) * 1540483477 + ((h2 >>> 16) * 59797 << 16); + return ((h2 ^ h2 >>> 15) >>> 0).toString(36); +} +var unitlessKeys = { + animationIterationCount: 1, + aspectRatio: 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, + scale: 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 +}; +var isDevelopment$1 = false; +var hyphenateRegex = /[A-Z]|^ms/g; +var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g; +var isCustomProperty = function isCustomProperty2(property) { + return property.charCodeAt(1) === 45; +}; +var isProcessableValue = function isProcessableValue2(value) { + return value != null && typeof value !== "boolean"; +}; +var processStyleName = /* @__PURE__ */ memoize$1(function(styleName) { + return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, "-$&").toLowerCase(); +}); +var processStyleValue = function processStyleValue2(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 (unitlessKeys[key] !== 1 && !isCustomProperty(key) && typeof value === "number" && value !== 0) { + return value + "px"; + } + return value; +}; +var noComponentSelectorMessage = "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 ""; + } + var componentSelector = interpolation; + if (componentSelector.__emotion_styles !== void 0) { + return componentSelector; + } + switch (typeof interpolation) { + case "boolean": { + return ""; + } + case "object": { + var keyframes3 = interpolation; + if (keyframes3.anim === 1) { + cursor = { + name: keyframes3.name, + styles: keyframes3.styles, + next: cursor + }; + return keyframes3.name; + } + var serializedStyles = interpolation; + if (serializedStyles.styles !== void 0) { + var next = serializedStyles.next; + if (next !== void 0) { + while (next !== void 0) { + cursor = { + name: next.name, + styles: next.styles, + next: cursor + }; + next = next.next; + } + } + var styles = serializedStyles.styles + ";"; + return styles; + } + return createStringFromObject(mergedProps, registered, interpolation); + } + case "function": { + if (mergedProps !== void 0) { + var previousCursor = cursor; + var result = interpolation(mergedProps); + cursor = previousCursor; + return handleInterpolation(mergedProps, registered, result); + } + break; + } + } + var asString = interpolation; + if (registered == null) { + return asString; + } + var cached = registered[asString]; + return cached !== void 0 ? cached : asString; +} +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") { + var asString = value; + if (registered != null && registered[asString] !== void 0) { + string += key + "{" + registered[asString] + "}"; + } else if (isProcessableValue(asString)) { + string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";"; + } + } else { + if (key === "NO_COMPONENT_SELECTOR" && isDevelopment$1) { + throw new Error(noComponentSelectorMessage); + } + if (Array.isArray(value) && typeof value[0] === "string" && (registered == null || registered[value[0]] === void 0)) { + 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: { + string += key + "{" + interpolated + "}"; + } + } + } + } + } + } + return string; +} +var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g; +var cursor; +function serializeStyles(args, registered, mergedProps) { + if (args.length === 1 && typeof args[0] === "object" && args[0] !== null && args[0].styles !== void 0) { + return args[0]; + } + var stringMode = true; + var styles = ""; + cursor = void 0; + var strings = args[0]; + if (strings == null || strings.raw === void 0) { + stringMode = false; + styles += handleInterpolation(mergedProps, registered, strings); + } else { + var asTemplateStringsArr = strings; + styles += asTemplateStringsArr[0]; + } + for (var i = 1; i < args.length; i++) { + styles += handleInterpolation(mergedProps, registered, args[i]); + if (stringMode) { + var templateStringsArr = strings; + styles += templateStringsArr[i]; + } + } + labelPattern.lastIndex = 0; + var identifierName = ""; + var match; + while ((match = labelPattern.exec(styles)) !== null) { + identifierName += "-" + match[1]; + } + var name = murmur2(styles) + identifierName; + return { + name, + styles, + next: cursor + }; +} +var syncFallback = function syncFallback2(create) { + return create(); +}; +var useInsertionEffect = React["useInsertionEffect"] ? React["useInsertionEffect"] : false; +var useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect || syncFallback; +var useInsertionEffectWithLayoutFallback = useInsertionEffect || reactExports.useLayoutEffect; +var Global = /* @__PURE__ */ withEmotionCache(function(props, cache) { + var styles = props.styles; + var serialized = serializeStyles([styles], void 0, reactExports.useContext(ThemeContext)); + var sheetRef = reactExports.useRef(); + useInsertionEffectWithLayoutFallback(function() { + var key = cache.key + "-global"; + var sheet = new cache.sheet.constructor({ + key, + nonce: cache.sheet.nonce, + container: cache.sheet.container, + speedy: cache.sheet.isSpeedy + }); + var rehydrating = false; + 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; + 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 !== void 0) { + insertStyles(cache, serialized.next, true); + } + if (sheet.tags.length) { + var element = sheet.tags[sheet.tags.length - 1].nextElementSibling; + sheet.before = element; + sheet.flush(); + } + cache.insert("", serialized, sheet, false); + }, [cache, serialized.name]); + return null; +}); +function css() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + return serializeStyles(args); +} +var keyframes = function keyframes2() { + var insertable = css.apply(void 0, arguments); + var name = "animation-" + insertable.name; + return { + name, + styles: "@keyframes " + name + "{" + insertable.styles + "}", + anim: 1, + toString: function toString() { + return "_EMO_" + this.name + "_" + this.styles + "_EMO_"; + } + }; +}; +var testOmitPropsOnStringTag = isPropValid; +var testOmitPropsOnComponent = function testOmitPropsOnComponent2(key) { + return key !== "theme"; +}; +var getDefaultShouldForwardProp = function getDefaultShouldForwardProp2(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 composeShouldForwardProps2(tag, options, isReal) { + var shouldForwardProp2; + if (options) { + var optionsShouldForwardProp = options.shouldForwardProp; + shouldForwardProp2 = tag.__emotion_forwardProp && optionsShouldForwardProp ? function(propName) { + return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName); + } : optionsShouldForwardProp; + } + if (typeof shouldForwardProp2 !== "function" && isReal) { + shouldForwardProp2 = tag.__emotion_forwardProp; + } + return shouldForwardProp2; +}; +var isDevelopment = false; +var Insertion = function Insertion2(_ref) { + var cache = _ref.cache, serialized = _ref.serialized, isStringTag2 = _ref.isStringTag; + registerStyles(cache, serialized, isStringTag2); + useInsertionEffectAlwaysWithSyncFallback(function() { + return insertStyles(cache, serialized, isStringTag2); + }); + return null; +}; +var createStyled$2 = function createStyled(tag, options) { + var isReal = tag.__emotion_real === tag; + var baseTag = isReal && tag.__emotion_base || tag; + var identifierName; + var targetClassName; + if (options !== void 0) { + identifierName = options.label; + targetClassName = options.target; + } + var shouldForwardProp2 = composeShouldForwardProps(tag, options, isReal); + var defaultShouldForwardProp = shouldForwardProp2 || getDefaultShouldForwardProp(baseTag); + var shouldUseAs = !defaultShouldForwardProp("as"); + return function() { + var args = arguments; + var styles = isReal && tag.__emotion_styles !== void 0 ? tag.__emotion_styles.slice(0) : []; + if (identifierName !== void 0) { + styles.push("label:" + identifierName + ";"); + } + if (args[0] == null || args[0].raw === void 0) { + styles.push.apply(styles, args); + } else { + styles.push(args[0][0]); + var len = args.length; + var i = 1; + for (; i < len; i++) { + styles.push(args[i], args[0][i]); + } + } + var Styled = 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 = reactExports.useContext(ThemeContext); + } + if (typeof props.className === "string") { + className = getRegisteredStyles(cache.registered, classInterpolations, props.className); + } else if (props.className != null) { + className = props.className + " "; + } + var serialized = serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps); + className += cache.key + "-" + serialized.name; + if (targetClassName !== void 0) { + className += " " + targetClassName; + } + var finalShouldForwardProp = shouldUseAs && shouldForwardProp2 === void 0 ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp; + var newProps = {}; + for (var _key in props) { + if (shouldUseAs && _key === "as") continue; + if (finalShouldForwardProp(_key)) { + newProps[_key] = props[_key]; + } + } + newProps.className = className; + if (ref) { + newProps.ref = ref; + } + return /* @__PURE__ */ reactExports.createElement(reactExports.Fragment, null, /* @__PURE__ */ reactExports.createElement(Insertion, { + cache, + serialized, + isStringTag: typeof FinalTag === "string" + }), /* @__PURE__ */ reactExports.createElement(FinalTag, newProps)); + }); + Styled.displayName = identifierName !== void 0 ? 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 = shouldForwardProp2; + Object.defineProperty(Styled, "toString", { + value: function value() { + if (targetClassName === void 0 && isDevelopment) { + return "NO_COMPONENT_SELECTOR"; + } + return "." + targetClassName; + } + }); + Styled.withComponent = function(nextTag, nextOptions) { + return createStyled(nextTag, _extends$1({}, options, nextOptions, { + shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true) + })).apply(void 0, styles); + }; + return Styled; + }; +}; +var tags = [ + "a", + "abbr", + "address", + "area", + "article", + "aside", + "audio", + "b", + "base", + "bdi", + "bdo", + "big", + "blockquote", + "body", + "br", + "button", + "canvas", + "caption", + "cite", + "code", + "col", + "colgroup", + "data", + "datalist", + "dd", + "del", + "details", + "dfn", + "dialog", + "div", + "dl", + "dt", + "em", + "embed", + "fieldset", + "figcaption", + "figure", + "footer", + "form", + "h1", + "h2", + "h3", + "h4", + "h5", + "h6", + "head", + "header", + "hgroup", + "hr", + "html", + "i", + "iframe", + "img", + "input", + "ins", + "kbd", + "keygen", + "label", + "legend", + "li", + "link", + "main", + "map", + "mark", + "marquee", + "menu", + "menuitem", + "meta", + "meter", + "nav", + "noscript", + "object", + "ol", + "optgroup", + "option", + "output", + "p", + "param", + "picture", + "pre", + "progress", + "q", + "rp", + "rt", + "ruby", + "s", + "samp", + "script", + "section", + "select", + "small", + "source", + "span", + "strong", + "style", + "sub", + "summary", + "sup", + "table", + "tbody", + "td", + "textarea", + "tfoot", + "th", + "thead", + "time", + "title", + "tr", + "track", + "u", + "ul", + "var", + "video", + "wbr", + // SVG + "circle", + "clipPath", + "defs", + "ellipse", + "foreignObject", + "g", + "image", + "line", + "linearGradient", + "mask", + "path", + "pattern", + "polygon", + "polyline", + "radialGradient", + "rect", + "stop", + "svg", + "text", + "tspan" +]; +var newStyled = createStyled$2.bind(); +tags.forEach(function(tagName) { + newStyled[tagName] = newStyled(tagName); +}); +function isEmpty$1(obj) { + return obj === void 0 || obj === null || Object.keys(obj).length === 0; +} +function GlobalStyles(props) { + const { + styles, + defaultTheme: defaultTheme2 = {} + } = props; + const globalStyles = typeof styles === "function" ? (themeInput) => styles(isEmpty$1(themeInput) ? defaultTheme2 : themeInput) : styles; + return /* @__PURE__ */ jsxRuntimeExports.jsx(Global, { + styles: globalStyles + }); +} +function styled$1(tag, options) { + const stylesFactory = newStyled(tag, options); + return stylesFactory; +} +const internal_processStyles = (tag, processor) => { + if (Array.isArray(tag.__emotion_styles)) { + tag.__emotion_styles = processor(tag.__emotion_styles); + } +}; +const styledEngine = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + GlobalStyles, + StyledEngineProvider, + ThemeContext, + css, + default: styled$1, + internal_processStyles, + keyframes +}, Symbol.toStringTag, { value: "Module" })); +function isPlainObject(item) { + if (typeof item !== "object" || item === null) { + return false; + } + const prototype = Object.getPrototypeOf(item); + return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in item) && !(Symbol.iterator in item); +} +function deepClone(source) { + if (!isPlainObject(source)) { + return source; + } + const output = {}; + Object.keys(source).forEach((key) => { + output[key] = deepClone(source[key]); + }); + return output; +} +function deepmerge$1(target, source, options = { + clone: true +}) { + const output = options.clone ? _extends$1({}, target) : target; + if (isPlainObject(target) && isPlainObject(source)) { + Object.keys(source).forEach((key) => { + if (isPlainObject(source[key]) && // Avoid prototype pollution + Object.prototype.hasOwnProperty.call(target, key) && isPlainObject(target[key])) { + output[key] = deepmerge$1(target[key], source[key], options); + } else if (options.clone) { + output[key] = isPlainObject(source[key]) ? deepClone(source[key]) : source[key]; + } else { + output[key] = source[key]; + } + }); + } + return output; +} +const deepmerge = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: deepmerge$1, + isPlainObject +}, Symbol.toStringTag, { value: "Module" })); +const _excluded$8 = ["values", "unit", "step"]; +const sortBreakpointsValues = (values2) => { + const breakpointsAsArray = Object.keys(values2).map((key) => ({ + key, + val: values2[key] + })) || []; + breakpointsAsArray.sort((breakpoint1, breakpoint2) => breakpoint1.val - breakpoint2.val); + return breakpointsAsArray.reduce((acc, obj) => { + return _extends$1({}, acc, { + [obj.key]: obj.val + }); + }, {}); +}; +function createBreakpoints(breakpoints) { + const { + // The breakpoint **start** at this value. + // For instance with the first breakpoint xs: [xs, sm). + values: values2 = { + xs: 0, + // phone + sm: 600, + // tablet + md: 900, + // small laptop + lg: 1200, + // desktop + xl: 1536 + // large screen + }, + unit = "px", + step = 5 + } = breakpoints, other = _objectWithoutPropertiesLoose(breakpoints, _excluded$8); + const sortedValues = sortBreakpointsValues(values2); + const keys = Object.keys(sortedValues); + function up(key) { + const value = typeof values2[key] === "number" ? values2[key] : key; + return `@media (min-width:${value}${unit})`; + } + function down(key) { + const value = typeof values2[key] === "number" ? values2[key] : key; + return `@media (max-width:${value - step / 100}${unit})`; + } + function between(start, end) { + const endIndex = keys.indexOf(end); + return `@media (min-width:${typeof values2[start] === "number" ? values2[start] : start}${unit}) and (max-width:${(endIndex !== -1 && typeof values2[keys[endIndex]] === "number" ? values2[keys[endIndex]] : end) - step / 100}${unit})`; + } + function only(key) { + if (keys.indexOf(key) + 1 < keys.length) { + return between(key, keys[keys.indexOf(key) + 1]); + } + return up(key); + } + function not(key) { + const keyIndex = keys.indexOf(key); + if (keyIndex === 0) { + return up(keys[1]); + } + if (keyIndex === keys.length - 1) { + return down(keys[keyIndex]); + } + return between(key, keys[keys.indexOf(key) + 1]).replace("@media", "@media not all and"); + } + return _extends$1({ + keys, + values: sortedValues, + up, + down, + between, + only, + not, + unit + }, other); +} +const shape = { + borderRadius: 4 +}; +function merge(acc, item) { + if (!item) { + return acc; + } + return deepmerge$1(acc, item, { + clone: false + // No need to clone deep, it's way faster. + }); +} +const values = { + xs: 0, + // phone + sm: 600, + // tablet + md: 900, + // small laptop + lg: 1200, + // desktop + xl: 1536 + // large screen +}; +const defaultBreakpoints = { + // Sorted ASC by size. That's important. + // It can't be configured as it's used statically for propTypes. + keys: ["xs", "sm", "md", "lg", "xl"], + up: (key) => `@media (min-width:${values[key]}px)` +}; +function handleBreakpoints(props, propValue, styleFromPropValue) { + const theme = props.theme || {}; + if (Array.isArray(propValue)) { + const themeBreakpoints = theme.breakpoints || defaultBreakpoints; + return propValue.reduce((acc, item, index) => { + acc[themeBreakpoints.up(themeBreakpoints.keys[index])] = styleFromPropValue(propValue[index]); + return acc; + }, {}); + } + if (typeof propValue === "object") { + const themeBreakpoints = theme.breakpoints || defaultBreakpoints; + return Object.keys(propValue).reduce((acc, breakpoint) => { + if (Object.keys(themeBreakpoints.values || values).indexOf(breakpoint) !== -1) { + const mediaKey = themeBreakpoints.up(breakpoint); + acc[mediaKey] = styleFromPropValue(propValue[breakpoint], breakpoint); + } else { + const cssKey = breakpoint; + acc[cssKey] = propValue[cssKey]; + } + return acc; + }, {}); + } + const output = styleFromPropValue(propValue); + return output; +} +function createEmptyBreakpointObject(breakpointsInput = {}) { + var _breakpointsInput$key; + const breakpointsInOrder = (_breakpointsInput$key = breakpointsInput.keys) == null ? void 0 : _breakpointsInput$key.reduce((acc, key) => { + const breakpointStyleKey = breakpointsInput.up(key); + acc[breakpointStyleKey] = {}; + return acc; + }, {}); + return breakpointsInOrder || {}; +} +function removeUnusedBreakpoints(breakpointKeys, style2) { + return breakpointKeys.reduce((acc, key) => { + const breakpointOutput = acc[key]; + const isBreakpointUnused = !breakpointOutput || Object.keys(breakpointOutput).length === 0; + if (isBreakpointUnused) { + delete acc[key]; + } + return acc; + }, style2); +} +function computeBreakpointsBase(breakpointValues, themeBreakpoints) { + if (typeof breakpointValues !== "object") { + return {}; + } + const base = {}; + const breakpointsKeys = Object.keys(themeBreakpoints); + if (Array.isArray(breakpointValues)) { + breakpointsKeys.forEach((breakpoint, i) => { + if (i < breakpointValues.length) { + base[breakpoint] = true; + } + }); + } else { + breakpointsKeys.forEach((breakpoint) => { + if (breakpointValues[breakpoint] != null) { + base[breakpoint] = true; + } + }); + } + return base; +} +function resolveBreakpointValues({ + values: breakpointValues, + breakpoints: themeBreakpoints, + base: customBase +}) { + const base = customBase || computeBreakpointsBase(breakpointValues, themeBreakpoints); + const keys = Object.keys(base); + if (keys.length === 0) { + return breakpointValues; + } + let previous; + return keys.reduce((acc, breakpoint, i) => { + if (Array.isArray(breakpointValues)) { + acc[breakpoint] = breakpointValues[i] != null ? breakpointValues[i] : breakpointValues[previous]; + previous = i; + } else if (typeof breakpointValues === "object") { + acc[breakpoint] = breakpointValues[breakpoint] != null ? breakpointValues[breakpoint] : breakpointValues[previous]; + previous = breakpoint; + } else { + acc[breakpoint] = breakpointValues; + } + return acc; + }, {}); +} +function capitalize$1(string) { + if (typeof string !== "string") { + throw new Error(formatMuiErrorMessage$1(7)); + } + return string.charAt(0).toUpperCase() + string.slice(1); +} +const capitalize = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: capitalize$1 +}, Symbol.toStringTag, { value: "Module" })); +function getPath(obj, path, checkVars = true) { + if (!path || typeof path !== "string") { + return null; + } + if (obj && obj.vars && checkVars) { + const val = `vars.${path}`.split(".").reduce((acc, item) => acc && acc[item] ? acc[item] : null, obj); + if (val != null) { + return val; + } + } + return path.split(".").reduce((acc, item) => { + if (acc && acc[item] != null) { + return acc[item]; + } + return null; + }, obj); +} +function getStyleValue(themeMapping, transform, propValueFinal, userValue = propValueFinal) { + let value; + if (typeof themeMapping === "function") { + value = themeMapping(propValueFinal); + } else if (Array.isArray(themeMapping)) { + value = themeMapping[propValueFinal] || userValue; + } else { + value = getPath(themeMapping, propValueFinal) || userValue; + } + if (transform) { + value = transform(value, userValue, themeMapping); + } + return value; +} +function style$1(options) { + const { + prop, + cssProperty = options.prop, + themeKey, + transform + } = options; + const fn = (props) => { + if (props[prop] == null) { + return null; + } + const propValue = props[prop]; + const theme = props.theme; + const themeMapping = getPath(theme, themeKey) || {}; + const styleFromPropValue = (propValueFinal) => { + let value = getStyleValue(themeMapping, transform, propValueFinal); + if (propValueFinal === value && typeof propValueFinal === "string") { + value = getStyleValue(themeMapping, transform, `${prop}${propValueFinal === "default" ? "" : capitalize$1(propValueFinal)}`, propValueFinal); + } + if (cssProperty === false) { + return value; + } + return { + [cssProperty]: value + }; + }; + return handleBreakpoints(props, propValue, styleFromPropValue); + }; + fn.propTypes = {}; + fn.filterProps = [prop]; + return fn; +} +function memoize(fn) { + const cache = {}; + return (arg) => { + if (cache[arg] === void 0) { + cache[arg] = fn(arg); + } + return cache[arg]; + }; +} +const properties = { + m: "margin", + p: "padding" +}; +const directions = { + t: "Top", + r: "Right", + b: "Bottom", + l: "Left", + x: ["Left", "Right"], + y: ["Top", "Bottom"] +}; +const aliases = { + marginX: "mx", + marginY: "my", + paddingX: "px", + paddingY: "py" +}; +const getCssProperties = memoize((prop) => { + if (prop.length > 2) { + if (aliases[prop]) { + prop = aliases[prop]; + } else { + return [prop]; + } + } + const [a, b2] = prop.split(""); + const property = properties[a]; + const direction = directions[b2] || ""; + return Array.isArray(direction) ? direction.map((dir) => property + dir) : [property + direction]; +}); +const marginKeys = ["m", "mt", "mr", "mb", "ml", "mx", "my", "margin", "marginTop", "marginRight", "marginBottom", "marginLeft", "marginX", "marginY", "marginInline", "marginInlineStart", "marginInlineEnd", "marginBlock", "marginBlockStart", "marginBlockEnd"]; +const paddingKeys = ["p", "pt", "pr", "pb", "pl", "px", "py", "padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft", "paddingX", "paddingY", "paddingInline", "paddingInlineStart", "paddingInlineEnd", "paddingBlock", "paddingBlockStart", "paddingBlockEnd"]; +[...marginKeys, ...paddingKeys]; +function createUnaryUnit(theme, themeKey, defaultValue, propName) { + var _getPath; + const themeSpacing = (_getPath = getPath(theme, themeKey, false)) != null ? _getPath : defaultValue; + if (typeof themeSpacing === "number") { + return (abs) => { + if (typeof abs === "string") { + return abs; + } + return themeSpacing * abs; + }; + } + if (Array.isArray(themeSpacing)) { + return (abs) => { + if (typeof abs === "string") { + return abs; + } + return themeSpacing[abs]; + }; + } + if (typeof themeSpacing === "function") { + return themeSpacing; + } + return () => void 0; +} +function createUnarySpacing(theme) { + return createUnaryUnit(theme, "spacing", 8); +} +function getValue(transformer, propValue) { + if (typeof propValue === "string" || propValue == null) { + return propValue; + } + const abs = Math.abs(propValue); + const transformed = transformer(abs); + if (propValue >= 0) { + return transformed; + } + if (typeof transformed === "number") { + return -transformed; + } + return `-${transformed}`; +} +function getStyleFromPropValue(cssProperties, transformer) { + return (propValue) => cssProperties.reduce((acc, cssProperty) => { + acc[cssProperty] = getValue(transformer, propValue); + return acc; + }, {}); +} +function resolveCssProperty(props, keys, prop, transformer) { + if (keys.indexOf(prop) === -1) { + return null; + } + const cssProperties = getCssProperties(prop); + const styleFromPropValue = getStyleFromPropValue(cssProperties, transformer); + const propValue = props[prop]; + return handleBreakpoints(props, propValue, styleFromPropValue); +} +function style(props, keys) { + const transformer = createUnarySpacing(props.theme); + return Object.keys(props).map((prop) => resolveCssProperty(props, keys, prop, transformer)).reduce(merge, {}); +} +function margin(props) { + return style(props, marginKeys); +} +margin.propTypes = {}; +margin.filterProps = marginKeys; +function padding(props) { + return style(props, paddingKeys); +} +padding.propTypes = {}; +padding.filterProps = paddingKeys; +function createSpacing(spacingInput = 8) { + if (spacingInput.mui) { + return spacingInput; + } + const transform = createUnarySpacing({ + spacing: spacingInput + }); + const spacing = (...argsInput) => { + const args = argsInput.length === 0 ? [1] : argsInput; + return args.map((argument) => { + const output = transform(argument); + return typeof output === "number" ? `${output}px` : output; + }).join(" "); + }; + spacing.mui = true; + return spacing; +} +function compose(...styles) { + const handlers = styles.reduce((acc, style2) => { + style2.filterProps.forEach((prop) => { + acc[prop] = style2; + }); + return acc; + }, {}); + const fn = (props) => { + return Object.keys(props).reduce((acc, prop) => { + if (handlers[prop]) { + return merge(acc, handlers[prop](props)); + } + return acc; + }, {}); + }; + fn.propTypes = {}; + fn.filterProps = styles.reduce((acc, style2) => acc.concat(style2.filterProps), []); + return fn; +} +function borderTransform(value) { + if (typeof value !== "number") { + return value; + } + return `${value}px solid`; +} +function createBorderStyle(prop, transform) { + return style$1({ + prop, + themeKey: "borders", + transform + }); +} +const border = createBorderStyle("border", borderTransform); +const borderTop = createBorderStyle("borderTop", borderTransform); +const borderRight = createBorderStyle("borderRight", borderTransform); +const borderBottom = createBorderStyle("borderBottom", borderTransform); +const borderLeft = createBorderStyle("borderLeft", borderTransform); +const borderColor = createBorderStyle("borderColor"); +const borderTopColor = createBorderStyle("borderTopColor"); +const borderRightColor = createBorderStyle("borderRightColor"); +const borderBottomColor = createBorderStyle("borderBottomColor"); +const borderLeftColor = createBorderStyle("borderLeftColor"); +const outline = createBorderStyle("outline", borderTransform); +const outlineColor = createBorderStyle("outlineColor"); +const borderRadius = (props) => { + if (props.borderRadius !== void 0 && props.borderRadius !== null) { + const transformer = createUnaryUnit(props.theme, "shape.borderRadius", 4); + const styleFromPropValue = (propValue) => ({ + borderRadius: getValue(transformer, propValue) + }); + return handleBreakpoints(props, props.borderRadius, styleFromPropValue); + } + return null; +}; +borderRadius.propTypes = {}; +borderRadius.filterProps = ["borderRadius"]; +compose(border, borderTop, borderRight, borderBottom, borderLeft, borderColor, borderTopColor, borderRightColor, borderBottomColor, borderLeftColor, borderRadius, outline, outlineColor); +const gap = (props) => { + if (props.gap !== void 0 && props.gap !== null) { + const transformer = createUnaryUnit(props.theme, "spacing", 8); + const styleFromPropValue = (propValue) => ({ + gap: getValue(transformer, propValue) + }); + return handleBreakpoints(props, props.gap, styleFromPropValue); + } + return null; +}; +gap.propTypes = {}; +gap.filterProps = ["gap"]; +const columnGap = (props) => { + if (props.columnGap !== void 0 && props.columnGap !== null) { + const transformer = createUnaryUnit(props.theme, "spacing", 8); + const styleFromPropValue = (propValue) => ({ + columnGap: getValue(transformer, propValue) + }); + return handleBreakpoints(props, props.columnGap, styleFromPropValue); + } + return null; +}; +columnGap.propTypes = {}; +columnGap.filterProps = ["columnGap"]; +const rowGap = (props) => { + if (props.rowGap !== void 0 && props.rowGap !== null) { + const transformer = createUnaryUnit(props.theme, "spacing", 8); + const styleFromPropValue = (propValue) => ({ + rowGap: getValue(transformer, propValue) + }); + return handleBreakpoints(props, props.rowGap, styleFromPropValue); + } + return null; +}; +rowGap.propTypes = {}; +rowGap.filterProps = ["rowGap"]; +const gridColumn = style$1({ + prop: "gridColumn" +}); +const gridRow = style$1({ + prop: "gridRow" +}); +const gridAutoFlow = style$1({ + prop: "gridAutoFlow" +}); +const gridAutoColumns = style$1({ + prop: "gridAutoColumns" +}); +const gridAutoRows = style$1({ + prop: "gridAutoRows" +}); +const gridTemplateColumns = style$1({ + prop: "gridTemplateColumns" +}); +const gridTemplateRows = style$1({ + prop: "gridTemplateRows" +}); +const gridTemplateAreas = style$1({ + prop: "gridTemplateAreas" +}); +const gridArea = style$1({ + prop: "gridArea" +}); +compose(gap, columnGap, rowGap, gridColumn, gridRow, gridAutoFlow, gridAutoColumns, gridAutoRows, gridTemplateColumns, gridTemplateRows, gridTemplateAreas, gridArea); +function paletteTransform(value, userValue) { + if (userValue === "grey") { + return userValue; + } + return value; +} +const color = style$1({ + prop: "color", + themeKey: "palette", + transform: paletteTransform +}); +const bgcolor = style$1({ + prop: "bgcolor", + cssProperty: "backgroundColor", + themeKey: "palette", + transform: paletteTransform +}); +const backgroundColor = style$1({ + prop: "backgroundColor", + themeKey: "palette", + transform: paletteTransform +}); +compose(color, bgcolor, backgroundColor); +function sizingTransform(value) { + return value <= 1 && value !== 0 ? `${value * 100}%` : value; +} +const width = style$1({ + prop: "width", + transform: sizingTransform +}); +const maxWidth = (props) => { + if (props.maxWidth !== void 0 && props.maxWidth !== null) { + const styleFromPropValue = (propValue) => { + var _props$theme, _props$theme2; + const breakpoint = ((_props$theme = props.theme) == null || (_props$theme = _props$theme.breakpoints) == null || (_props$theme = _props$theme.values) == null ? void 0 : _props$theme[propValue]) || values[propValue]; + if (!breakpoint) { + return { + maxWidth: sizingTransform(propValue) + }; + } + if (((_props$theme2 = props.theme) == null || (_props$theme2 = _props$theme2.breakpoints) == null ? void 0 : _props$theme2.unit) !== "px") { + return { + maxWidth: `${breakpoint}${props.theme.breakpoints.unit}` + }; + } + return { + maxWidth: breakpoint + }; + }; + return handleBreakpoints(props, props.maxWidth, styleFromPropValue); + } + return null; +}; +maxWidth.filterProps = ["maxWidth"]; +const minWidth = style$1({ + prop: "minWidth", + transform: sizingTransform +}); +const height = style$1({ + prop: "height", + transform: sizingTransform +}); +const maxHeight = style$1({ + prop: "maxHeight", + transform: sizingTransform +}); +const minHeight = style$1({ + prop: "minHeight", + transform: sizingTransform +}); +style$1({ + prop: "size", + cssProperty: "width", + transform: sizingTransform +}); +style$1({ + prop: "size", + cssProperty: "height", + transform: sizingTransform +}); +const boxSizing = style$1({ + prop: "boxSizing" +}); +compose(width, maxWidth, minWidth, height, maxHeight, minHeight, boxSizing); +const defaultSxConfig = { + // borders + border: { + themeKey: "borders", + transform: borderTransform + }, + borderTop: { + themeKey: "borders", + transform: borderTransform + }, + borderRight: { + themeKey: "borders", + transform: borderTransform + }, + borderBottom: { + themeKey: "borders", + transform: borderTransform + }, + borderLeft: { + themeKey: "borders", + transform: borderTransform + }, + borderColor: { + themeKey: "palette" + }, + borderTopColor: { + themeKey: "palette" + }, + borderRightColor: { + themeKey: "palette" + }, + borderBottomColor: { + themeKey: "palette" + }, + borderLeftColor: { + themeKey: "palette" + }, + outline: { + themeKey: "borders", + transform: borderTransform + }, + outlineColor: { + themeKey: "palette" + }, + borderRadius: { + themeKey: "shape.borderRadius", + style: borderRadius + }, + // palette + color: { + themeKey: "palette", + transform: paletteTransform + }, + bgcolor: { + themeKey: "palette", + cssProperty: "backgroundColor", + transform: paletteTransform + }, + backgroundColor: { + themeKey: "palette", + transform: paletteTransform + }, + // spacing + p: { + style: padding + }, + pt: { + style: padding + }, + pr: { + style: padding + }, + pb: { + style: padding + }, + pl: { + style: padding + }, + px: { + style: padding + }, + py: { + style: padding + }, + padding: { + style: padding + }, + paddingTop: { + style: padding + }, + paddingRight: { + style: padding + }, + paddingBottom: { + style: padding + }, + paddingLeft: { + style: padding + }, + paddingX: { + style: padding + }, + paddingY: { + style: padding + }, + paddingInline: { + style: padding + }, + paddingInlineStart: { + style: padding + }, + paddingInlineEnd: { + style: padding + }, + paddingBlock: { + style: padding + }, + paddingBlockStart: { + style: padding + }, + paddingBlockEnd: { + style: padding + }, + m: { + style: margin + }, + mt: { + style: margin + }, + mr: { + style: margin + }, + mb: { + style: margin + }, + ml: { + style: margin + }, + mx: { + style: margin + }, + my: { + style: margin + }, + margin: { + style: margin + }, + marginTop: { + style: margin + }, + marginRight: { + style: margin + }, + marginBottom: { + style: margin + }, + marginLeft: { + style: margin + }, + marginX: { + style: margin + }, + marginY: { + style: margin + }, + marginInline: { + style: margin + }, + marginInlineStart: { + style: margin + }, + marginInlineEnd: { + style: margin + }, + marginBlock: { + style: margin + }, + marginBlockStart: { + style: margin + }, + marginBlockEnd: { + style: margin + }, + // display + displayPrint: { + cssProperty: false, + transform: (value) => ({ + "@media print": { + display: value + } + }) + }, + display: {}, + overflow: {}, + textOverflow: {}, + visibility: {}, + whiteSpace: {}, + // flexbox + flexBasis: {}, + flexDirection: {}, + flexWrap: {}, + justifyContent: {}, + alignItems: {}, + alignContent: {}, + order: {}, + flex: {}, + flexGrow: {}, + flexShrink: {}, + alignSelf: {}, + justifyItems: {}, + justifySelf: {}, + // grid + gap: { + style: gap + }, + rowGap: { + style: rowGap + }, + columnGap: { + style: columnGap + }, + gridColumn: {}, + gridRow: {}, + gridAutoFlow: {}, + gridAutoColumns: {}, + gridAutoRows: {}, + gridTemplateColumns: {}, + gridTemplateRows: {}, + gridTemplateAreas: {}, + gridArea: {}, + // positions + position: {}, + zIndex: { + themeKey: "zIndex" + }, + top: {}, + right: {}, + bottom: {}, + left: {}, + // shadows + boxShadow: { + themeKey: "shadows" + }, + // sizing + width: { + transform: sizingTransform + }, + maxWidth: { + style: maxWidth + }, + minWidth: { + transform: sizingTransform + }, + height: { + transform: sizingTransform + }, + maxHeight: { + transform: sizingTransform + }, + minHeight: { + transform: sizingTransform + }, + boxSizing: {}, + // typography + fontFamily: { + themeKey: "typography" + }, + fontSize: { + themeKey: "typography" + }, + fontStyle: { + themeKey: "typography" + }, + fontWeight: { + themeKey: "typography" + }, + letterSpacing: {}, + textTransform: {}, + lineHeight: {}, + textAlign: {}, + typography: { + cssProperty: false, + themeKey: "typography" + } +}; +function objectsHaveSameKeys(...objects) { + const allKeys = objects.reduce((keys, object) => keys.concat(Object.keys(object)), []); + const union = new Set(allKeys); + return objects.every((object) => union.size === Object.keys(object).length); +} +function callIfFn(maybeFn, arg) { + return typeof maybeFn === "function" ? maybeFn(arg) : maybeFn; +} +function unstable_createStyleFunctionSx() { + function getThemeValue(prop, val, theme, config) { + const props = { + [prop]: val, + theme + }; + const options = config[prop]; + if (!options) { + return { + [prop]: val + }; + } + const { + cssProperty = prop, + themeKey, + transform, + style: style2 + } = options; + if (val == null) { + return null; + } + if (themeKey === "typography" && val === "inherit") { + return { + [prop]: val + }; + } + const themeMapping = getPath(theme, themeKey) || {}; + if (style2) { + return style2(props); + } + const styleFromPropValue = (propValueFinal) => { + let value = getStyleValue(themeMapping, transform, propValueFinal); + if (propValueFinal === value && typeof propValueFinal === "string") { + value = getStyleValue(themeMapping, transform, `${prop}${propValueFinal === "default" ? "" : capitalize$1(propValueFinal)}`, propValueFinal); + } + if (cssProperty === false) { + return value; + } + return { + [cssProperty]: value + }; + }; + return handleBreakpoints(props, val, styleFromPropValue); + } + function styleFunctionSx2(props) { + var _theme$unstable_sxCon; + const { + sx, + theme = {} + } = props || {}; + if (!sx) { + return null; + } + const config = (_theme$unstable_sxCon = theme.unstable_sxConfig) != null ? _theme$unstable_sxCon : defaultSxConfig; + function traverse(sxInput) { + let sxObject = sxInput; + if (typeof sxInput === "function") { + sxObject = sxInput(theme); + } else if (typeof sxInput !== "object") { + return sxInput; + } + if (!sxObject) { + return null; + } + const emptyBreakpoints = createEmptyBreakpointObject(theme.breakpoints); + const breakpointsKeys = Object.keys(emptyBreakpoints); + let css2 = emptyBreakpoints; + Object.keys(sxObject).forEach((styleKey) => { + const value = callIfFn(sxObject[styleKey], theme); + if (value !== null && value !== void 0) { + if (typeof value === "object") { + if (config[styleKey]) { + css2 = merge(css2, getThemeValue(styleKey, value, theme, config)); + } else { + const breakpointsValues = handleBreakpoints({ + theme + }, value, (x2) => ({ + [styleKey]: x2 + })); + if (objectsHaveSameKeys(breakpointsValues, value)) { + css2[styleKey] = styleFunctionSx2({ + sx: value, + theme + }); + } else { + css2 = merge(css2, breakpointsValues); + } + } + } else { + css2 = merge(css2, getThemeValue(styleKey, value, theme, config)); + } + } + }); + return removeUnusedBreakpoints(breakpointsKeys, css2); + } + return Array.isArray(sx) ? sx.map(traverse) : traverse(sx); + } + return styleFunctionSx2; +} +const styleFunctionSx$1 = unstable_createStyleFunctionSx(); +styleFunctionSx$1.filterProps = ["sx"]; +function applyStyles(key, styles) { + const theme = this; + if (theme.vars && typeof theme.getColorSchemeSelector === "function") { + const selector = theme.getColorSchemeSelector(key).replace(/(\[[^\]]+\])/, "*:where($1)"); + return { + [selector]: styles + }; + } + if (theme.palette.mode === key) { + return styles; + } + return {}; +} +const _excluded$7 = ["breakpoints", "palette", "spacing", "shape"]; +function createTheme$2(options = {}, ...args) { + const { + breakpoints: breakpointsInput = {}, + palette: paletteInput = {}, + spacing: spacingInput, + shape: shapeInput = {} + } = options, other = _objectWithoutPropertiesLoose(options, _excluded$7); + const breakpoints = createBreakpoints(breakpointsInput); + const spacing = createSpacing(spacingInput); + let muiTheme = deepmerge$1({ + breakpoints, + direction: "ltr", + components: {}, + // Inject component definitions. + palette: _extends$1({ + mode: "light" + }, paletteInput), + spacing, + shape: _extends$1({}, shape, shapeInput) + }, other); + muiTheme.applyStyles = applyStyles; + muiTheme = args.reduce((acc, argument) => deepmerge$1(acc, argument), muiTheme); + muiTheme.unstable_sxConfig = _extends$1({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig); + muiTheme.unstable_sx = function sx(props) { + return styleFunctionSx$1({ + sx: props, + theme: this + }); + }; + return muiTheme; +} +const createTheme$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: createTheme$2, + private_createBreakpoints: createBreakpoints, + unstable_applyStyles: applyStyles +}, Symbol.toStringTag, { value: "Module" })); +const _excluded$6 = ["sx"]; +const splitProps = (props) => { + var _props$theme$unstable, _props$theme; + const result = { + systemProps: {}, + otherProps: {} + }; + const config = (_props$theme$unstable = props == null || (_props$theme = props.theme) == null ? void 0 : _props$theme.unstable_sxConfig) != null ? _props$theme$unstable : defaultSxConfig; + Object.keys(props).forEach((prop) => { + if (config[prop]) { + result.systemProps[prop] = props[prop]; + } else { + result.otherProps[prop] = props[prop]; + } + }); + return result; +}; +function extendSxProp(props) { + const { + sx: inSx + } = props, other = _objectWithoutPropertiesLoose(props, _excluded$6); + const { + systemProps, + otherProps + } = splitProps(other); + let finalSx; + if (Array.isArray(inSx)) { + finalSx = [systemProps, ...inSx]; + } else if (typeof inSx === "function") { + finalSx = (...args) => { + const result = inSx(...args); + if (!isPlainObject(result)) { + return systemProps; + } + return _extends$1({}, systemProps, result); + }; + } else { + finalSx = _extends$1({}, systemProps, inSx); + } + return _extends$1({}, otherProps, { + sx: finalSx + }); +} +const styleFunctionSx = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: styleFunctionSx$1, + extendSxProp, + unstable_createStyleFunctionSx, + unstable_defaultSxConfig: defaultSxConfig +}, Symbol.toStringTag, { value: "Module" })); +const defaultGenerator = (componentName) => componentName; +const createClassNameGenerator = () => { + let generate = defaultGenerator; + return { + configure(generator) { + generate = generator; + }, + generate(componentName) { + return generate(componentName); + }, + reset() { + generate = defaultGenerator; + } + }; +}; +const ClassNameGenerator = createClassNameGenerator(); +const globalStateClasses = { + active: "active", + checked: "checked", + completed: "completed", + disabled: "disabled", + error: "error", + expanded: "expanded", + focused: "focused", + focusVisible: "focusVisible", + open: "open", + readOnly: "readOnly", + required: "required", + selected: "selected" +}; +function generateUtilityClass(componentName, slot, globalStatePrefix = "Mui") { + const globalStateClass = globalStateClasses[slot]; + return globalStateClass ? `${globalStatePrefix}-${globalStateClass}` : `${ClassNameGenerator.generate(componentName)}-${slot}`; +} +function generateUtilityClasses(componentName, slots, globalStatePrefix = "Mui") { + const result = {}; + slots.forEach((slot) => { + result[slot] = generateUtilityClass(componentName, slot, globalStatePrefix); + }); + return result; +} +var reactIs = { exports: {} }; +var reactIs_production_min = {}; +/** + * @license React + * 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 = Symbol.for("react.element"), c = Symbol.for("react.portal"), d = Symbol.for("react.fragment"), e = Symbol.for("react.strict_mode"), f = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), h = Symbol.for("react.context"), k = Symbol.for("react.server_context"), l = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), n = Symbol.for("react.suspense_list"), p = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), t = Symbol.for("react.offscreen"), u; +u = Symbol.for("react.module.reference"); +function v(a) { + if ("object" === typeof a && null !== a) { + var r2 = a.$$typeof; + switch (r2) { + case b: + switch (a = a.type, a) { + case d: + case f: + case e: + case m: + case n: + return a; + default: + switch (a = a && a.$$typeof, a) { + case k: + case h: + case l: + case q: + case p: + case g: + return a; + default: + return r2; + } + } + case c: + return r2; + } + } +} +reactIs_production_min.ContextConsumer = h; +reactIs_production_min.ContextProvider = g; +reactIs_production_min.Element = b; +reactIs_production_min.ForwardRef = l; +reactIs_production_min.Fragment = d; +reactIs_production_min.Lazy = q; +reactIs_production_min.Memo = p; +reactIs_production_min.Portal = c; +reactIs_production_min.Profiler = f; +reactIs_production_min.StrictMode = e; +reactIs_production_min.Suspense = m; +reactIs_production_min.SuspenseList = n; +reactIs_production_min.isAsyncMode = function() { + return false; +}; +reactIs_production_min.isConcurrentMode = function() { + return false; +}; +reactIs_production_min.isContextConsumer = function(a) { + return v(a) === h; +}; +reactIs_production_min.isContextProvider = function(a) { + return v(a) === g; +}; +reactIs_production_min.isElement = function(a) { + return "object" === typeof a && null !== a && a.$$typeof === b; +}; +reactIs_production_min.isForwardRef = function(a) { + return v(a) === l; +}; +reactIs_production_min.isFragment = function(a) { + return v(a) === d; +}; +reactIs_production_min.isLazy = function(a) { + return v(a) === q; +}; +reactIs_production_min.isMemo = function(a) { + return v(a) === p; +}; +reactIs_production_min.isPortal = function(a) { + return v(a) === c; +}; +reactIs_production_min.isProfiler = function(a) { + return v(a) === f; +}; +reactIs_production_min.isStrictMode = function(a) { + return v(a) === e; +}; +reactIs_production_min.isSuspense = function(a) { + return v(a) === m; +}; +reactIs_production_min.isSuspenseList = function(a) { + return v(a) === n; +}; +reactIs_production_min.isValidElementType = function(a) { + return "string" === typeof a || "function" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false; +}; +reactIs_production_min.typeOf = v; +{ + reactIs.exports = reactIs_production_min; +} +var reactIsExports = reactIs.exports; +const fnNameMatchRegex = /^\s*function(?:\s|\s*\/\*.*\*\/\s*)+([^(\s/]*)\s*/; +function getFunctionName(fn) { + const match = `${fn}`.match(fnNameMatchRegex); + const name = match && match[1]; + return name || ""; +} +function getFunctionComponentName(Component, fallback = "") { + return Component.displayName || Component.name || getFunctionName(Component) || fallback; +} +function getWrappedName(outerType, innerType, wrapperName) { + const functionName = getFunctionComponentName(innerType); + return outerType.displayName || (functionName !== "" ? `${wrapperName}(${functionName})` : wrapperName); +} +function getDisplayName$1(Component) { + if (Component == null) { + return void 0; + } + if (typeof Component === "string") { + return Component; + } + if (typeof Component === "function") { + return getFunctionComponentName(Component, "Component"); + } + if (typeof Component === "object") { + switch (Component.$$typeof) { + case reactIsExports.ForwardRef: + return getWrappedName(Component, Component.render, "ForwardRef"); + case reactIsExports.Memo: + return getWrappedName(Component, Component.type, "memo"); + default: + return void 0; + } + } + return void 0; +} +const getDisplayName = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: getDisplayName$1, + getFunctionName +}, Symbol.toStringTag, { value: "Module" })); +function resolveProps(defaultProps, props) { + const output = _extends$1({}, props); + Object.keys(defaultProps).forEach((propName) => { + if (propName.toString().match(/^(components|slots)$/)) { + output[propName] = _extends$1({}, defaultProps[propName], output[propName]); + } else if (propName.toString().match(/^(componentsProps|slotProps)$/)) { + const defaultSlotProps = defaultProps[propName] || {}; + const slotProps = props[propName]; + output[propName] = {}; + if (!slotProps || !Object.keys(slotProps)) { + output[propName] = defaultSlotProps; + } else if (!defaultSlotProps || !Object.keys(defaultSlotProps)) { + output[propName] = slotProps; + } else { + output[propName] = _extends$1({}, slotProps); + Object.keys(defaultSlotProps).forEach((slotPropName) => { + output[propName][slotPropName] = resolveProps(defaultSlotProps[slotPropName], slotProps[slotPropName]); + }); + } + } else if (output[propName] === void 0) { + output[propName] = defaultProps[propName]; + } + }); + return output; +} +function clamp$1(val, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) { + return Math.max(min, Math.min(val, max)); +} +const clamp = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + default: clamp$1 +}, Symbol.toStringTag, { value: "Module" })); +function composeClasses(slots, getUtilityClass, classes = void 0) { + const output = {}; + Object.keys(slots).forEach( + // `Object.keys(slots)` can't be wider than `T` because we infer `T` from `slots`. + // @ts-expect-error https://github.com/microsoft/TypeScript/pull/12253#issuecomment-263132208 + (slot) => { + output[slot] = slots[slot].reduce((acc, key) => { + if (key) { + const utilityClass = getUtilityClass(key); + if (utilityClass !== "") { + acc.push(utilityClass); + } + if (classes && classes[key]) { + acc.push(classes[key]); + } + } + return acc; + }, []).join(" "); + } + ); + return output; +} +const PropsContext = /* @__PURE__ */ reactExports.createContext(void 0); +function getThemeProps(params) { + const { + theme, + name, + props + } = params; + if (!theme || !theme.components || !theme.components[name]) { + return props; + } + const config = theme.components[name]; + if (config.defaultProps) { + return resolveProps(config.defaultProps, props); + } + if (!config.styleOverrides && !config.variants) { + return resolveProps(config, props); + } + return props; +} +function useDefaultProps$1({ + props, + name +}) { + const ctx = reactExports.useContext(PropsContext); + return getThemeProps({ + props, + name, + theme: { + components: ctx + } + }); +} +function createMixins(breakpoints, mixins) { + return _extends$1({ + toolbar: { + minHeight: 56, + [breakpoints.up("xs")]: { + "@media (orientation: landscape)": { + minHeight: 48 + } + }, + [breakpoints.up("sm")]: { + minHeight: 64 + } + } + }, mixins); +} +var colorManipulator = {}; +var interopRequireDefault = { exports: {} }; +(function(module) { + function _interopRequireDefault2(e2) { + return e2 && e2.__esModule ? e2 : { + "default": e2 + }; + } + module.exports = _interopRequireDefault2, module.exports.__esModule = true, module.exports["default"] = module.exports; +})(interopRequireDefault); +var interopRequireDefaultExports = interopRequireDefault.exports; +const require$$1$1 = /* @__PURE__ */ getAugmentedNamespace(formatMuiErrorMessage); +const require$$2 = /* @__PURE__ */ getAugmentedNamespace(clamp); +var _interopRequireDefault$1 = interopRequireDefaultExports; +Object.defineProperty(colorManipulator, "__esModule", { + value: true +}); +var alpha_1 = colorManipulator.alpha = alpha; +colorManipulator.blend = blend; +colorManipulator.colorChannel = void 0; +var darken_1 = colorManipulator.darken = darken; +colorManipulator.decomposeColor = decomposeColor; +colorManipulator.emphasize = emphasize; +var getContrastRatio_1 = colorManipulator.getContrastRatio = getContrastRatio; +colorManipulator.getLuminance = getLuminance; +colorManipulator.hexToRgb = hexToRgb; +colorManipulator.hslToRgb = hslToRgb; +var lighten_1 = colorManipulator.lighten = lighten; +colorManipulator.private_safeAlpha = private_safeAlpha; +colorManipulator.private_safeColorChannel = void 0; +colorManipulator.private_safeDarken = private_safeDarken; +colorManipulator.private_safeEmphasize = private_safeEmphasize; +colorManipulator.private_safeLighten = private_safeLighten; +colorManipulator.recomposeColor = recomposeColor; +colorManipulator.rgbToHex = rgbToHex; +var _formatMuiErrorMessage2 = _interopRequireDefault$1(require$$1$1); +var _clamp = _interopRequireDefault$1(require$$2); +function clampWrapper(value, min = 0, max = 1) { + return (0, _clamp.default)(value, min, max); +} +function hexToRgb(color2) { + color2 = color2.slice(1); + const re = new RegExp(`.{1,${color2.length >= 6 ? 2 : 1}}`, "g"); + let colors = color2.match(re); + if (colors && colors[0].length === 1) { + colors = colors.map((n2) => n2 + n2); + } + return colors ? `rgb${colors.length === 4 ? "a" : ""}(${colors.map((n2, index) => { + return index < 3 ? parseInt(n2, 16) : Math.round(parseInt(n2, 16) / 255 * 1e3) / 1e3; + }).join(", ")})` : ""; +} +function intToHex(int) { + const hex = int.toString(16); + return hex.length === 1 ? `0${hex}` : hex; +} +function decomposeColor(color2) { + if (color2.type) { + return color2; + } + if (color2.charAt(0) === "#") { + return decomposeColor(hexToRgb(color2)); + } + const marker = color2.indexOf("("); + const type = color2.substring(0, marker); + if (["rgb", "rgba", "hsl", "hsla", "color"].indexOf(type) === -1) { + throw new Error((0, _formatMuiErrorMessage2.default)(9, color2)); + } + let values2 = color2.substring(marker + 1, color2.length - 1); + let colorSpace; + if (type === "color") { + values2 = values2.split(" "); + colorSpace = values2.shift(); + if (values2.length === 4 && values2[3].charAt(0) === "/") { + values2[3] = values2[3].slice(1); + } + if (["srgb", "display-p3", "a98-rgb", "prophoto-rgb", "rec-2020"].indexOf(colorSpace) === -1) { + throw new Error((0, _formatMuiErrorMessage2.default)(10, colorSpace)); + } + } else { + values2 = values2.split(","); + } + values2 = values2.map((value) => parseFloat(value)); + return { + type, + values: values2, + colorSpace + }; +} +const colorChannel = (color2) => { + const decomposedColor = decomposeColor(color2); + return decomposedColor.values.slice(0, 3).map((val, idx) => decomposedColor.type.indexOf("hsl") !== -1 && idx !== 0 ? `${val}%` : val).join(" "); +}; +colorManipulator.colorChannel = colorChannel; +const private_safeColorChannel = (color2, warning) => { + try { + return colorChannel(color2); + } catch (error) { + if (warning && false) { + console.warn(warning); + } + return color2; + } +}; +colorManipulator.private_safeColorChannel = private_safeColorChannel; +function recomposeColor(color2) { + const { + type, + colorSpace + } = color2; + let { + values: values2 + } = color2; + if (type.indexOf("rgb") !== -1) { + values2 = values2.map((n2, i) => i < 3 ? parseInt(n2, 10) : n2); + } else if (type.indexOf("hsl") !== -1) { + values2[1] = `${values2[1]}%`; + values2[2] = `${values2[2]}%`; + } + if (type.indexOf("color") !== -1) { + values2 = `${colorSpace} ${values2.join(" ")}`; + } else { + values2 = `${values2.join(", ")}`; + } + return `${type}(${values2})`; +} +function rgbToHex(color2) { + if (color2.indexOf("#") === 0) { + return color2; + } + const { + values: values2 + } = decomposeColor(color2); + return `#${values2.map((n2, i) => intToHex(i === 3 ? Math.round(255 * n2) : n2)).join("")}`; +} +function hslToRgb(color2) { + color2 = decomposeColor(color2); + const { + values: values2 + } = color2; + const h2 = values2[0]; + const s = values2[1] / 100; + const l2 = values2[2] / 100; + const a = s * Math.min(l2, 1 - l2); + const f2 = (n2, k2 = (n2 + h2 / 30) % 12) => l2 - a * Math.max(Math.min(k2 - 3, 9 - k2, 1), -1); + let type = "rgb"; + const rgb = [Math.round(f2(0) * 255), Math.round(f2(8) * 255), Math.round(f2(4) * 255)]; + if (color2.type === "hsla") { + type += "a"; + rgb.push(values2[3]); + } + return recomposeColor({ + type, + values: rgb + }); +} +function getLuminance(color2) { + color2 = decomposeColor(color2); + let rgb = color2.type === "hsl" || color2.type === "hsla" ? decomposeColor(hslToRgb(color2)).values : color2.values; + rgb = rgb.map((val) => { + if (color2.type !== "color") { + val /= 255; + } + return val <= 0.03928 ? val / 12.92 : ((val + 0.055) / 1.055) ** 2.4; + }); + return Number((0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2]).toFixed(3)); +} +function getContrastRatio(foreground, background) { + const lumA = getLuminance(foreground); + const lumB = getLuminance(background); + return (Math.max(lumA, lumB) + 0.05) / (Math.min(lumA, lumB) + 0.05); +} +function alpha(color2, value) { + color2 = decomposeColor(color2); + value = clampWrapper(value); + if (color2.type === "rgb" || color2.type === "hsl") { + color2.type += "a"; + } + if (color2.type === "color") { + color2.values[3] = `/${value}`; + } else { + color2.values[3] = value; + } + return recomposeColor(color2); +} +function private_safeAlpha(color2, value, warning) { + try { + return alpha(color2, value); + } catch (error) { + if (warning && false) { + console.warn(warning); + } + return color2; + } +} +function darken(color2, coefficient) { + color2 = decomposeColor(color2); + coefficient = clampWrapper(coefficient); + if (color2.type.indexOf("hsl") !== -1) { + color2.values[2] *= 1 - coefficient; + } else if (color2.type.indexOf("rgb") !== -1 || color2.type.indexOf("color") !== -1) { + for (let i = 0; i < 3; i += 1) { + color2.values[i] *= 1 - coefficient; + } + } + return recomposeColor(color2); +} +function private_safeDarken(color2, coefficient, warning) { + try { + return darken(color2, coefficient); + } catch (error) { + if (warning && false) { + console.warn(warning); + } + return color2; + } +} +function lighten(color2, coefficient) { + color2 = decomposeColor(color2); + coefficient = clampWrapper(coefficient); + if (color2.type.indexOf("hsl") !== -1) { + color2.values[2] += (100 - color2.values[2]) * coefficient; + } else if (color2.type.indexOf("rgb") !== -1) { + for (let i = 0; i < 3; i += 1) { + color2.values[i] += (255 - color2.values[i]) * coefficient; + } + } else if (color2.type.indexOf("color") !== -1) { + for (let i = 0; i < 3; i += 1) { + color2.values[i] += (1 - color2.values[i]) * coefficient; + } + } + return recomposeColor(color2); +} +function private_safeLighten(color2, coefficient, warning) { + try { + return lighten(color2, coefficient); + } catch (error) { + if (warning && false) { + console.warn(warning); + } + return color2; + } +} +function emphasize(color2, coefficient = 0.15) { + return getLuminance(color2) > 0.5 ? darken(color2, coefficient) : lighten(color2, coefficient); +} +function private_safeEmphasize(color2, coefficient, warning) { + try { + return emphasize(color2, coefficient); + } catch (error) { + if (warning && false) { + console.warn(warning); + } + return color2; + } +} +function blend(background, overlay, opacity, gamma = 1) { + const blendChannel = (b2, o) => Math.round((b2 ** (1 / gamma) * (1 - opacity) + o ** (1 / gamma) * opacity) ** gamma); + const backgroundColor2 = decomposeColor(background); + const overlayColor = decomposeColor(overlay); + const rgb = [blendChannel(backgroundColor2.values[0], overlayColor.values[0]), blendChannel(backgroundColor2.values[1], overlayColor.values[1]), blendChannel(backgroundColor2.values[2], overlayColor.values[2])]; + return recomposeColor({ + type: "rgb", + values: rgb + }); +} +const _excluded$5 = ["mode", "contrastThreshold", "tonalOffset"]; +const light = { + // The colors used to style the text. + text: { + // The most important text. + primary: "rgba(0, 0, 0, 0.87)", + // Secondary text. + secondary: "rgba(0, 0, 0, 0.6)", + // Disabled text have even lower visual prominence. + disabled: "rgba(0, 0, 0, 0.38)" + }, + // The color used to divide different elements. + divider: "rgba(0, 0, 0, 0.12)", + // The background colors used to style the surfaces. + // Consistency between these values is important. + background: { + paper: common.white, + default: common.white + }, + // The colors used to style the action elements. + action: { + // The color of an active action like an icon button. + active: "rgba(0, 0, 0, 0.54)", + // The color of an hovered action. + hover: "rgba(0, 0, 0, 0.04)", + hoverOpacity: 0.04, + // The color of a selected action. + selected: "rgba(0, 0, 0, 0.08)", + selectedOpacity: 0.08, + // The color of a disabled action. + disabled: "rgba(0, 0, 0, 0.26)", + // The background color of a disabled action. + disabledBackground: "rgba(0, 0, 0, 0.12)", + disabledOpacity: 0.38, + focus: "rgba(0, 0, 0, 0.12)", + focusOpacity: 0.12, + activatedOpacity: 0.12 + } +}; +const dark = { + text: { + primary: common.white, + secondary: "rgba(255, 255, 255, 0.7)", + disabled: "rgba(255, 255, 255, 0.5)", + icon: "rgba(255, 255, 255, 0.5)" + }, + divider: "rgba(255, 255, 255, 0.12)", + background: { + paper: "#121212", + default: "#121212" + }, + action: { + active: common.white, + hover: "rgba(255, 255, 255, 0.08)", + hoverOpacity: 0.08, + selected: "rgba(255, 255, 255, 0.16)", + selectedOpacity: 0.16, + disabled: "rgba(255, 255, 255, 0.3)", + disabledBackground: "rgba(255, 255, 255, 0.12)", + disabledOpacity: 0.38, + focus: "rgba(255, 255, 255, 0.12)", + focusOpacity: 0.12, + activatedOpacity: 0.24 + } +}; +function addLightOrDark(intent, direction, shade, tonalOffset) { + const tonalOffsetLight = tonalOffset.light || tonalOffset; + const tonalOffsetDark = tonalOffset.dark || tonalOffset * 1.5; + if (!intent[direction]) { + if (intent.hasOwnProperty(shade)) { + intent[direction] = intent[shade]; + } else if (direction === "light") { + intent.light = lighten_1(intent.main, tonalOffsetLight); + } else if (direction === "dark") { + intent.dark = darken_1(intent.main, tonalOffsetDark); + } + } +} +function getDefaultPrimary(mode = "light") { + if (mode === "dark") { + return { + main: blue[200], + light: blue[50], + dark: blue[400] + }; + } + return { + main: blue[700], + light: blue[400], + dark: blue[800] + }; +} +function getDefaultSecondary(mode = "light") { + if (mode === "dark") { + return { + main: purple[200], + light: purple[50], + dark: purple[400] + }; + } + return { + main: purple[500], + light: purple[300], + dark: purple[700] + }; +} +function getDefaultError(mode = "light") { + if (mode === "dark") { + return { + main: red[500], + light: red[300], + dark: red[700] + }; + } + return { + main: red[700], + light: red[400], + dark: red[800] + }; +} +function getDefaultInfo(mode = "light") { + if (mode === "dark") { + return { + main: lightBlue[400], + light: lightBlue[300], + dark: lightBlue[700] + }; + } + return { + main: lightBlue[700], + light: lightBlue[500], + dark: lightBlue[900] + }; +} +function getDefaultSuccess(mode = "light") { + if (mode === "dark") { + return { + main: green[400], + light: green[300], + dark: green[700] + }; + } + return { + main: green[800], + light: green[500], + dark: green[900] + }; +} +function getDefaultWarning(mode = "light") { + if (mode === "dark") { + return { + main: orange[400], + light: orange[300], + dark: orange[700] + }; + } + return { + main: "#ed6c02", + // closest to orange[800] that pass 3:1. + light: orange[500], + dark: orange[900] + }; +} +function createPalette(palette) { + const { + mode = "light", + contrastThreshold = 3, + tonalOffset = 0.2 + } = palette, other = _objectWithoutPropertiesLoose(palette, _excluded$5); + const primary = palette.primary || getDefaultPrimary(mode); + const secondary = palette.secondary || getDefaultSecondary(mode); + const error = palette.error || getDefaultError(mode); + const info = palette.info || getDefaultInfo(mode); + const success = palette.success || getDefaultSuccess(mode); + const warning = palette.warning || getDefaultWarning(mode); + function getContrastText(background) { + const contrastText = getContrastRatio_1(background, dark.text.primary) >= contrastThreshold ? dark.text.primary : light.text.primary; + return contrastText; + } + const augmentColor = ({ + color: color2, + name, + mainShade = 500, + lightShade = 300, + darkShade = 700 + }) => { + color2 = _extends$1({}, color2); + if (!color2.main && color2[mainShade]) { + color2.main = color2[mainShade]; + } + if (!color2.hasOwnProperty("main")) { + throw new Error(formatMuiErrorMessage$1(11, name ? ` (${name})` : "", mainShade)); + } + if (typeof color2.main !== "string") { + throw new Error(formatMuiErrorMessage$1(12, name ? ` (${name})` : "", JSON.stringify(color2.main))); + } + addLightOrDark(color2, "light", lightShade, tonalOffset); + addLightOrDark(color2, "dark", darkShade, tonalOffset); + if (!color2.contrastText) { + color2.contrastText = getContrastText(color2.main); + } + return color2; + }; + const modes = { + dark, + light + }; + const paletteOutput = deepmerge$1(_extends$1({ + // A collection of common colors. + common: _extends$1({}, common), + // prevent mutable object. + // The palette mode, can be light or dark. + mode, + // The colors used to represent primary interface elements for a user. + primary: augmentColor({ + color: primary, + name: "primary" + }), + // The colors used to represent secondary interface elements for a user. + secondary: augmentColor({ + color: secondary, + name: "secondary", + mainShade: "A400", + lightShade: "A200", + darkShade: "A700" + }), + // The colors used to represent interface elements that the user should be made aware of. + error: augmentColor({ + color: error, + name: "error" + }), + // The colors used to represent potentially dangerous actions or important messages. + warning: augmentColor({ + color: warning, + name: "warning" + }), + // The colors used to present information to the user that is neutral and not necessarily important. + info: augmentColor({ + color: info, + name: "info" + }), + // The colors used to indicate the successful completion of an action that user triggered. + success: augmentColor({ + color: success, + name: "success" + }), + // The grey colors. + grey, + // Used by `getContrastText()` to maximize the contrast between + // the background and the text. + contrastThreshold, + // Takes a background color and returns the text color that maximizes the contrast. + getContrastText, + // Generate a rich color object. + augmentColor, + // Used by the functions below to shift a color's luminance by approximately + // two indexes within its tonal palette. + // E.g., shift from Red 500 to Red 300 or Red 700. + tonalOffset + }, modes[mode]), other); + return paletteOutput; +} +const _excluded$4 = ["fontFamily", "fontSize", "fontWeightLight", "fontWeightRegular", "fontWeightMedium", "fontWeightBold", "htmlFontSize", "allVariants", "pxToRem"]; +function round(value) { + return Math.round(value * 1e5) / 1e5; +} +const caseAllCaps = { + textTransform: "uppercase" +}; +const defaultFontFamily = '"Roboto", "Helvetica", "Arial", sans-serif'; +function createTypography(palette, typography) { + const _ref = typeof typography === "function" ? typography(palette) : typography, { + fontFamily = defaultFontFamily, + // The default font size of the Material Specification. + fontSize = 14, + // px + fontWeightLight = 300, + fontWeightRegular = 400, + fontWeightMedium = 500, + fontWeightBold = 700, + // Tell MUI what's the font-size on the html element. + // 16px is the default font-size used by browsers. + htmlFontSize = 16, + // Apply the CSS properties to all the variants. + allVariants, + pxToRem: pxToRem2 + } = _ref, other = _objectWithoutPropertiesLoose(_ref, _excluded$4); + const coef = fontSize / 14; + const pxToRem = pxToRem2 || ((size) => `${size / htmlFontSize * coef}rem`); + const buildVariant = (fontWeight, size, lineHeight, letterSpacing, casing) => _extends$1({ + fontFamily, + fontWeight, + fontSize: pxToRem(size), + // Unitless following https://meyerweb.com/eric/thoughts/2006/02/08/unitless-line-heights/ + lineHeight + }, fontFamily === defaultFontFamily ? { + letterSpacing: `${round(letterSpacing / size)}em` + } : {}, casing, allVariants); + const variants = { + h1: buildVariant(fontWeightLight, 96, 1.167, -1.5), + h2: buildVariant(fontWeightLight, 60, 1.2, -0.5), + h3: buildVariant(fontWeightRegular, 48, 1.167, 0), + h4: buildVariant(fontWeightRegular, 34, 1.235, 0.25), + h5: buildVariant(fontWeightRegular, 24, 1.334, 0), + h6: buildVariant(fontWeightMedium, 20, 1.6, 0.15), + subtitle1: buildVariant(fontWeightRegular, 16, 1.75, 0.15), + subtitle2: buildVariant(fontWeightMedium, 14, 1.57, 0.1), + body1: buildVariant(fontWeightRegular, 16, 1.5, 0.15), + body2: buildVariant(fontWeightRegular, 14, 1.43, 0.15), + button: buildVariant(fontWeightMedium, 14, 1.75, 0.4, caseAllCaps), + caption: buildVariant(fontWeightRegular, 12, 1.66, 0.4), + overline: buildVariant(fontWeightRegular, 12, 2.66, 1, caseAllCaps), + // TODO v6: Remove handling of 'inherit' variant from the theme as it is already handled in Material UI's Typography component. Also, remember to remove the associated types. + inherit: { + fontFamily: "inherit", + fontWeight: "inherit", + fontSize: "inherit", + lineHeight: "inherit", + letterSpacing: "inherit" + } + }; + return deepmerge$1(_extends$1({ + htmlFontSize, + pxToRem, + fontFamily, + fontSize, + fontWeightLight, + fontWeightRegular, + fontWeightMedium, + fontWeightBold + }, variants), other, { + clone: false + // No need to clone deep + }); +} +const shadowKeyUmbraOpacity = 0.2; +const shadowKeyPenumbraOpacity = 0.14; +const shadowAmbientShadowOpacity = 0.12; +function createShadow(...px) { + return [`${px[0]}px ${px[1]}px ${px[2]}px ${px[3]}px rgba(0,0,0,${shadowKeyUmbraOpacity})`, `${px[4]}px ${px[5]}px ${px[6]}px ${px[7]}px rgba(0,0,0,${shadowKeyPenumbraOpacity})`, `${px[8]}px ${px[9]}px ${px[10]}px ${px[11]}px rgba(0,0,0,${shadowAmbientShadowOpacity})`].join(","); +} +const shadows = ["none", createShadow(0, 2, 1, -1, 0, 1, 1, 0, 0, 1, 3, 0), createShadow(0, 3, 1, -2, 0, 2, 2, 0, 0, 1, 5, 0), createShadow(0, 3, 3, -2, 0, 3, 4, 0, 0, 1, 8, 0), createShadow(0, 2, 4, -1, 0, 4, 5, 0, 0, 1, 10, 0), createShadow(0, 3, 5, -1, 0, 5, 8, 0, 0, 1, 14, 0), createShadow(0, 3, 5, -1, 0, 6, 10, 0, 0, 1, 18, 0), createShadow(0, 4, 5, -2, 0, 7, 10, 1, 0, 2, 16, 1), createShadow(0, 5, 5, -3, 0, 8, 10, 1, 0, 3, 14, 2), createShadow(0, 5, 6, -3, 0, 9, 12, 1, 0, 3, 16, 2), createShadow(0, 6, 6, -3, 0, 10, 14, 1, 0, 4, 18, 3), createShadow(0, 6, 7, -4, 0, 11, 15, 1, 0, 4, 20, 3), createShadow(0, 7, 8, -4, 0, 12, 17, 2, 0, 5, 22, 4), createShadow(0, 7, 8, -4, 0, 13, 19, 2, 0, 5, 24, 4), createShadow(0, 7, 9, -4, 0, 14, 21, 2, 0, 5, 26, 4), createShadow(0, 8, 9, -5, 0, 15, 22, 2, 0, 6, 28, 5), createShadow(0, 8, 10, -5, 0, 16, 24, 2, 0, 6, 30, 5), createShadow(0, 8, 11, -5, 0, 17, 26, 2, 0, 6, 32, 5), createShadow(0, 9, 11, -5, 0, 18, 28, 2, 0, 7, 34, 6), createShadow(0, 9, 12, -6, 0, 19, 29, 2, 0, 7, 36, 6), createShadow(0, 10, 13, -6, 0, 20, 31, 3, 0, 8, 38, 7), createShadow(0, 10, 13, -6, 0, 21, 33, 3, 0, 8, 40, 7), createShadow(0, 10, 14, -6, 0, 22, 35, 3, 0, 8, 42, 7), createShadow(0, 11, 14, -7, 0, 23, 36, 3, 0, 9, 44, 8), createShadow(0, 11, 15, -7, 0, 24, 38, 3, 0, 9, 46, 8)]; +const _excluded$3 = ["duration", "easing", "delay"]; +const easing = { + // This is the most common easing curve. + easeInOut: "cubic-bezier(0.4, 0, 0.2, 1)", + // Objects enter the screen at full velocity from off-screen and + // slowly decelerate to a resting point. + easeOut: "cubic-bezier(0.0, 0, 0.2, 1)", + // Objects leave the screen at full velocity. They do not decelerate when off-screen. + easeIn: "cubic-bezier(0.4, 0, 1, 1)", + // The sharp curve is used by objects that may return to the screen at any time. + sharp: "cubic-bezier(0.4, 0, 0.6, 1)" +}; +const duration = { + shortest: 150, + shorter: 200, + short: 250, + // most basic recommended timing + standard: 300, + // this is to be used in complex animations + complex: 375, + // recommended when something is entering screen + enteringScreen: 225, + // recommended when something is leaving screen + leavingScreen: 195 +}; +function formatMs(milliseconds) { + return `${Math.round(milliseconds)}ms`; +} +function getAutoHeightDuration(height2) { + if (!height2) { + return 0; + } + const constant = height2 / 36; + return Math.round((4 + 15 * constant ** 0.25 + constant / 5) * 10); +} +function createTransitions(inputTransitions) { + const mergedEasing = _extends$1({}, easing, inputTransitions.easing); + const mergedDuration = _extends$1({}, duration, inputTransitions.duration); + const create = (props = ["all"], options = {}) => { + const { + duration: durationOption = mergedDuration.standard, + easing: easingOption = mergedEasing.easeInOut, + delay = 0 + } = options; + _objectWithoutPropertiesLoose(options, _excluded$3); + return (Array.isArray(props) ? props : [props]).map((animatedProp) => `${animatedProp} ${typeof durationOption === "string" ? durationOption : formatMs(durationOption)} ${easingOption} ${typeof delay === "string" ? delay : formatMs(delay)}`).join(","); + }; + return _extends$1({ + getAutoHeightDuration, + create + }, inputTransitions, { + easing: mergedEasing, + duration: mergedDuration + }); +} +const zIndex = { + mobileStepper: 1e3, + fab: 1050, + speedDial: 1050, + appBar: 1100, + drawer: 1200, + modal: 1300, + snackbar: 1400, + tooltip: 1500 +}; +const _excluded$2 = ["breakpoints", "mixins", "spacing", "palette", "transitions", "typography", "shape"]; +function createTheme(options = {}, ...args) { + const { + mixins: mixinsInput = {}, + palette: paletteInput = {}, + transitions: transitionsInput = {}, + typography: typographyInput = {} + } = options, other = _objectWithoutPropertiesLoose(options, _excluded$2); + if (options.vars) { + throw new Error(formatMuiErrorMessage$1(18)); + } + const palette = createPalette(paletteInput); + const systemTheme = createTheme$2(options); + let muiTheme = deepmerge$1(systemTheme, { + mixins: createMixins(systemTheme.breakpoints, mixinsInput), + palette, + // Don't use [...shadows] until you've verified its transpiled code is not invoking the iterator protocol. + shadows: shadows.slice(), + typography: createTypography(palette, typographyInput), + transitions: createTransitions(transitionsInput), + zIndex: _extends$1({}, zIndex) + }); + muiTheme = deepmerge$1(muiTheme, other); + muiTheme = args.reduce((acc, argument) => deepmerge$1(acc, argument), muiTheme); + muiTheme.unstable_sxConfig = _extends$1({}, defaultSxConfig, other == null ? void 0 : other.unstable_sxConfig); + muiTheme.unstable_sx = function sx(props) { + return styleFunctionSx$1({ + sx: props, + theme: this + }); + }; + return muiTheme; +} +const defaultTheme = createTheme(); +var createStyled$1 = {}; +var _extends = { exports: {} }; +var hasRequired_extends; +function require_extends() { + if (hasRequired_extends) return _extends.exports; + hasRequired_extends = 1; + (function(module) { + function _extends3() { + return module.exports = _extends3 = Object.assign ? Object.assign.bind() : function(n2) { + for (var e2 = 1; e2 < arguments.length; e2++) { + var t2 = arguments[e2]; + for (var r2 in t2) ({}).hasOwnProperty.call(t2, r2) && (n2[r2] = t2[r2]); + } + return n2; + }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends3.apply(null, arguments); + } + module.exports = _extends3, module.exports.__esModule = true, module.exports["default"] = module.exports; + })(_extends); + return _extends.exports; +} +var objectWithoutPropertiesLoose = { exports: {} }; +var hasRequiredObjectWithoutPropertiesLoose; +function requireObjectWithoutPropertiesLoose() { + if (hasRequiredObjectWithoutPropertiesLoose) return objectWithoutPropertiesLoose.exports; + hasRequiredObjectWithoutPropertiesLoose = 1; + (function(module) { + function _objectWithoutPropertiesLoose3(r2, e2) { + if (null == r2) return {}; + var t2 = {}; + for (var n2 in r2) if ({}.hasOwnProperty.call(r2, n2)) { + if (e2.includes(n2)) continue; + t2[n2] = r2[n2]; + } + return t2; + } + module.exports = _objectWithoutPropertiesLoose3, module.exports.__esModule = true, module.exports["default"] = module.exports; + })(objectWithoutPropertiesLoose); + return objectWithoutPropertiesLoose.exports; +} +const require$$1 = /* @__PURE__ */ getAugmentedNamespace(styledEngine); +const require$$4 = /* @__PURE__ */ getAugmentedNamespace(deepmerge); +const require$$5 = /* @__PURE__ */ getAugmentedNamespace(capitalize); +const require$$6 = /* @__PURE__ */ getAugmentedNamespace(getDisplayName); +const require$$7 = /* @__PURE__ */ getAugmentedNamespace(createTheme$1); +const require$$8 = /* @__PURE__ */ getAugmentedNamespace(styleFunctionSx); +var _interopRequireDefault = interopRequireDefaultExports; +Object.defineProperty(createStyled$1, "__esModule", { + value: true +}); +var _default = createStyled$1.default = createStyled2; +createStyled$1.shouldForwardProp = shouldForwardProp; +createStyled$1.systemDefaultTheme = void 0; +var _extends2 = _interopRequireDefault(require_extends()); +var _objectWithoutPropertiesLoose2 = _interopRequireDefault(requireObjectWithoutPropertiesLoose()); +var _styledEngine = _interopRequireWildcard(require$$1); +var _deepmerge = require$$4; +_interopRequireDefault(require$$5); +_interopRequireDefault(require$$6); +var _createTheme = _interopRequireDefault(require$$7); +var _styleFunctionSx = _interopRequireDefault(require$$8); +const _excluded$1 = ["ownerState"], _excluded2 = ["variants"], _excluded3 = ["name", "slot", "skipVariantsResolver", "skipSx", "overridesResolver"]; +function _getRequireWildcardCache(e2) { + if ("function" != typeof WeakMap) return null; + var r2 = /* @__PURE__ */ new WeakMap(), t2 = /* @__PURE__ */ new WeakMap(); + return (_getRequireWildcardCache = function(e22) { + return e22 ? t2 : r2; + })(e2); +} +function _interopRequireWildcard(e2, r2) { + if (e2 && e2.__esModule) return e2; + if (null === e2 || "object" != typeof e2 && "function" != typeof e2) return { default: e2 }; + var t2 = _getRequireWildcardCache(r2); + if (t2 && t2.has(e2)) return t2.get(e2); + var n2 = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var u2 in e2) if ("default" !== u2 && Object.prototype.hasOwnProperty.call(e2, u2)) { + var i = a ? Object.getOwnPropertyDescriptor(e2, u2) : null; + i && (i.get || i.set) ? Object.defineProperty(n2, u2, i) : n2[u2] = e2[u2]; + } + return n2.default = e2, t2 && t2.set(e2, n2), n2; +} +function isEmpty(obj) { + return Object.keys(obj).length === 0; +} +function isStringTag(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; +} +function shouldForwardProp(prop) { + return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as"; +} +const systemDefaultTheme = createStyled$1.systemDefaultTheme = (0, _createTheme.default)(); +const lowercaseFirstLetter = (string) => { + if (!string) { + return string; + } + return string.charAt(0).toLowerCase() + string.slice(1); +}; +function resolveTheme({ + defaultTheme: defaultTheme2, + theme, + themeId +}) { + return isEmpty(theme) ? defaultTheme2 : theme[themeId] || theme; +} +function defaultOverridesResolver(slot) { + if (!slot) { + return null; + } + return (props, styles) => styles[slot]; +} +function processStyleArg(callableStyle, _ref) { + let { + ownerState + } = _ref, props = (0, _objectWithoutPropertiesLoose2.default)(_ref, _excluded$1); + const resolvedStylesArg = typeof callableStyle === "function" ? callableStyle((0, _extends2.default)({ + ownerState + }, props)) : callableStyle; + if (Array.isArray(resolvedStylesArg)) { + return resolvedStylesArg.flatMap((resolvedStyle) => processStyleArg(resolvedStyle, (0, _extends2.default)({ + ownerState + }, props))); + } + if (!!resolvedStylesArg && typeof resolvedStylesArg === "object" && Array.isArray(resolvedStylesArg.variants)) { + const { + variants = [] + } = resolvedStylesArg, otherStyles = (0, _objectWithoutPropertiesLoose2.default)(resolvedStylesArg, _excluded2); + let result = otherStyles; + variants.forEach((variant) => { + let isMatch = true; + if (typeof variant.props === "function") { + isMatch = variant.props((0, _extends2.default)({ + ownerState + }, props, ownerState)); + } else { + Object.keys(variant.props).forEach((key) => { + if ((ownerState == null ? void 0 : ownerState[key]) !== variant.props[key] && props[key] !== variant.props[key]) { + isMatch = false; + } + }); + } + if (isMatch) { + if (!Array.isArray(result)) { + result = [result]; + } + result.push(typeof variant.style === "function" ? variant.style((0, _extends2.default)({ + ownerState + }, props, ownerState)) : variant.style); + } + }); + return result; + } + return resolvedStylesArg; +} +function createStyled2(input = {}) { + const { + themeId, + defaultTheme: defaultTheme2 = systemDefaultTheme, + rootShouldForwardProp: rootShouldForwardProp2 = shouldForwardProp, + slotShouldForwardProp: slotShouldForwardProp2 = shouldForwardProp + } = input; + const systemSx = (props) => { + return (0, _styleFunctionSx.default)((0, _extends2.default)({}, props, { + theme: resolveTheme((0, _extends2.default)({}, props, { + defaultTheme: defaultTheme2, + themeId + })) + })); + }; + systemSx.__mui_systemSx = true; + return (tag, inputOptions = {}) => { + (0, _styledEngine.internal_processStyles)(tag, (styles) => styles.filter((style2) => !(style2 != null && style2.__mui_systemSx))); + const { + name: componentName, + slot: componentSlot, + skipVariantsResolver: inputSkipVariantsResolver, + skipSx: inputSkipSx, + // TODO v6: remove `lowercaseFirstLetter()` in the next major release + // For more details: https://github.com/mui/material-ui/pull/37908 + overridesResolver = defaultOverridesResolver(lowercaseFirstLetter(componentSlot)) + } = inputOptions, options = (0, _objectWithoutPropertiesLoose2.default)(inputOptions, _excluded3); + const skipVariantsResolver = inputSkipVariantsResolver !== void 0 ? inputSkipVariantsResolver : ( + // TODO v6: remove `Root` in the next major release + // For more details: https://github.com/mui/material-ui/pull/37908 + componentSlot && componentSlot !== "Root" && componentSlot !== "root" || false + ); + const skipSx = inputSkipSx || false; + let label; + let shouldForwardPropOption = shouldForwardProp; + if (componentSlot === "Root" || componentSlot === "root") { + shouldForwardPropOption = rootShouldForwardProp2; + } else if (componentSlot) { + shouldForwardPropOption = slotShouldForwardProp2; + } else if (isStringTag(tag)) { + shouldForwardPropOption = void 0; + } + const defaultStyledResolver = (0, _styledEngine.default)(tag, (0, _extends2.default)({ + shouldForwardProp: shouldForwardPropOption, + label + }, options)); + const transformStyleArg = (stylesArg) => { + if (typeof stylesArg === "function" && stylesArg.__emotion_real !== stylesArg || (0, _deepmerge.isPlainObject)(stylesArg)) { + return (props) => processStyleArg(stylesArg, (0, _extends2.default)({}, props, { + theme: resolveTheme({ + theme: props.theme, + defaultTheme: defaultTheme2, + themeId + }) + })); + } + return stylesArg; + }; + const muiStyledResolver = (styleArg, ...expressions) => { + let transformedStyleArg = transformStyleArg(styleArg); + const expressionsWithDefaultTheme = expressions ? expressions.map(transformStyleArg) : []; + if (componentName && overridesResolver) { + expressionsWithDefaultTheme.push((props) => { + const theme = resolveTheme((0, _extends2.default)({}, props, { + defaultTheme: defaultTheme2, + themeId + })); + if (!theme.components || !theme.components[componentName] || !theme.components[componentName].styleOverrides) { + return null; + } + const styleOverrides = theme.components[componentName].styleOverrides; + const resolvedStyleOverrides = {}; + Object.entries(styleOverrides).forEach(([slotKey, slotStyle]) => { + resolvedStyleOverrides[slotKey] = processStyleArg(slotStyle, (0, _extends2.default)({}, props, { + theme + })); + }); + return overridesResolver(props, resolvedStyleOverrides); + }); + } + if (componentName && !skipVariantsResolver) { + expressionsWithDefaultTheme.push((props) => { + var _theme$components; + const theme = resolveTheme((0, _extends2.default)({}, props, { + defaultTheme: defaultTheme2, + themeId + })); + const themeVariants = theme == null || (_theme$components = theme.components) == null || (_theme$components = _theme$components[componentName]) == null ? void 0 : _theme$components.variants; + return processStyleArg({ + variants: themeVariants + }, (0, _extends2.default)({}, props, { + theme + })); + }); + } + if (!skipSx) { + expressionsWithDefaultTheme.push(systemSx); + } + const numOfCustomFnsApplied = expressionsWithDefaultTheme.length - expressions.length; + if (Array.isArray(styleArg) && numOfCustomFnsApplied > 0) { + const placeholders = new Array(numOfCustomFnsApplied).fill(""); + transformedStyleArg = [...styleArg, ...placeholders]; + transformedStyleArg.raw = [...styleArg.raw, ...placeholders]; + } + const Component = defaultStyledResolver(transformedStyleArg, ...expressionsWithDefaultTheme); + if (tag.muiName) { + Component.muiName = tag.muiName; + } + return Component; + }; + if (defaultStyledResolver.withConfig) { + muiStyledResolver.withConfig = defaultStyledResolver.withConfig; + } + return muiStyledResolver; + }; +} +function slotShouldForwardProp(prop) { + return prop !== "ownerState" && prop !== "theme" && prop !== "sx" && prop !== "as"; +} +const rootShouldForwardProp = (prop) => slotShouldForwardProp(prop) && prop !== "classes"; +const styled = _default({ + themeId: THEME_ID, + defaultTheme, + rootShouldForwardProp +}); +function useDefaultProps(params) { + return useDefaultProps$1(params); +} +function getTypographyUtilityClass(slot) { + return generateUtilityClass("MuiTypography", slot); +} +generateUtilityClasses("MuiTypography", ["root", "h1", "h2", "h3", "h4", "h5", "h6", "subtitle1", "subtitle2", "body1", "body2", "inherit", "button", "caption", "overline", "alignLeft", "alignRight", "alignCenter", "alignJustify", "noWrap", "gutterBottom", "paragraph"]); +const _excluded = ["align", "className", "component", "gutterBottom", "noWrap", "paragraph", "variant", "variantMapping"]; +const useUtilityClasses = (ownerState) => { + const { + align, + gutterBottom, + noWrap, + paragraph, + variant, + classes + } = ownerState; + const slots = { + root: ["root", variant, ownerState.align !== "inherit" && `align${capitalize$1(align)}`, gutterBottom && "gutterBottom", noWrap && "noWrap", paragraph && "paragraph"] + }; + return composeClasses(slots, getTypographyUtilityClass, classes); +}; +const TypographyRoot = styled("span", { + name: "MuiTypography", + slot: "Root", + overridesResolver: (props, styles) => { + const { + ownerState + } = props; + return [styles.root, ownerState.variant && styles[ownerState.variant], ownerState.align !== "inherit" && styles[`align${capitalize$1(ownerState.align)}`], ownerState.noWrap && styles.noWrap, ownerState.gutterBottom && styles.gutterBottom, ownerState.paragraph && styles.paragraph]; + } +})(({ + theme, + ownerState +}) => _extends$1({ + margin: 0 +}, ownerState.variant === "inherit" && { + // Some elements, like