npm - @max-ts/components - Versions diffs - 0.3.4 → 0.3.5 - Mend

@max-ts/components 0.3.4 → 0.3.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (602) hide show

package/lib/node_modules/.pnpm/@mui_material@6.4.5_@emotion_react@11.14.0_@types_react@19.0.10_react@19.0.0__@emotion__861faf9ddc4761e7658ec96cff5e306a/node_modules/@mui/material/CircularProgress/CircularProgress.mjs ADDED Viewed

@@ -0,0 +1,252 @@
+import * as O from "react";
+import r from "../../../../../../../_virtual/index.mjs";
+import { clsx as R } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.mjs";
+import C from "../utils/memoTheme.mjs";
+import T from "../utils/createSimplePaletteValueFilter.mjs";
+import { getCircularProgressUtilityClass as M } from "./circularProgressClasses.mjs";
+import { j as h } from "../../../../../../../_virtual/jsx-runtime.mjs";
+import { useDefaultProps as N } from "../DefaultPropsProvider/DefaultPropsProvider.mjs";
+import g from "../styles/styled.mjs";
+import c from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/capitalize/capitalize.mjs";
+import E from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/composeClasses/composeClasses.mjs";
+import { css as P, keyframes as w } from "../../../../../@emotion_react@11.14.0_@types_react@19.0.10_react@19.0.0/node_modules/@emotion/react/dist/emotion-react.browser.esm.mjs";
+import z from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/chainPropTypes/chainPropTypes.mjs";
+const s = 44, v = w`
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+`, y = w`
+  0% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: 0;
+  }
+  50% {
+    stroke-dasharray: 100px, 200px;
+    stroke-dashoffset: -15px;
+  }
+  100% {
+    stroke-dasharray: 1px, 200px;
+    stroke-dashoffset: -126px;
+  }
+`, F = typeof v != "string" ? P`
+        animation: ${v} 1.4s linear infinite;
+      ` : null, I = typeof y != "string" ? P`
+        animation: ${y} 1.4s ease-in-out infinite;
+      ` : null, U = (t) => {
+  const {
+    classes: e,
+    variant: o,
+    color: i,
+    disableShrink: l
+  } = t, p = {
+    root: ["root", o, `color${c(i)}`],
+    svg: ["svg"],
+    circle: ["circle", `circle${c(o)}`, l && "circleDisableShrink"]
+  };
+  return E(p, M, e);
+}, V = g("span", {
+  name: "MuiCircularProgress",
+  slot: "Root",
+  overridesResolver: (t, e) => {
+    const {
+      ownerState: o
+    } = t;
+    return [e.root, e[o.variant], e[`color${c(o.color)}`]];
+  }
+})(C(({
+  theme: t
+}) => ({
+  display: "inline-block",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: t.transitions.create("transform")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: F || {
+      animation: `${v} 1.4s linear infinite`
+    }
+  }, ...Object.entries(t.palette).filter(T()).map(([e]) => ({
+    props: {
+      color: e
+    },
+    style: {
+      color: (t.vars || t).palette[e].main
+    }
+  }))]
+}))), A = g("svg", {
+  name: "MuiCircularProgress",
+  slot: "Svg",
+  overridesResolver: (t, e) => e.svg
+})({
+  display: "block"
+  // Keeps the progress centered
+}), K = g("circle", {
+  name: "MuiCircularProgress",
+  slot: "Circle",
+  overridesResolver: (t, e) => {
+    const {
+      ownerState: o
+    } = t;
+    return [e.circle, e[`circle${c(o.variant)}`], o.disableShrink && e.circleDisableShrink];
+  }
+})(C(({
+  theme: t
+}) => ({
+  stroke: "currentColor",
+  variants: [{
+    props: {
+      variant: "determinate"
+    },
+    style: {
+      transition: t.transitions.create("stroke-dashoffset")
+    }
+  }, {
+    props: {
+      variant: "indeterminate"
+    },
+    style: {
+      // Some default value that looks fine waiting for the animation to kicks in.
+      strokeDasharray: "80px, 200px",
+      strokeDashoffset: 0
+      // Add the unit to fix a Edge 16 and below bug.
+    }
+  }, {
+    props: ({
+      ownerState: e
+    }) => e.variant === "indeterminate" && !e.disableShrink,
+    style: I || {
+      // At runtime for Pigment CSS, `bufferAnimation` will be null and the generated keyframe will be used.
+      animation: `${y} 1.4s ease-in-out infinite`
+    }
+  }]
+}))), B = /* @__PURE__ */ O.forwardRef(function(e, o) {
+  const i = N({
+    props: e,
+    name: "MuiCircularProgress"
+  }), {
+    className: l,
+    color: p = "primary",
+    disableShrink: $ = !1,
+    size: m = 40,
+    style: j,
+    thickness: a = 3.6,
+    value: f = 0,
+    variant: k = "indeterminate",
+    ...D
+  } = i, n = {
+    ...i,
+    color: p,
+    disableShrink: $,
+    size: m,
+    thickness: a,
+    value: f,
+    variant: k
+  }, d = U(n), u = {}, x = {}, b = {};
+  if (k === "determinate") {
+    const S = 2 * Math.PI * ((s - a) / 2);
+    u.strokeDasharray = S.toFixed(3), b["aria-valuenow"] = Math.round(f), u.strokeDashoffset = `${((100 - f) / 100 * S).toFixed(3)}px`, x.transform = "rotate(-90deg)";
+  }
+  return /* @__PURE__ */ h.jsx(V, {
+    className: R(d.root, l),
+    style: {
+      width: m,
+      height: m,
+      ...x,
+      ...j
+    },
+    ownerState: n,
+    ref: o,
+    role: "progressbar",
+    ...b,
+    ...D,
+    children: /* @__PURE__ */ h.jsx(A, {
+      className: d.svg,
+      ownerState: n,
+      viewBox: `${s / 2} ${s / 2} ${s} ${s}`,
+      children: /* @__PURE__ */ h.jsx(K, {
+        className: d.circle,
+        style: u,
+        ownerState: n,
+        cx: s,
+        cy: s,
+        r: (s - a) / 2,
+        fill: "none",
+        strokeWidth: a
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (B.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: r.object,
+  /**
+   * @ignore
+   */
+  className: r.string,
+  /**
+   * The color of the component.
+   * It supports both default and custom theme colors, which can be added as shown in the
+   * [palette customization guide](https://mui.com/material-ui/customization/palette/#custom-colors).
+   * @default 'primary'
+   */
+  color: r.oneOfType([r.oneOf(["inherit", "primary", "secondary", "error", "info", "success", "warning"]), r.string]),
+  /**
+   * If `true`, the shrink animation is disabled.
+   * This only works if variant is `indeterminate`.
+   * @default false
+   */
+  disableShrink: z(r.bool, (t) => t.disableShrink && t.variant && t.variant !== "indeterminate" ? new Error("MUI: You have provided the `disableShrink` prop with a variant other than `indeterminate`. This will have no effect.") : null),
+  /**
+   * The size of the component.
+   * If using a number, the pixel unit is assumed.
+   * If using a string, you need to provide the CSS unit, for example '3rem'.
+   * @default 40
+   */
+  size: r.oneOfType([r.number, r.string]),
+  /**
+   * @ignore
+   */
+  style: r.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: r.oneOfType([r.arrayOf(r.oneOfType([r.func, r.object, r.bool])), r.func, r.object]),
+  /**
+   * The thickness of the circle.
+   * @default 3.6
+   */
+  thickness: r.number,
+  /**
+   * The value of the progress indicator for the determinate variant.
+   * Value between 0 and 100.
+   * @default 0
+   */
+  value: r.number,
+  /**
+   * The variant to use.
+   * Use indeterminate when there is no progress value.
+   * @default 'indeterminate'
+   */
+  variant: r.oneOf(["determinate", "indeterminate"])
+});
+export {
+  B as default
+};

@@ -0,0 +1,9 @@
+import e from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/generateUtilityClass/generateUtilityClass.mjs";
+import i from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/generateUtilityClasses/generateUtilityClasses.mjs";
+function o(r) {
+  return e("MuiCircularProgress", r);
+}
+i("MuiCircularProgress", ["root", "determinate", "indeterminate", "colorPrimary", "colorSecondary", "svg", "circle", "circleDeterminate", "circleIndeterminate", "circleDisableShrink"]);
+export {
+  o as getCircularProgressUtilityClass
+};

@@ -0,0 +1,104 @@
+import * as o from "react";
+import l from "../../../../../../../_virtual/index.mjs";
+import w from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.mjs";
+import C from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/getReactElementRef/getReactElementRef.mjs";
+import L from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useEventCallback/useEventCallback.mjs";
+import h from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/ownerDocument/ownerDocument.mjs";
+import b from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/elementAcceptingRef/elementAcceptingRef.mjs";
+import g from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/exactProp/exactProp.mjs";
+function T(c) {
+  return c.substring(2).toLowerCase();
+}
+function D(c, s) {
+  return s.documentElement.clientWidth < c.clientX || s.documentElement.clientHeight < c.clientY;
+}
+function v(c) {
+  const {
+    children: s,
+    disableReactTree: y = !1,
+    mouseEvent: i = "onClick",
+    onClickAway: k,
+    touchEvent: u = "onTouchEnd"
+  } = c, a = o.useRef(!1), r = o.useRef(null), d = o.useRef(!1), m = o.useRef(!1);
+  o.useEffect(() => (setTimeout(() => {
+    d.current = !0;
+  }, 0), () => {
+    d.current = !1;
+  }), []);
+  const P = w(C(s), r), f = L((e) => {
+    const n = m.current;
+    m.current = !1;
+    const t = h(r.current);
+    if (!d.current || !r.current || "clientX" in e && D(e, t))
+      return;
+    if (a.current) {
+      a.current = !1;
+      return;
+    }
+    let E;
+    e.composedPath ? E = e.composedPath().includes(r.current) : E = !t.documentElement.contains(
+      // @ts-expect-error returns `false` as intended when not dispatched from a Node
+      e.target
+    ) || r.current.contains(
+      // @ts-expect-error returns `false` as intended when not dispatched from a Node
+      e.target
+    ), !E && (y || !n) && k(e);
+  }), R = (e) => (n) => {
+    m.current = !0;
+    const t = s.props[e];
+    t && t(n);
+  }, p = {
+    ref: P
+  };
+  return u !== !1 && (p[u] = R(u)), o.useEffect(() => {
+    if (u !== !1) {
+      const e = T(u), n = h(r.current), t = () => {
+        a.current = !0;
+      };
+      return n.addEventListener(e, f), n.addEventListener("touchmove", t), () => {
+        n.removeEventListener(e, f), n.removeEventListener("touchmove", t);
+      };
+    }
+  }, [f, u]), i !== !1 && (p[i] = R(i)), o.useEffect(() => {
+    if (i !== !1) {
+      const e = T(i), n = h(r.current);
+      return n.addEventListener(e, f), () => {
+        n.removeEventListener(e, f);
+      };
+    }
+  }, [f, i]), /* @__PURE__ */ o.cloneElement(s, p);
+}
+process.env.NODE_ENV !== "production" && (v.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │ To update them, edit the TypeScript types and run `pnpm proptypes`. │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * The wrapped element.
+   */
+  children: b.isRequired,
+  /**
+   * If `true`, the React tree is ignored and only the DOM tree is considered.
+   * This prop changes how portaled elements are handled.
+   * @default false
+   */
+  disableReactTree: l.bool,
+  /**
+   * The mouse event to listen to. You can disable the listener by providing `false`.
+   * @default 'onClick'
+   */
+  mouseEvent: l.oneOf(["onClick", "onMouseDown", "onMouseUp", "onPointerDown", "onPointerUp", !1]),
+  /**
+   * Callback fired when a "click away" event is detected.
+   */
+  onClickAway: l.func.isRequired,
+  /**
+   * The touch event to listen to. You can disable the listener by providing `false`.
+   * @default 'onTouchEnd'
+   */
+  touchEvent: l.oneOf(["onTouchEnd", "onTouchStart", !1])
+});
+process.env.NODE_ENV !== "production" && (v.propTypes = g(v.propTypes));
+export {
+  v as ClickAwayListener
+};

@@ -0,0 +1,335 @@
+import * as w from "react";
+import { clsx as tt } from "../../../../../clsx@2.1.1/node_modules/clsx/dist/clsx.mjs";
+import t from "../../../../../../../_virtual/index.mjs";
+import et from "../styles/useTheme.mjs";
+import { j as v } from "../../../../../../../_virtual/jsx-runtime.mjs";
+import C from "../styles/styled.mjs";
+import nt from "../utils/memoTheme.mjs";
+import { duration as ot } from "../styles/createTransitions.mjs";
+import { getTransitionProps as A } from "../transitions/utils.mjs";
+import { getCollapseUtilityClass as it } from "./collapseClasses.mjs";
+import { useDefaultProps as rt } from "../DefaultPropsProvider/DefaultPropsProvider.mjs";
+import st from "../../../../../react-transition-group@4.4.5_react-dom@19.0.0_react@19.0.0__react@19.0.0/node_modules/react-transition-group/esm/Transition.mjs";
+import at from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useTimeout/useTimeout.mjs";
+import pt from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/useForkRef/useForkRef.mjs";
+import lt from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/composeClasses/composeClasses.mjs";
+import ct from "../../../../../@mui_utils@6.4.3_@types_react@19.0.10_react@19.0.0/node_modules/@mui/utils/esm/elementTypeAcceptingRef/elementTypeAcceptingRef.mjs";
+const dt = (r) => {
+  const {
+    orientation: n,
+    classes: s
+  } = r, f = {
+    root: ["root", `${n}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${n}`],
+    wrapperInner: ["wrapperInner", `${n}`]
+  };
+  return lt(f, it, s);
+}, ut = C("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (r, n) => {
+    const {
+      ownerState: s
+    } = r;
+    return [n.root, n[s.orientation], s.state === "entered" && n.entered, s.state === "exited" && !s.in && s.collapsedSize === "0px" && n.hidden];
+  }
+})(nt(({
+  theme: r
+}) => ({
+  height: 0,
+  overflow: "hidden",
+  transition: r.transitions.create("height"),
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      height: "auto",
+      width: 0,
+      transition: r.transitions.create("width")
+    }
+  }, {
+    props: {
+      state: "entered"
+    },
+    style: {
+      height: "auto",
+      overflow: "visible"
+    }
+  }, {
+    props: {
+      state: "entered",
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto"
+    }
+  }, {
+    props: ({
+      ownerState: n
+    }) => n.state === "exited" && !n.in && n.collapsedSize === "0px",
+    style: {
+      visibility: "hidden"
+    }
+  }]
+}))), mt = C("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper",
+  overridesResolver: (r, n) => n.wrapper
+})({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), ft = C("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (r, n) => n.wrapperInner
+})({
+  width: "100%",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      width: "auto",
+      height: "100%"
+    }
+  }]
+}), S = /* @__PURE__ */ w.forwardRef(function(n, s) {
+  const f = rt({
+    props: n,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: b,
+    children: L,
+    className: M,
+    collapsedSize: h = "0px",
+    component: U,
+    easing: D,
+    in: j,
+    onEnter: O,
+    onEntered: $,
+    onEntering: N,
+    onExit: W,
+    onExited: V,
+    onExiting: F,
+    orientation: H = "vertical",
+    style: T,
+    timeout: a = ot.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: _ = st,
+    ...k
+  } = f, g = {
+    ...f,
+    orientation: H,
+    collapsedSize: h
+  }, c = dt(g), I = et(), q = at(), p = w.useRef(null), z = w.useRef(), y = typeof h == "number" ? `${h}px` : h, d = H === "horizontal", u = d ? "width" : "height", x = w.useRef(null), B = pt(s, x), l = (e) => (o) => {
+    if (e) {
+      const i = x.current;
+      o === void 0 ? e(i) : e(i, o);
+    }
+  }, R = () => p.current ? p.current[d ? "clientWidth" : "clientHeight"] : 0, G = l((e, o) => {
+    p.current && d && (p.current.style.position = "absolute"), e.style[u] = y, O && O(e, o);
+  }), J = l((e, o) => {
+    const i = R();
+    p.current && d && (p.current.style.position = "");
+    const {
+      duration: m,
+      easing: E
+    } = A({
+      style: T,
+      timeout: a,
+      easing: D
+    }, {
+      mode: "enter"
+    });
+    if (a === "auto") {
+      const P = I.transitions.getAutoHeightDuration(i);
+      e.style.transitionDuration = `${P}ms`, z.current = P;
+    } else
+      e.style.transitionDuration = typeof m == "string" ? m : `${m}ms`;
+    e.style[u] = `${i}px`, e.style.transitionTimingFunction = E, N && N(e, o);
+  }), K = l((e, o) => {
+    e.style[u] = "auto", $ && $(e, o);
+  }), Q = l((e) => {
+    e.style[u] = `${R()}px`, W && W(e);
+  }), X = l(V), Y = l((e) => {
+    const o = R(), {
+      duration: i,
+      easing: m
+    } = A({
+      style: T,
+      timeout: a,
+      easing: D
+    }, {
+      mode: "exit"
+    });
+    if (a === "auto") {
+      const E = I.transitions.getAutoHeightDuration(o);
+      e.style.transitionDuration = `${E}ms`, z.current = E;
+    } else
+      e.style.transitionDuration = typeof i == "string" ? i : `${i}ms`;
+    e.style[u] = y, e.style.transitionTimingFunction = m, F && F(e);
+  }), Z = (e) => {
+    a === "auto" && q.start(z.current || 0, e), b && b(x.current, e);
+  };
+  return /* @__PURE__ */ v.jsx(_, {
+    in: j,
+    onEnter: G,
+    onEntered: K,
+    onEntering: J,
+    onExit: Q,
+    onExited: X,
+    onExiting: Y,
+    addEndListener: Z,
+    nodeRef: x,
+    timeout: a === "auto" ? null : a,
+    ...k,
+    children: (e, {
+      ownerState: o,
+      ...i
+    }) => /* @__PURE__ */ v.jsx(ut, {
+      as: U,
+      className: tt(c.root, M, {
+        entered: c.entered,
+        exited: !j && y === "0px" && c.hidden
+      }[e]),
+      style: {
+        [d ? "minWidth" : "minHeight"]: y,
+        ...T
+      },
+      ref: B,
+      ownerState: {
+        ...g,
+        state: e
+      },
+      ...i,
+      children: /* @__PURE__ */ v.jsx(mt, {
+        ownerState: {
+          ...g,
+          state: e
+        },
+        className: c.wrapper,
+        ref: p,
+        children: /* @__PURE__ */ v.jsx(ft, {
+          ownerState: {
+            ...g,
+            state: e
+          },
+          className: c.wrapperInner,
+          children: L
+        })
+      })
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (S.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Add a custom transition end trigger. Called with the transitioning DOM
+   * node and a done callback. Allows for more fine grained transition end
+   * logic. Note: Timeouts are still used as a fallback if provided.
+   */
+  addEndListener: t.func,
+  /**
+   * The content node to be collapsed.
+   */
+  children: t.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: t.object,
+  /**
+   * @ignore
+   */
+  className: t.string,
+  /**
+   * The width (horizontal) or height (vertical) of the container when collapsed.
+   * @default '0px'
+   */
+  collapsedSize: t.oneOfType([t.number, t.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: ct,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: t.oneOfType([t.shape({
+    enter: t.string,
+    exit: t.string
+  }), t.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: t.bool,
+  /**
+   * @ignore
+   */
+  onEnter: t.func,
+  /**
+   * @ignore
+   */
+  onEntered: t.func,
+  /**
+   * @ignore
+   */
+  onEntering: t.func,
+  /**
+   * @ignore
+   */
+  onExit: t.func,
+  /**
+   * @ignore
+   */
+  onExited: t.func,
+  /**
+   * @ignore
+   */
+  onExiting: t.func,
+  /**
+   * The transition orientation.
+   * @default 'vertical'
+   */
+  orientation: t.oneOf(["horizontal", "vertical"]),
+  /**
+   * @ignore
+   */
+  style: t.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: t.oneOfType([t.arrayOf(t.oneOfType([t.func, t.object, t.bool])), t.func, t.object]),
+  /**
+   * The duration for the transition, in milliseconds.
+   * You may specify a single timeout for all transitions, or individually with an object.
+   *
+   * Set to 'auto' to automatically calculate transition time based on height.
+   * @default duration.standard
+   */
+  timeout: t.oneOfType([t.oneOf(["auto"]), t.number, t.shape({
+    appear: t.number,
+    enter: t.number,
+    exit: t.number
+  })])
+});
+S && (S.muiSupportAuto = !0);
+export {
+  S as default
+};