@jigowatts/jigowatts-ui 0.0.1-12

package/dist/AccordionSummary-B4zooGpd.js

@@ -0,0 +1,831 @@
+import { i as he, u as ne, g as B, b as H, s as O, a as i, n as xe, _ as j, c as J } from "./styled-CWju4EfZ.js";
+import { r as be } from "./createSvgIcon-Dj8zNxRS.js";
+import ye, { jsx as E, jsxs as re } from "react/jsx-runtime";
+import * as l from "react";
+import { r as ve } from "./index-BLPOOjNr.js";
+import { c as G, P as e } from "./index-Bs3JCwgu.js";
+import { u as Ce, r as Ee, m as Te, a as Se } from "./mergeSlotProps-J197zKan.js";
+import { d as we, u as se } from "./useIsFocusVisible-BxB-Hdhb.js";
+import { T as Re, g as te, P as Pe } from "./Paper-COvYqxZa.js";
+import { a as Ae } from "./useControlled-BQCJRJNJ.js";
+import { e as Ne, c as $e, B as Oe } from "./ButtonBase-pxtIu13Q.js";
+var X = {}, Me = he;
+Object.defineProperty(X, "__esModule", {
+  value: !0
+});
+var De = X.default = void 0, je = Me(be()), ze = ye;
+De = X.default = (0, je.default)(/* @__PURE__ */ (0, ze.jsx)("path", {
+  d: "M16.59 8.59 12 13.17 7.41 8.59 6 10l6 6 6-6z"
+}), "ExpandMore");
+function Y(o) {
+  return ne;
+}
+function _e(o) {
+  return B("MuiCollapse", o);
+}
+H("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const Ie = ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"], Ve = (o) => {
+  const {
+    orientation: t,
+    classes: r
+  } = o, s = {
+    root: ["root", `${t}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${t}`],
+    wrapperInner: ["wrapperInner", `${t}`]
+  };
+  return J(s, _e, r);
+}, We = O("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [t.root, t[r.orientation], r.state === "entered" && t.entered, r.state === "exited" && !r.in && r.collapsedSize === "0px" && t.hidden];
+  }
+})(({
+  theme: o,
+  ownerState: t
+}) => i({
+  height: 0,
+  overflow: "hidden",
+  transition: o.transitions.create("height")
+}, t.orientation === "horizontal" && {
+  height: "auto",
+  width: 0,
+  transition: o.transitions.create("width")
+}, t.state === "entered" && i({
+  height: "auto",
+  overflow: "visible"
+}, t.orientation === "horizontal" && {
+  width: "auto"
+}), t.state === "exited" && !t.in && t.collapsedSize === "0px" && {
+  visibility: "hidden"
+})), ke = O("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper",
+  overridesResolver: (o, t) => t.wrapper
+})(({
+  ownerState: o
+}) => i({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%"
+}, o.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), Fe = O("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (o, t) => t.wrapperInner
+})(({
+  ownerState: o
+}) => i({
+  width: "100%"
+}, o.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), Z = /* @__PURE__ */ l.forwardRef(function(t, r) {
+  const s = ne({
+    props: t,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: a,
+    children: p,
+    className: u,
+    collapsedSize: c = "0px",
+    component: y,
+    easing: T,
+    in: f,
+    onEnter: S,
+    onEntered: w,
+    onEntering: v,
+    onExit: C,
+    onExited: b,
+    onExiting: m,
+    orientation: d = "vertical",
+    style: R,
+    timeout: g = xe.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: $ = Re
+  } = s, V = j(s, Ie), P = i({}, s, {
+    orientation: d,
+    collapsedSize: c
+  }), h = Ve(P), M = Ce(), K = we(), A = l.useRef(null), W = l.useRef(), z = typeof c == "number" ? `${c}px` : c, D = d === "horizontal", k = D ? "width" : "height", U = l.useRef(null), de = se(r, U), _ = (n) => (x) => {
+    if (n) {
+      const N = U.current;
+      x === void 0 ? n(N) : n(N, x);
+    }
+  }, Q = () => A.current ? A.current[D ? "clientWidth" : "clientHeight"] : 0, le = _((n, x) => {
+    A.current && D && (A.current.style.position = "absolute"), n.style[k] = z, S && S(n, x);
+  }), pe = _((n, x) => {
+    const N = Q();
+    A.current && D && (A.current.style.position = "");
+    const {
+      duration: F,
+      easing: q
+    } = te({
+      style: R,
+      timeout: g,
+      easing: T
+    }, {
+      mode: "enter"
+    });
+    if (g === "auto") {
+      const oe = M.transitions.getAutoHeightDuration(N);
+      n.style.transitionDuration = `${oe}ms`, W.current = oe;
+    } else
+      n.style.transitionDuration = typeof F == "string" ? F : `${F}ms`;
+    n.style[k] = `${N}px`, n.style.transitionTimingFunction = q, v && v(n, x);
+  }), ue = _((n, x) => {
+    n.style[k] = "auto", w && w(n, x);
+  }), fe = _((n) => {
+    n.style[k] = `${Q()}px`, C && C(n);
+  }), me = _(b), ge = _((n) => {
+    const x = Q(), {
+      duration: N,
+      easing: F
+    } = te({
+      style: R,
+      timeout: g,
+      easing: T
+    }, {
+      mode: "exit"
+    });
+    if (g === "auto") {
+      const q = M.transitions.getAutoHeightDuration(x);
+      n.style.transitionDuration = `${q}ms`, W.current = q;
+    } else
+      n.style.transitionDuration = typeof N == "string" ? N : `${N}ms`;
+    n.style[k] = z, n.style.transitionTimingFunction = F, m && m(n);
+  });
+  return /* @__PURE__ */ E($, i({
+    in: f,
+    onEnter: le,
+    onEntered: ue,
+    onEntering: pe,
+    onExit: fe,
+    onExited: me,
+    onExiting: ge,
+    addEndListener: (n) => {
+      g === "auto" && K.start(W.current || 0, n), a && a(U.current, n);
+    },
+    nodeRef: U,
+    timeout: g === "auto" ? null : g
+  }, V, {
+    children: (n, x) => /* @__PURE__ */ E(We, i({
+      as: y,
+      className: G(h.root, u, {
+        entered: h.entered,
+        exited: !f && z === "0px" && h.hidden
+      }[n]),
+      style: i({
+        [D ? "minWidth" : "minHeight"]: z
+      }, R),
+      ref: de
+    }, x, {
+      // `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
+      // that might have been forwarded from the Transition component.
+      ownerState: i({}, P, {
+        state: n
+      }),
+      children: /* @__PURE__ */ E(ke, {
+        ownerState: i({}, P, {
+          state: n
+        }),
+        className: h.wrapper,
+        ref: A,
+        children: /* @__PURE__ */ E(Fe, {
+          ownerState: i({}, P, {
+            state: n
+          }),
+          className: h.wrapperInner,
+          children: p
+        })
+      })
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (Z.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: e.func,
+  /**
+   * The content node to be collapsed.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The width (horizontal) or height (vertical) of the container when collapsed.
+   * @default '0px'
+   */
+  collapsedSize: e.oneOfType([e.number, e.string]),
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: Ne,
+  /**
+   * The transition timing function.
+   * You may specify a single easing or a object containing enter and exit values.
+   */
+  easing: e.oneOfType([e.shape({
+    enter: e.string,
+    exit: e.string
+  }), e.string]),
+  /**
+   * If `true`, the component will transition in.
+   */
+  in: e.bool,
+  /**
+   * @ignore
+   */
+  onEnter: e.func,
+  /**
+   * @ignore
+   */
+  onEntered: e.func,
+  /**
+   * @ignore
+   */
+  onEntering: e.func,
+  /**
+   * @ignore
+   */
+  onExit: e.func,
+  /**
+   * @ignore
+   */
+  onExited: e.func,
+  /**
+   * @ignore
+   */
+  onExiting: e.func,
+  /**
+   * The transition orientation.
+   * @default 'vertical'
+   */
+  orientation: e.oneOf(["horizontal", "vertical"]),
+  /**
+   * @ignore
+   */
+  style: e.object,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.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: e.oneOfType([e.oneOf(["auto"]), e.number, e.shape({
+    appear: e.number,
+    enter: e.number,
+    exit: e.number
+  })])
+});
+Z.muiSupportAuto = !0;
+const Ge = Z, ee = /* @__PURE__ */ l.createContext({});
+process.env.NODE_ENV !== "production" && (ee.displayName = "AccordionContext");
+const Ue = ["className", "elementType", "ownerState", "externalForwardedProps", "getSlotOwnerState", "internalForwardedProps"], qe = ["component", "slots", "slotProps"], Le = ["component"];
+function Be(o, t) {
+  const {
+    className: r,
+    elementType: s,
+    ownerState: a,
+    externalForwardedProps: p,
+    getSlotOwnerState: u,
+    internalForwardedProps: c
+  } = t, y = j(t, Ue), {
+    component: T,
+    slots: f = {
+      [o]: void 0
+    },
+    slotProps: S = {
+      [o]: void 0
+    }
+  } = p, w = j(p, qe), v = f[o] || s, C = Ee(S[o], a), b = Te(i({
+    className: r
+  }, y, {
+    externalForwardedProps: o === "root" ? w : void 0,
+    externalSlotProps: C
+  })), {
+    props: {
+      component: m
+    },
+    internalRef: d
+  } = b, R = j(b.props, Le), g = se(d, C == null ? void 0 : C.ref, t.ref), $ = u ? u(R) : {}, V = i({}, a, $), P = o === "root" ? m || T : m, h = Se(v, i({}, o === "root" && !T && !f[o] && c, o !== "root" && !f[o] && c, R, P && {
+    as: P
+  }, {
+    ref: g
+  }), V);
+  return Object.keys($).forEach((M) => {
+    delete h[M];
+  }), [v, h];
+}
+function He(o) {
+  return B("MuiAccordion", o);
+}
+const Je = H("MuiAccordion", ["root", "rounded", "expanded", "disabled", "gutters", "region"]), L = Je, Ke = ["children", "className", "defaultExpanded", "disabled", "disableGutters", "expanded", "onChange", "square", "slots", "slotProps", "TransitionComponent", "TransitionProps"], Qe = Y(), Xe = (o) => {
+  const {
+    classes: t,
+    square: r,
+    expanded: s,
+    disabled: a,
+    disableGutters: p
+  } = o;
+  return J({
+    root: ["root", !r && "rounded", s && "expanded", a && "disabled", !p && "gutters"],
+    region: ["region"]
+  }, He, t);
+}, Ye = O(Pe, {
+  name: "MuiAccordion",
+  slot: "Root",
+  overridesResolver: (o, t) => {
+    const {
+      ownerState: r
+    } = o;
+    return [{
+      [`& .${L.region}`]: t.region
+    }, t.root, !r.square && t.rounded, !r.disableGutters && t.gutters];
+  }
+})(({
+  theme: o
+}) => {
+  const t = {
+    duration: o.transitions.duration.shortest
+  };
+  return {
+    position: "relative",
+    transition: o.transitions.create(["margin"], t),
+    overflowAnchor: "none",
+    // Keep the same scrolling position
+    "&::before": {
+      position: "absolute",
+      left: 0,
+      top: -1,
+      right: 0,
+      height: 1,
+      content: '""',
+      opacity: 1,
+      backgroundColor: (o.vars || o).palette.divider,
+      transition: o.transitions.create(["opacity", "background-color"], t)
+    },
+    "&:first-of-type": {
+      "&::before": {
+        display: "none"
+      }
+    },
+    [`&.${L.expanded}`]: {
+      "&::before": {
+        opacity: 0
+      },
+      "&:first-of-type": {
+        marginTop: 0
+      },
+      "&:last-of-type": {
+        marginBottom: 0
+      },
+      "& + &": {
+        "&::before": {
+          display: "none"
+        }
+      }
+    },
+    [`&.${L.disabled}`]: {
+      backgroundColor: (o.vars || o).palette.action.disabledBackground
+    }
+  };
+}, ({
+  theme: o
+}) => ({
+  variants: [{
+    props: (t) => !t.square,
+    style: {
+      borderRadius: 0,
+      "&:first-of-type": {
+        borderTopLeftRadius: (o.vars || o).shape.borderRadius,
+        borderTopRightRadius: (o.vars || o).shape.borderRadius
+      },
+      "&:last-of-type": {
+        borderBottomLeftRadius: (o.vars || o).shape.borderRadius,
+        borderBottomRightRadius: (o.vars || o).shape.borderRadius,
+        // Fix a rendering issue on Edge
+        "@supports (-ms-ime-align: auto)": {
+          borderBottomLeftRadius: 0,
+          borderBottomRightRadius: 0
+        }
+      }
+    }
+  }, {
+    props: (t) => !t.disableGutters,
+    style: {
+      [`&.${L.expanded}`]: {
+        margin: "16px 0"
+      }
+    }
+  }]
+})), ie = /* @__PURE__ */ l.forwardRef(function(t, r) {
+  const s = Qe({
+    props: t,
+    name: "MuiAccordion"
+  }), {
+    children: a,
+    className: p,
+    defaultExpanded: u = !1,
+    disabled: c = !1,
+    disableGutters: y = !1,
+    expanded: T,
+    onChange: f,
+    square: S = !1,
+    slots: w = {},
+    slotProps: v = {},
+    TransitionComponent: C,
+    TransitionProps: b
+  } = s, m = j(s, Ke), [d, R] = Ae({
+    controlled: T,
+    default: u,
+    name: "Accordion",
+    state: "expanded"
+  }), g = l.useCallback((D) => {
+    R(!d), f && f(D, !d);
+  }, [d, f, R]), [$, ...V] = l.Children.toArray(a), P = l.useMemo(() => ({
+    expanded: d,
+    disabled: c,
+    disableGutters: y,
+    toggle: g
+  }), [d, c, y, g]), h = i({}, s, {
+    square: S,
+    disabled: c,
+    disableGutters: y,
+    expanded: d
+  }), M = Xe(h), K = i({
+    transition: C
+  }, w), A = i({
+    transition: b
+  }, v), [W, z] = Be("transition", {
+    elementType: Ge,
+    externalForwardedProps: {
+      slots: K,
+      slotProps: A
+    },
+    ownerState: h
+  });
+  return /* @__PURE__ */ re(Ye, i({
+    className: G(M.root, p),
+    ref: r,
+    ownerState: h,
+    square: S
+  }, m, {
+    children: [/* @__PURE__ */ E(ee.Provider, {
+      value: P,
+      children: $
+    }), /* @__PURE__ */ E(W, i({
+      in: d,
+      timeout: "auto"
+    }, z, {
+      children: /* @__PURE__ */ E("div", {
+        "aria-labelledby": $.props.id,
+        id: $.props["aria-controls"],
+        role: "region",
+        className: M.region,
+        children: V
+      })
+    }))]
+  }));
+});
+process.env.NODE_ENV !== "production" && (ie.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: $e(e.node.isRequired, (o) => {
+    const t = l.Children.toArray(o.children)[0];
+    return ve.isFragment(t) ? new Error("MUI: The Accordion doesn't accept a Fragment as a child. Consider providing an array instead.") : /* @__PURE__ */ l.isValidElement(t) ? null : new Error("MUI: Expected the first child of Accordion to be a valid element.");
+  }),
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * If `true`, expands the accordion by default.
+   * @default false
+   */
+  defaultExpanded: e.bool,
+  /**
+   * If `true`, the component is disabled.
+   * @default false
+   */
+  disabled: e.bool,
+  /**
+   * If `true`, it removes the margin between two expanded accordion items and the increase of height.
+   * @default false
+   */
+  disableGutters: e.bool,
+  /**
+   * If `true`, expands the accordion, otherwise collapse it.
+   * Setting this prop enables control over the accordion.
+   */
+  expanded: e.bool,
+  /**
+   * Callback fired when the expand/collapse state is changed.
+   *
+   * @param {React.SyntheticEvent} event The event source of the callback. **Warning**: This is a generic event not a change event.
+   * @param {boolean} expanded The `expanded` state of the accordion.
+   */
+  onChange: e.func,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    transition: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    transition: e.elementType
+  }),
+  /**
+   * If `true`, rounded corners are disabled.
+   * @default false
+   */
+  square: e.bool,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object]),
+  /**
+   * The component used for the transition.
+   * [Follow this guide](/material-ui/transitions/#transitioncomponent-prop) to learn more about the requirements for this component.
+   * @deprecated Use `slots.transition` instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   */
+  TransitionComponent: e.elementType,
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](https://reactcommunity.org/react-transition-group/transition/) component.
+   * @deprecated Use `slotProps.transition` instead. This prop will be removed in v7. [How to migrate](/material-ui/migration/migrating-from-deprecated-apis/).
+   */
+  TransitionProps: e.object
+});
+const So = ie;
+function Ze(o) {
+  return B("MuiAccordionDetails", o);
+}
+H("MuiAccordionDetails", ["root"]);
+const eo = ["className"], oo = Y(), to = (o) => {
+  const {
+    classes: t
+  } = o;
+  return J({
+    root: ["root"]
+  }, Ze, t);
+}, no = O("div", {
+  name: "MuiAccordionDetails",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})(({
+  theme: o
+}) => ({
+  padding: o.spacing(1, 2, 2)
+})), ae = /* @__PURE__ */ l.forwardRef(function(t, r) {
+  const s = oo({
+    props: t,
+    name: "MuiAccordionDetails"
+  }), {
+    className: a
+  } = s, p = j(s, eo), u = s, c = to(u);
+  return /* @__PURE__ */ E(no, i({
+    className: G(c.root, a),
+    ref: r,
+    ownerState: u
+  }, p));
+});
+process.env.NODE_ENV !== "production" && (ae.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: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+const wo = ae;
+function ro(o) {
+  return B("MuiAccordionSummary", o);
+}
+const so = H("MuiAccordionSummary", ["root", "expanded", "focusVisible", "disabled", "gutters", "contentGutters", "content", "expandIconWrapper"]), I = so, io = ["children", "className", "expandIcon", "focusVisibleClassName", "onClick"], ao = Y(), co = (o) => {
+  const {
+    classes: t,
+    expanded: r,
+    disabled: s,
+    disableGutters: a
+  } = o;
+  return J({
+    root: ["root", r && "expanded", s && "disabled", !a && "gutters"],
+    focusVisible: ["focusVisible"],
+    content: ["content", r && "expanded", !a && "contentGutters"],
+    expandIconWrapper: ["expandIconWrapper", r && "expanded"]
+  }, ro, t);
+}, lo = O(Oe, {
+  name: "MuiAccordionSummary",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})(({
+  theme: o
+}) => {
+  const t = {
+    duration: o.transitions.duration.shortest
+  };
+  return {
+    display: "flex",
+    minHeight: 48,
+    padding: o.spacing(0, 2),
+    transition: o.transitions.create(["min-height", "background-color"], t),
+    [`&.${I.focusVisible}`]: {
+      backgroundColor: (o.vars || o).palette.action.focus
+    },
+    [`&.${I.disabled}`]: {
+      opacity: (o.vars || o).palette.action.disabledOpacity
+    },
+    [`&:hover:not(.${I.disabled})`]: {
+      cursor: "pointer"
+    },
+    variants: [{
+      props: (r) => !r.disableGutters,
+      style: {
+        [`&.${I.expanded}`]: {
+          minHeight: 64
+        }
+      }
+    }]
+  };
+}), po = O("div", {
+  name: "MuiAccordionSummary",
+  slot: "Content",
+  overridesResolver: (o, t) => t.content
+})(({
+  theme: o
+}) => ({
+  display: "flex",
+  flexGrow: 1,
+  margin: "12px 0",
+  variants: [{
+    props: (t) => !t.disableGutters,
+    style: {
+      transition: o.transitions.create(["margin"], {
+        duration: o.transitions.duration.shortest
+      }),
+      [`&.${I.expanded}`]: {
+        margin: "20px 0"
+      }
+    }
+  }]
+})), uo = O("div", {
+  name: "MuiAccordionSummary",
+  slot: "ExpandIconWrapper",
+  overridesResolver: (o, t) => t.expandIconWrapper
+})(({
+  theme: o
+}) => ({
+  display: "flex",
+  color: (o.vars || o).palette.action.active,
+  transform: "rotate(0deg)",
+  transition: o.transitions.create("transform", {
+    duration: o.transitions.duration.shortest
+  }),
+  [`&.${I.expanded}`]: {
+    transform: "rotate(180deg)"
+  }
+})), ce = /* @__PURE__ */ l.forwardRef(function(t, r) {
+  const s = ao({
+    props: t,
+    name: "MuiAccordionSummary"
+  }), {
+    children: a,
+    className: p,
+    expandIcon: u,
+    focusVisibleClassName: c,
+    onClick: y
+  } = s, T = j(s, io), {
+    disabled: f = !1,
+    disableGutters: S,
+    expanded: w,
+    toggle: v
+  } = l.useContext(ee), C = (d) => {
+    v && v(d), y && y(d);
+  }, b = i({}, s, {
+    expanded: w,
+    disabled: f,
+    disableGutters: S
+  }), m = co(b);
+  return /* @__PURE__ */ re(lo, i({
+    focusRipple: !1,
+    disableRipple: !0,
+    disabled: f,
+    component: "div",
+    "aria-expanded": w,
+    className: G(m.root, p),
+    focusVisibleClassName: G(m.focusVisible, c),
+    onClick: C,
+    ref: r,
+    ownerState: b
+  }, T, {
+    children: [/* @__PURE__ */ E(po, {
+      className: m.content,
+      ownerState: b,
+      children: a
+    }), u && /* @__PURE__ */ E(uo, {
+      className: m.expandIconWrapper,
+      ownerState: b,
+      children: u
+    })]
+  }));
+});
+process.env.NODE_ENV !== "production" && (ce.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: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The icon to display as the expand indicator.
+   */
+  expandIcon: e.node,
+  /**
+   * This prop can help identify which element has keyboard focus.
+   * The class name will be applied when the element gains the focus through keyboard interaction.
+   * It's a polyfill for the [CSS :focus-visible selector](https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo).
+   * The rationale for using this feature [is explained here](https://github.com/WICG/focus-visible/blob/HEAD/explainer.md).
+   * A [polyfill can be used](https://github.com/WICG/focus-visible) to apply a `focus-visible` class to other components
+   * if needed.
+   */
+  focusVisibleClassName: e.string,
+  /**
+   * @ignore
+   */
+  onClick: e.func,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+});
+const Ro = ce;
+export {
+  So as A,
+  Ro as a,
+  wo as b,
+  De as d
+};