@solostylist/ui-kit 1.0.174 → 1.0.176

package/dist/Paper-DnctZB5U.js

@@ -0,0 +1,689 @@
+import { _ as q } from "./objectWithoutPropertiesLoose-DiWPeE4c.js";
+import { _ as V, T as Y, d as G } from "./ButtonBase-C_YYB9Ry.js";
+import { P as o, l as I } from "./createTheme-f5g1s6ww.js";
+import * as F from "react";
+import N from "react";
+import P from "react-dom";
+import { c as W } from "./clsx-OuTLNxxd.js";
+import { d as z } from "./defaultTheme-LSr-S9un.js";
+import { T as X } from "./identifier-BKLqN993.js";
+import { u as H } from "./useTheme-CtdhfT4P.js";
+import { j as Z } from "./jsx-runtime-tc70JA_2.js";
+import { s as B } from "./styled-B0KflPi-.js";
+import { u as J, c as K, m as Q } from "./DefaultPropsProvider-sk0uWcA6.js";
+import { g as j, a as $ } from "./colorManipulator-ep5lERxB.js";
+import { g as ee } from "./generateUtilityClasses-BtVDwGrk.js";
+function te() {
+  const r = H(z);
+  return process.env.NODE_ENV !== "production" && F.useDebugValue(r), r[X] || r;
+}
+var g = { exports: {} }, f = {};
+var M;
+function ne() {
+  if (M) return f;
+  M = 1;
+  var r = /* @__PURE__ */ Symbol.for("react.transitional.element"), u = /* @__PURE__ */ Symbol.for("react.portal"), s = /* @__PURE__ */ Symbol.for("react.fragment"), i = /* @__PURE__ */ Symbol.for("react.strict_mode"), n = /* @__PURE__ */ Symbol.for("react.profiler"), t = /* @__PURE__ */ Symbol.for("react.consumer"), a = /* @__PURE__ */ Symbol.for("react.context"), l = /* @__PURE__ */ Symbol.for("react.forward_ref"), p = /* @__PURE__ */ Symbol.for("react.suspense"), d = /* @__PURE__ */ Symbol.for("react.suspense_list"), E = /* @__PURE__ */ Symbol.for("react.memo"), m = /* @__PURE__ */ Symbol.for("react.lazy"), T = /* @__PURE__ */ Symbol.for("react.view_transition"), b = /* @__PURE__ */ Symbol.for("react.client.reference");
+  function v(e) {
+    if (typeof e == "object" && e !== null) {
+      var R = e.$$typeof;
+      switch (R) {
+        case r:
+          switch (e = e.type, e) {
+            case s:
+            case n:
+            case i:
+            case p:
+            case d:
+            case T:
+              return e;
+            default:
+              switch (e = e && e.$$typeof, e) {
+                case a:
+                case l:
+                case m:
+                case E:
+                  return e;
+                case t:
+                  return e;
+                default:
+                  return R;
+              }
+          }
+        case u:
+          return R;
+      }
+    }
+  }
+  return f.ContextConsumer = t, f.ContextProvider = a, f.Element = r, f.ForwardRef = l, f.Fragment = s, f.Lazy = m, f.Memo = E, f.Portal = u, f.Profiler = n, f.StrictMode = i, f.Suspense = p, f.SuspenseList = d, f.isContextConsumer = function(e) {
+    return v(e) === t;
+  }, f.isContextProvider = function(e) {
+    return v(e) === a;
+  }, f.isElement = function(e) {
+    return typeof e == "object" && e !== null && e.$$typeof === r;
+  }, f.isForwardRef = function(e) {
+    return v(e) === l;
+  }, f.isFragment = function(e) {
+    return v(e) === s;
+  }, f.isLazy = function(e) {
+    return v(e) === m;
+  }, f.isMemo = function(e) {
+    return v(e) === E;
+  }, f.isPortal = function(e) {
+    return v(e) === u;
+  }, f.isProfiler = function(e) {
+    return v(e) === n;
+  }, f.isStrictMode = function(e) {
+    return v(e) === i;
+  }, f.isSuspense = function(e) {
+    return v(e) === p;
+  }, f.isSuspenseList = function(e) {
+    return v(e) === d;
+  }, f.isValidElementType = function(e) {
+    return typeof e == "string" || typeof e == "function" || e === s || e === n || e === i || e === p || e === d || typeof e == "object" && e !== null && (e.$$typeof === m || e.$$typeof === E || e.$$typeof === a || e.$$typeof === t || e.$$typeof === l || e.$$typeof === b || e.getModuleId !== void 0);
+  }, f.typeOf = v, f;
+}
+var c = {};
+var D;
+function re() {
+  return D || (D = 1, process.env.NODE_ENV !== "production" && (function() {
+    function r(e) {
+      if (typeof e == "object" && e !== null) {
+        var R = e.$$typeof;
+        switch (R) {
+          case u:
+            switch (e = e.type, e) {
+              case i:
+              case t:
+              case n:
+              case d:
+              case E:
+              case b:
+                return e;
+              default:
+                switch (e = e && e.$$typeof, e) {
+                  case l:
+                  case p:
+                  case T:
+                  case m:
+                    return e;
+                  case a:
+                    return e;
+                  default:
+                    return R;
+                }
+            }
+          case s:
+            return R;
+        }
+      }
+    }
+    var u = /* @__PURE__ */ Symbol.for("react.transitional.element"), s = /* @__PURE__ */ Symbol.for("react.portal"), i = /* @__PURE__ */ Symbol.for("react.fragment"), n = /* @__PURE__ */ Symbol.for("react.strict_mode"), t = /* @__PURE__ */ Symbol.for("react.profiler"), a = /* @__PURE__ */ Symbol.for("react.consumer"), l = /* @__PURE__ */ Symbol.for("react.context"), p = /* @__PURE__ */ Symbol.for("react.forward_ref"), d = /* @__PURE__ */ Symbol.for("react.suspense"), E = /* @__PURE__ */ Symbol.for("react.suspense_list"), m = /* @__PURE__ */ Symbol.for("react.memo"), T = /* @__PURE__ */ Symbol.for("react.lazy"), b = /* @__PURE__ */ Symbol.for("react.view_transition"), v = /* @__PURE__ */ Symbol.for("react.client.reference");
+    c.ContextConsumer = a, c.ContextProvider = l, c.Element = u, c.ForwardRef = p, c.Fragment = i, c.Lazy = T, c.Memo = m, c.Portal = s, c.Profiler = t, c.StrictMode = n, c.Suspense = d, c.SuspenseList = E, c.isContextConsumer = function(e) {
+      return r(e) === a;
+    }, c.isContextProvider = function(e) {
+      return r(e) === l;
+    }, c.isElement = function(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === u;
+    }, c.isForwardRef = function(e) {
+      return r(e) === p;
+    }, c.isFragment = function(e) {
+      return r(e) === i;
+    }, c.isLazy = function(e) {
+      return r(e) === T;
+    }, c.isMemo = function(e) {
+      return r(e) === m;
+    }, c.isPortal = function(e) {
+      return r(e) === s;
+    }, c.isProfiler = function(e) {
+      return r(e) === t;
+    }, c.isStrictMode = function(e) {
+      return r(e) === n;
+    }, c.isSuspense = function(e) {
+      return r(e) === d;
+    }, c.isSuspenseList = function(e) {
+      return r(e) === E;
+    }, c.isValidElementType = function(e) {
+      return typeof e == "string" || typeof e == "function" || e === i || e === t || e === n || e === d || e === E || typeof e == "object" && e !== null && (e.$$typeof === T || e.$$typeof === m || e.$$typeof === l || e.$$typeof === a || e.$$typeof === p || e.$$typeof === v || e.getModuleId !== void 0);
+    }, c.typeOf = r;
+  })()), c;
+}
+var w;
+function oe() {
+  return w || (w = 1, process.env.NODE_ENV === "production" ? g.exports = /* @__PURE__ */ ne() : g.exports = /* @__PURE__ */ re()), g.exports;
+}
+var ge = /* @__PURE__ */ oe();
+const L = {
+  disabled: !1
+};
+var ie = process.env.NODE_ENV !== "production" ? o.oneOfType([o.number, o.shape({
+  enter: o.number,
+  exit: o.number,
+  appear: o.number
+}).isRequired]) : null, be = process.env.NODE_ENV !== "production" ? o.oneOfType([o.string, o.shape({
+  enter: o.string,
+  exit: o.string,
+  active: o.string
+}), o.shape({
+  enter: o.string,
+  enterDone: o.string,
+  enterActive: o.string,
+  exit: o.string,
+  exitDone: o.string,
+  exitActive: o.string
+})]) : null, ae = function(u) {
+  return u.scrollTop;
+}, C = "unmounted", _ = "exited", x = "entering", y = "entered", O = "exiting", h = /* @__PURE__ */ (function(r) {
+  V(u, r);
+  function u(i, n) {
+    var t;
+    t = r.call(this, i, n) || this;
+    var a = n, l = a && !a.isMounting ? i.enter : i.appear, p;
+    return t.appearStatus = null, i.in ? l ? (p = _, t.appearStatus = x) : p = y : i.unmountOnExit || i.mountOnEnter ? p = C : p = _, t.state = {
+      status: p
+    }, t.nextCallback = null, t;
+  }
+  u.getDerivedStateFromProps = function(n, t) {
+    var a = n.in;
+    return a && t.status === C ? {
+      status: _
+    } : null;
+  };
+  var s = u.prototype;
+  return s.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, s.componentDidUpdate = function(n) {
+    var t = null;
+    if (n !== this.props) {
+      var a = this.state.status;
+      this.props.in ? a !== x && a !== y && (t = x) : (a === x || a === y) && (t = O);
+    }
+    this.updateStatus(!1, t);
+  }, s.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, s.getTimeouts = function() {
+    var n = this.props.timeout, t, a, l;
+    return t = a = l = n, n != null && typeof n != "number" && (t = n.exit, a = n.enter, l = n.appear !== void 0 ? n.appear : a), {
+      exit: t,
+      enter: a,
+      appear: l
+    };
+  }, s.updateStatus = function(n, t) {
+    if (n === void 0 && (n = !1), t !== null)
+      if (this.cancelNextCallback(), t === x) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var a = this.props.nodeRef ? this.props.nodeRef.current : P.findDOMNode(this);
+          a && ae(a);
+        }
+        this.performEnter(n);
+      } else
+        this.performExit();
+    else this.props.unmountOnExit && this.state.status === _ && this.setState({
+      status: C
+    });
+  }, s.performEnter = function(n) {
+    var t = this, a = this.props.enter, l = this.context ? this.context.isMounting : n, p = this.props.nodeRef ? [l] : [P.findDOMNode(this), l], d = p[0], E = p[1], m = this.getTimeouts(), T = l ? m.appear : m.enter;
+    if (!n && !a || L.disabled) {
+      this.safeSetState({
+        status: y
+      }, function() {
+        t.props.onEntered(d);
+      });
+      return;
+    }
+    this.props.onEnter(d, E), this.safeSetState({
+      status: x
+    }, function() {
+      t.props.onEntering(d, E), t.onTransitionEnd(T, function() {
+        t.safeSetState({
+          status: y
+        }, function() {
+          t.props.onEntered(d, E);
+        });
+      });
+    });
+  }, s.performExit = function() {
+    var n = this, t = this.props.exit, a = this.getTimeouts(), l = this.props.nodeRef ? void 0 : P.findDOMNode(this);
+    if (!t || L.disabled) {
+      this.safeSetState({
+        status: _
+      }, function() {
+        n.props.onExited(l);
+      });
+      return;
+    }
+    this.props.onExit(l), this.safeSetState({
+      status: O
+    }, function() {
+      n.props.onExiting(l), n.onTransitionEnd(a.exit, function() {
+        n.safeSetState({
+          status: _
+        }, function() {
+          n.props.onExited(l);
+        });
+      });
+    });
+  }, s.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, s.safeSetState = function(n, t) {
+    t = this.setNextCallback(t), this.setState(n, t);
+  }, s.setNextCallback = function(n) {
+    var t = this, a = !0;
+    return this.nextCallback = function(l) {
+      a && (a = !1, t.nextCallback = null, n(l));
+    }, this.nextCallback.cancel = function() {
+      a = !1;
+    }, this.nextCallback;
+  }, s.onTransitionEnd = function(n, t) {
+    this.setNextCallback(t);
+    var a = this.props.nodeRef ? this.props.nodeRef.current : P.findDOMNode(this), l = n == null && !this.props.addEndListener;
+    if (!a || l) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var p = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], d = p[0], E = p[1];
+      this.props.addEndListener(d, E);
+    }
+    n != null && setTimeout(this.nextCallback, n);
+  }, s.render = function() {
+    var n = this.state.status;
+    if (n === C)
+      return null;
+    var t = this.props, a = t.children;
+    t.in, t.mountOnEnter, t.unmountOnExit, t.appear, t.enter, t.exit, t.timeout, t.addEndListener, t.onEnter, t.onEntering, t.onEntered, t.onExit, t.onExiting, t.onExited, t.nodeRef;
+    var l = q(t, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ N.createElement(Y.Provider, {
+        value: null
+      }, typeof a == "function" ? a(n, l) : N.cloneElement(N.Children.only(a), l))
+    );
+  }, u;
+})(N.Component);
+h.contextType = Y;
+h.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A React reference to DOM element that need to transition:
+   * https://stackoverflow.com/a/51127130/4671932
+   *
+   *   - When `nodeRef` prop is used, `node` is not passed to callback functions
+   *      (e.g. `onEnter`) because user already has direct access to the node.
+   *   - When changing `key` prop of `Transition` in a `TransitionGroup` a new
+   *     `nodeRef` need to be provided to `Transition` with changed `key` prop
+   *     (see
+   *     [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
+   */
+  nodeRef: o.shape({
+    current: typeof Element > "u" ? o.any : function(r, u, s, i, n, t) {
+      var a = r[u];
+      return o.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(r, u, s, i, n, t);
+    }
+  }),
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: o.oneOfType([o.func.isRequired, o.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: o.bool,
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: o.bool,
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: o.bool,
+  /**
+   * By default the child component does not perform the enter transition when
+   * it first mounts, regardless of the value of `in`. If you want this
+   * behavior, set both `appear` and `in` to `true`.
+   *
+   * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
+   * > only adds an additional enter transition. However, in the
+   * > `<CSSTransition>` component that first enter transition does result in
+   * > additional `.appear-*` classes, that way you can choose to style it
+   * > differently.
+   */
+  appear: o.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: o.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: o.bool,
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function(u) {
+    var s = ie;
+    u.addEndListener || (s = s.isRequired);
+    for (var i = arguments.length, n = new Array(i > 1 ? i - 1 : 0), t = 1; t < i; t++)
+      n[t - 1] = arguments[t];
+    return s.apply(void 0, [u].concat(n));
+  },
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. Timeouts are still used as a fallback if provided.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: o.func,
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: o.func,
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: o.func,
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: o.func,
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: o.func,
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: o.func,
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * **Note**: when `nodeRef` prop is passed, `node` is not passed
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: o.func
+} : {};
+function S() {
+}
+h.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: S,
+  onEntering: S,
+  onEntered: S,
+  onExit: S,
+  onExiting: S,
+  onExited: S
+};
+h.UNMOUNTED = C;
+h.EXITED = _;
+h.ENTERING = x;
+h.ENTERED = y;
+h.EXITING = O;
+const Oe = (r) => r.scrollTop;
+function Ae(r, u) {
+  const {
+    timeout: s,
+    easing: i,
+    style: n = {}
+  } = r;
+  return {
+    duration: n.transitionDuration ?? (typeof s == "number" ? s : s[u.mode] || 0),
+    easing: n.transitionTimingFunction ?? (typeof i == "object" ? i[u.mode] : i),
+    delay: n.transitionDelay
+  };
+}
+function se(r) {
+  const u = typeof r;
+  switch (u) {
+    case "number":
+      return Number.isNaN(r) ? "NaN" : Number.isFinite(r) ? r !== Math.floor(r) ? "float" : "number" : "Infinity";
+    case "object":
+      return r === null ? "null" : r.constructor.name;
+    default:
+      return u;
+  }
+}
+function U(r, u, s, i) {
+  const n = r[u];
+  if (n == null || !Number.isInteger(n)) {
+    const t = se(n);
+    return new RangeError(`Invalid ${i} \`${u}\` of type \`${t}\` supplied to \`${s}\`, expected \`integer\`.`);
+  }
+  return null;
+}
+function k(r, u, s, i) {
+  return r[u] === void 0 ? null : U(r, u, s, i);
+}
+function A() {
+  return null;
+}
+k.isRequired = U;
+A.isRequired = A;
+const ue = process.env.NODE_ENV === "production" ? A : k;
+function le(r) {
+  return j("MuiPaper", r);
+}
+ee("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 fe = (r) => {
+  const {
+    square: u,
+    elevation: s,
+    variant: i,
+    classes: n
+  } = r, t = {
+    root: ["root", i, !u && "rounded", i === "elevation" && `elevation${s}`]
+  };
+  return K(t, le, n);
+}, ce = B("div", {
+  name: "MuiPaper",
+  slot: "Root",
+  overridesResolver: (r, u) => {
+    const {
+      ownerState: s
+    } = r;
+    return [u.root, u[s.variant], !s.square && u.rounded, s.variant === "elevation" && u[`elevation${s.elevation}`]];
+  }
+})(Q(({
+  theme: r
+}) => ({
+  backgroundColor: (r.vars || r).palette.background.paper,
+  color: (r.vars || r).palette.text.primary,
+  transition: r.transitions.create("box-shadow"),
+  variants: [{
+    props: ({
+      ownerState: u
+    }) => !u.square,
+    style: {
+      borderRadius: r.shape.borderRadius
+    }
+  }, {
+    props: {
+      variant: "outlined"
+    },
+    style: {
+      border: `1px solid ${(r.vars || r).palette.divider}`
+    }
+  }, {
+    props: {
+      variant: "elevation"
+    },
+    style: {
+      boxShadow: "var(--Paper-shadow)",
+      backgroundImage: "var(--Paper-overlay)"
+    }
+  }]
+}))), pe = /* @__PURE__ */ F.forwardRef(function(u, s) {
+  const i = J({
+    props: u,
+    name: "MuiPaper"
+  }), n = te(), {
+    className: t,
+    component: a = "div",
+    elevation: l = 1,
+    square: p = !1,
+    variant: d = "elevation",
+    ...E
+  } = i, m = {
+    ...i,
+    component: a,
+    elevation: l,
+    square: p,
+    variant: d
+  }, T = fe(m);
+  return process.env.NODE_ENV !== "production" && n.shadows[l] === void 0 && console.error([`MUI: The elevation provided <Paper elevation={${l}}> is not available in the theme.`, `Please make sure that \`theme.shadows[${l}]\` is defined.`].join(`
+`)), /* @__PURE__ */ Z.jsx(ce, {
+    as: a,
+    ownerState: m,
+    className: W(T.root, t),
+    ref: s,
+    ...E,
+    style: {
+      ...d === "elevation" && {
+        "--Paper-shadow": (n.vars || n).shadows[l],
+        ...n.vars && {
+          "--Paper-overlay": n.vars.overlays?.[l]
+        },
+        ...!n.vars && n.palette.mode === "dark" && {
+          "--Paper-overlay": `linear-gradient(${$("#fff", I(l))}, ${$("#fff", I(l))})`
+        }
+      },
+      ...E.style
+    }
+  });
+});
+process.env.NODE_ENV !== "production" && (pe.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The content of the component.
+   */
+  children: o.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: o.elementType,
+  /**
+   * Shadow depth, corresponds to `dp` in the spec.
+   * It accepts values between 0 and 24 inclusive.
+   * @default 1
+   */
+  elevation: G(ue, (r) => {
+    const {
+      elevation: u,
+      variant: s
+    } = r;
+    return u > 0 && s === "outlined" ? new Error(`MUI: Combining \`elevation={${u}}\` with \`variant="${s}"\` has no effect. Either use \`elevation={0}\` or use a different \`variant\`.`) : null;
+  }),
+  /**
+   * If `true`, rounded corners are disabled.
+   * @default false
+   */
+  square: o.bool,
+  /**
+   * @ignore
+   */
+  style: o.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object]),
+  /**
+   * The variant to use.
+   * @default 'elevation'
+   */
+  variant: o.oneOfType([o.oneOf(["elevation", "outlined"]), o.string])
+});
+export {
+  pe as P,
+  h as T,
+  Oe as a,
+  be as c,
+  ae as f,
+  Ae as g,
+  ue as i,
+  ge as r,
+  te as u
+};