@hybridcore/ui 1.6.13 → 1.6.16

package/dist/AccordionSummary-DUtr16g6.js

@@ -0,0 +1,781 @@
+import { a as i, _ as B } from "./extends-C3382pL0.js";
+import * as a from "react";
+import { r as le } from "./index-DH6qsPBn.js";
+import { P as e } from "./index-CblbdqjE.js";
+import { c as G } from "./clsx-OuTLNxxd.js";
+import { u as pe } from "./useSlot-u4t0X96G.js";
+import { g as q, a as F, s as T, u as H, j as ue, c as J } from "./generateUtilityClasses-Cc-owZ4J.js";
+import { jsx as g, jsxs as te } from "react/jsx-runtime";
+import { T as fe, u as me, g as oe, P as ge } from "./Paper-B1HV8GyO.js";
+import { u as be } from "./useControlled-BYdyS7Pn.js";
+import { e as he, u as xe, f as ye, c as Ce } from "./TransitionGroupContext-Ja2CgIob.js";
+import { B as ve } from "./ButtonBase-DObmf4Q_.js";
+function Ee(o) {
+  return F("MuiCollapse", o);
+}
+q("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const Te = ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"], Re = (o) => {
+  const {
+    orientation: t,
+    classes: r
+  } = o, s = {
+    root: ["root", `${t}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${t}`],
+    wrapperInner: ["wrapperInner", `${t}`]
+  };
+  return J(s, Ee, r);
+}, we = T("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"
+})), Ae = T("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%"
+})), Se = T("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (o, t) => t.wrapperInner
+})(({
+  ownerState: o
+}) => i({
+  width: "100%"
+}, o.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), Y = /* @__PURE__ */ a.forwardRef(function(t, r) {
+  const s = H({
+    props: t,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: c,
+    children: u,
+    className: f,
+    collapsedSize: l = "0px",
+    component: v,
+    easing: N,
+    in: b,
+    onEnter: R,
+    onEntered: w,
+    onEntering: A,
+    onExit: P,
+    onExited: E,
+    onExiting: h,
+    orientation: d = "vertical",
+    style: $,
+    timeout: m = ue.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: j = fe
+  } = s, K = B(s, Te), O = i({}, s, {
+    orientation: d,
+    collapsedSize: l
+  }), x = Re(O), I = me(), Q = he(), y = a.useRef(null), V = a.useRef(), D = typeof l == "number" ? `${l}px` : l, S = d === "horizontal", W = S ? "width" : "height", U = a.useRef(null), ne = xe(r, U), M = (n) => (p) => {
+    if (n) {
+      const C = U.current;
+      p === void 0 ? n(C) : n(C, p);
+    }
+  }, X = () => y.current ? y.current[S ? "clientWidth" : "clientHeight"] : 0, re = M((n, p) => {
+    y.current && S && (y.current.style.position = "absolute"), n.style[W] = D, R && R(n, p);
+  }), se = M((n, p) => {
+    const C = X();
+    y.current && S && (y.current.style.position = "");
+    const {
+      duration: k,
+      easing: _
+    } = oe({
+      style: $,
+      timeout: m,
+      easing: N
+    }, {
+      mode: "enter"
+    });
+    if (m === "auto") {
+      const ee = I.transitions.getAutoHeightDuration(C);
+      n.style.transitionDuration = `${ee}ms`, V.current = ee;
+    } else
+      n.style.transitionDuration = typeof k == "string" ? k : `${k}ms`;
+    n.style[W] = `${C}px`, n.style.transitionTimingFunction = _, A && A(n, p);
+  }), ie = M((n, p) => {
+    n.style[W] = "auto", w && w(n, p);
+  }), ae = M((n) => {
+    n.style[W] = `${X()}px`, P && P(n);
+  }), ce = M(E), de = M((n) => {
+    const p = X(), {
+      duration: C,
+      easing: k
+    } = oe({
+      style: $,
+      timeout: m,
+      easing: N
+    }, {
+      mode: "exit"
+    });
+    if (m === "auto") {
+      const _ = I.transitions.getAutoHeightDuration(p);
+      n.style.transitionDuration = `${_}ms`, V.current = _;
+    } else
+      n.style.transitionDuration = typeof C == "string" ? C : `${C}ms`;
+    n.style[W] = D, n.style.transitionTimingFunction = k, h && h(n);
+  });
+  return /* @__PURE__ */ g(j, i({
+    in: b,
+    onEnter: re,
+    onEntered: ie,
+    onEntering: se,
+    onExit: ae,
+    onExited: ce,
+    onExiting: de,
+    addEndListener: (n) => {
+      m === "auto" && Q.start(V.current || 0, n), c && c(U.current, n);
+    },
+    nodeRef: U,
+    timeout: m === "auto" ? null : m
+  }, K, {
+    children: (n, p) => /* @__PURE__ */ g(we, i({
+      as: v,
+      className: G(x.root, f, {
+        entered: x.entered,
+        exited: !b && D === "0px" && x.hidden
+      }[n]),
+      style: i({
+        [S ? "minWidth" : "minHeight"]: D
+      }, $),
+      ref: ne
+    }, p, {
+      // `ownerState` is set after `childProps` to override any existing `ownerState` property in `childProps`
+      // that might have been forwarded from the Transition component.
+      ownerState: i({}, O, {
+        state: n
+      }),
+      children: /* @__PURE__ */ g(Ae, {
+        ownerState: i({}, O, {
+          state: n
+        }),
+        className: x.wrapper,
+        ref: y,
+        children: /* @__PURE__ */ g(Se, {
+          ownerState: i({}, O, {
+            state: n
+          }),
+          className: x.wrapperInner,
+          children: u
+        })
+      })
+    }))
+  }));
+});
+process.env.NODE_ENV !== "production" && (Y.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: ye,
+  /**
+   * 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
+  })])
+});
+Y.muiSupportAuto = !0;
+const Z = /* @__PURE__ */ a.createContext({});
+process.env.NODE_ENV !== "production" && (Z.displayName = "AccordionContext");
+function Ne(o) {
+  return F("MuiAccordion", o);
+}
+const L = q("MuiAccordion", ["root", "rounded", "expanded", "disabled", "gutters", "region"]), Pe = ["children", "className", "defaultExpanded", "disabled", "disableGutters", "expanded", "onChange", "square", "slots", "slotProps", "TransitionComponent", "TransitionProps"], $e = (o) => {
+  const {
+    classes: t,
+    square: r,
+    expanded: s,
+    disabled: c,
+    disableGutters: u
+  } = o;
+  return J({
+    root: ["root", !r && "rounded", s && "expanded", c && "disabled", !u && "gutters"],
+    region: ["region"]
+  }, Ne, t);
+}, Oe = T(ge, {
+  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"
+      }
+    }
+  }]
+})), De = /* @__PURE__ */ a.forwardRef(function(t, r) {
+  const s = H({
+    props: t,
+    name: "MuiAccordion"
+  }), {
+    children: c,
+    className: u,
+    defaultExpanded: f = !1,
+    disabled: l = !1,
+    disableGutters: v = !1,
+    expanded: N,
+    onChange: b,
+    square: R = !1,
+    slots: w = {},
+    slotProps: A = {},
+    TransitionComponent: P,
+    TransitionProps: E
+  } = s, h = B(s, Pe), [d, $] = be({
+    controlled: N,
+    default: f,
+    name: "Accordion",
+    state: "expanded"
+  }), m = a.useCallback((S) => {
+    $(!d), b && b(S, !d);
+  }, [d, b, $]), [j, ...K] = a.Children.toArray(c), O = a.useMemo(() => ({
+    expanded: d,
+    disabled: l,
+    disableGutters: v,
+    toggle: m
+  }), [d, l, v, m]), x = i({}, s, {
+    square: R,
+    disabled: l,
+    disableGutters: v,
+    expanded: d
+  }), I = $e(x), Q = i({
+    transition: P
+  }, w), y = i({
+    transition: E
+  }, A), [V, D] = pe("transition", {
+    elementType: Y,
+    externalForwardedProps: {
+      slots: Q,
+      slotProps: y
+    },
+    ownerState: x
+  });
+  return /* @__PURE__ */ te(Oe, i({
+    className: G(I.root, u),
+    ref: r,
+    ownerState: x,
+    square: R
+  }, h, {
+    children: [/* @__PURE__ */ g(Z.Provider, {
+      value: O,
+      children: j
+    }), /* @__PURE__ */ g(V, i({
+      in: d,
+      timeout: "auto"
+    }, D, {
+      children: /* @__PURE__ */ g("div", {
+        "aria-labelledby": j.props.id,
+        id: j.props["aria-controls"],
+        role: "region",
+        className: I.region,
+        children: K
+      })
+    }))]
+  }));
+});
+process.env.NODE_ENV !== "production" && (De.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: Ce(e.node.isRequired, (o) => {
+    const t = a.Children.toArray(o.children)[0];
+    return le.isFragment(t) ? new Error("MUI: The Accordion doesn't accept a Fragment as a child. Consider providing an array instead.") : /* @__PURE__ */ a.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
+});
+function Me(o) {
+  return F("MuiAccordionDetails", o);
+}
+q("MuiAccordionDetails", ["root"]);
+const ze = ["className"], je = (o) => {
+  const {
+    classes: t
+  } = o;
+  return J({
+    root: ["root"]
+  }, Me, t);
+}, Ie = T("div", {
+  name: "MuiAccordionDetails",
+  slot: "Root",
+  overridesResolver: (o, t) => t.root
+})(({
+  theme: o
+}) => ({
+  padding: o.spacing(1, 2, 2)
+})), Ve = /* @__PURE__ */ a.forwardRef(function(t, r) {
+  const s = H({
+    props: t,
+    name: "MuiAccordionDetails"
+  }), {
+    className: c
+  } = s, u = B(s, ze), f = s, l = je(f);
+  return /* @__PURE__ */ g(Ie, i({
+    className: G(l.root, c),
+    ref: r,
+    ownerState: f
+  }, u));
+});
+process.env.NODE_ENV !== "production" && (Ve.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])
+});
+function We(o) {
+  return F("MuiAccordionSummary", o);
+}
+const z = q("MuiAccordionSummary", ["root", "expanded", "focusVisible", "disabled", "gutters", "contentGutters", "content", "expandIconWrapper"]), ke = ["children", "className", "expandIcon", "focusVisibleClassName", "onClick"], Ge = (o) => {
+  const {
+    classes: t,
+    expanded: r,
+    disabled: s,
+    disableGutters: c
+  } = o;
+  return J({
+    root: ["root", r && "expanded", s && "disabled", !c && "gutters"],
+    focusVisible: ["focusVisible"],
+    content: ["content", r && "expanded", !c && "contentGutters"],
+    expandIconWrapper: ["expandIconWrapper", r && "expanded"]
+  }, We, t);
+}, Ue = T(ve, {
+  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),
+    [`&.${z.focusVisible}`]: {
+      backgroundColor: (o.vars || o).palette.action.focus
+    },
+    [`&.${z.disabled}`]: {
+      opacity: (o.vars || o).palette.action.disabledOpacity
+    },
+    [`&:hover:not(.${z.disabled})`]: {
+      cursor: "pointer"
+    },
+    variants: [{
+      props: (r) => !r.disableGutters,
+      style: {
+        [`&.${z.expanded}`]: {
+          minHeight: 64
+        }
+      }
+    }]
+  };
+}), _e = T("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
+      }),
+      [`&.${z.expanded}`]: {
+        margin: "20px 0"
+      }
+    }
+  }]
+})), Le = T("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
+  }),
+  [`&.${z.expanded}`]: {
+    transform: "rotate(180deg)"
+  }
+})), Be = /* @__PURE__ */ a.forwardRef(function(t, r) {
+  const s = H({
+    props: t,
+    name: "MuiAccordionSummary"
+  }), {
+    children: c,
+    className: u,
+    expandIcon: f,
+    focusVisibleClassName: l,
+    onClick: v
+  } = s, N = B(s, ke), {
+    disabled: b = !1,
+    disableGutters: R,
+    expanded: w,
+    toggle: A
+  } = a.useContext(Z), P = (d) => {
+    A && A(d), v && v(d);
+  }, E = i({}, s, {
+    expanded: w,
+    disabled: b,
+    disableGutters: R
+  }), h = Ge(E);
+  return /* @__PURE__ */ te(Ue, i({
+    focusRipple: !1,
+    disableRipple: !0,
+    disabled: b,
+    component: "div",
+    "aria-expanded": w,
+    className: G(h.root, u),
+    focusVisibleClassName: G(h.focusVisible, l),
+    onClick: P,
+    ref: r,
+    ownerState: E
+  }, N, {
+    children: [/* @__PURE__ */ g(_e, {
+      className: h.content,
+      ownerState: E,
+      children: c
+    }), f && /* @__PURE__ */ g(Le, {
+      className: h.expandIconWrapper,
+      ownerState: E,
+      children: f
+    })]
+  }));
+});
+process.env.NODE_ENV !== "production" && (Be.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])
+});
+export {
+  De as A,
+  Be as a,
+  Ve as b
+};