kdpa-components 0.0.11 → 0.0.12

package/dist/components/Accordion/index.js

@@ -1,9 +1,1127 @@
-import { K as c, a as d, b as m } from "../../KdpaAccordions-0a0aa0f8.js";
-import "../../ButtonBase-5ef58bca.js";
-import "react";
-import "react-dom";
+import { P as e, _ as Ne, a as W, T as ue, g as Q, b as Y, s as N, c as p, u as Z, d as Se, e as Ae, j as h, f as P, h as De, i as ee, k as Oe, l as we, m as $e, r as Me, B as je } from "../../ButtonBase-5ef58bca.js";
+import * as u from "react";
+import X from "react";
+import K from "react-dom";
+function Ie({
+  controlled: t,
+  default: n,
+  name: i,
+  state: s = "value"
+}) {
+  const {
+    current: r
+  } = u.useRef(t !== void 0), [o, a] = u.useState(n), c = r ? t : o;
+  if (process.env.NODE_ENV !== "production") {
+    u.useEffect(() => {
+      r !== (t !== void 0) && console.error([`MUI: A component is changing the ${r ? "" : "un"}controlled ${s} state of ${i} to be ${r ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${i} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [s, i, t]);
+    const {
+      current: f
+    } = u.useRef(n);
+    u.useEffect(() => {
+      !r && f !== n && console.error([`MUI: A component is changing the default ${s} state of an uncontrolled ${i} after being initialized. To suppress this warning opt to use a controlled ${i}.`].join(`
+`));
+    }, [JSON.stringify(n)]);
+  }
+  const l = u.useCallback((f) => {
+    r || a(f);
+  }, []);
+  return [c, l];
+}
+const de = {
+  disabled: !1
+};
+var ke = process.env.NODE_ENV !== "production" ? e.oneOfType([e.number, e.shape({
+  enter: e.number,
+  exit: e.number,
+  appear: e.number
+}).isRequired]) : null;
+process.env.NODE_ENV !== "production" && e.oneOfType([e.string, e.shape({
+  enter: e.string,
+  exit: e.string,
+  active: e.string
+}), e.shape({
+  enter: e.string,
+  enterDone: e.string,
+  enterActive: e.string,
+  exit: e.string,
+  exitDone: e.string,
+  exitActive: e.string
+})]);
+var Ue = function(n) {
+  return n.scrollTop;
+}, L = "unmounted", $ = "exited", M = "entering", U = "entered", re = "exiting", T = /* @__PURE__ */ function(t) {
+  Ne(n, t);
+  function n(s, r) {
+    var o;
+    o = t.call(this, s, r) || this;
+    var a = r, c = a && !a.isMounting ? s.enter : s.appear, l;
+    return o.appearStatus = null, s.in ? c ? (l = $, o.appearStatus = M) : l = U : s.unmountOnExit || s.mountOnEnter ? l = L : l = $, o.state = {
+      status: l
+    }, o.nextCallback = null, o;
+  }
+  n.getDerivedStateFromProps = function(r, o) {
+    var a = r.in;
+    return a && o.status === L ? {
+      status: $
+    } : null;
+  };
+  var i = n.prototype;
+  return i.componentDidMount = function() {
+    this.updateStatus(!0, this.appearStatus);
+  }, i.componentDidUpdate = function(r) {
+    var o = null;
+    if (r !== this.props) {
+      var a = this.state.status;
+      this.props.in ? a !== M && a !== U && (o = M) : (a === M || a === U) && (o = re);
+    }
+    this.updateStatus(!1, o);
+  }, i.componentWillUnmount = function() {
+    this.cancelNextCallback();
+  }, i.getTimeouts = function() {
+    var r = this.props.timeout, o, a, c;
+    return o = a = c = r, r != null && typeof r != "number" && (o = r.exit, a = r.enter, c = r.appear !== void 0 ? r.appear : a), {
+      exit: o,
+      enter: a,
+      appear: c
+    };
+  }, i.updateStatus = function(r, o) {
+    if (r === void 0 && (r = !1), o !== null)
+      if (this.cancelNextCallback(), o === M) {
+        if (this.props.unmountOnExit || this.props.mountOnEnter) {
+          var a = this.props.nodeRef ? this.props.nodeRef.current : K.findDOMNode(this);
+          a && Ue(a);
+        }
+        this.performEnter(r);
+      } else
+        this.performExit();
+    else
+      this.props.unmountOnExit && this.state.status === $ && this.setState({
+        status: L
+      });
+  }, i.performEnter = function(r) {
+    var o = this, a = this.props.enter, c = this.context ? this.context.isMounting : r, l = this.props.nodeRef ? [c] : [K.findDOMNode(this), c], f = l[0], m = l[1], g = this.getTimeouts(), v = c ? g.appear : g.enter;
+    if (!r && !a || de.disabled) {
+      this.safeSetState({
+        status: U
+      }, function() {
+        o.props.onEntered(f);
+      });
+      return;
+    }
+    this.props.onEnter(f, m), this.safeSetState({
+      status: M
+    }, function() {
+      o.props.onEntering(f, m), o.onTransitionEnd(v, function() {
+        o.safeSetState({
+          status: U
+        }, function() {
+          o.props.onEntered(f, m);
+        });
+      });
+    });
+  }, i.performExit = function() {
+    var r = this, o = this.props.exit, a = this.getTimeouts(), c = this.props.nodeRef ? void 0 : K.findDOMNode(this);
+    if (!o || de.disabled) {
+      this.safeSetState({
+        status: $
+      }, function() {
+        r.props.onExited(c);
+      });
+      return;
+    }
+    this.props.onExit(c), this.safeSetState({
+      status: re
+    }, function() {
+      r.props.onExiting(c), r.onTransitionEnd(a.exit, function() {
+        r.safeSetState({
+          status: $
+        }, function() {
+          r.props.onExited(c);
+        });
+      });
+    });
+  }, i.cancelNextCallback = function() {
+    this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
+  }, i.safeSetState = function(r, o) {
+    o = this.setNextCallback(o), this.setState(r, o);
+  }, i.setNextCallback = function(r) {
+    var o = this, a = !0;
+    return this.nextCallback = function(c) {
+      a && (a = !1, o.nextCallback = null, r(c));
+    }, this.nextCallback.cancel = function() {
+      a = !1;
+    }, this.nextCallback;
+  }, i.onTransitionEnd = function(r, o) {
+    this.setNextCallback(o);
+    var a = this.props.nodeRef ? this.props.nodeRef.current : K.findDOMNode(this), c = r == null && !this.props.addEndListener;
+    if (!a || c) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+    if (this.props.addEndListener) {
+      var l = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], f = l[0], m = l[1];
+      this.props.addEndListener(f, m);
+    }
+    r != null && setTimeout(this.nextCallback, r);
+  }, i.render = function() {
+    var r = this.state.status;
+    if (r === L)
+      return null;
+    var o = this.props, a = o.children;
+    o.in, o.mountOnEnter, o.unmountOnExit, o.appear, o.enter, o.exit, o.timeout, o.addEndListener, o.onEnter, o.onEntering, o.onEntered, o.onExit, o.onExiting, o.onExited, o.nodeRef;
+    var c = W(o, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
+    return (
+      // allows for nested Transitions
+      /* @__PURE__ */ X.createElement(ue.Provider, {
+        value: null
+      }, typeof a == "function" ? a(r, c) : X.cloneElement(X.Children.only(a), c))
+    );
+  }, n;
+}(X.Component);
+T.contextType = ue;
+T.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: e.shape({
+    current: typeof Element > "u" ? e.any : function(t, n, i, s, r, o) {
+      var a = t[n];
+      return e.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(t, n, i, s, r, o);
+    }
+  }),
+  /**
+   * 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: e.oneOfType([e.func.isRequired, e.element.isRequired]).isRequired,
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: e.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: e.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: e.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: e.bool,
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: e.bool,
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: e.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(n) {
+    var i = ke;
+    n.addEndListener || (i = i.isRequired);
+    for (var s = arguments.length, r = new Array(s > 1 ? s - 1 : 0), o = 1; o < s; o++)
+      r[o - 1] = arguments[o];
+    return i.apply(void 0, [n].concat(r));
+  },
+  /**
+   * 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: e.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: e.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: e.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: e.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: e.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: e.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: e.func
+} : {};
+function k() {
+}
+T.defaultProps = {
+  in: !1,
+  mountOnEnter: !1,
+  unmountOnExit: !1,
+  appear: !1,
+  enter: !0,
+  exit: !0,
+  onEnter: k,
+  onEntering: k,
+  onEntered: k,
+  onExit: k,
+  onExiting: k,
+  onExited: k
+};
+T.UNMOUNTED = L;
+T.EXITED = $;
+T.ENTERING = M;
+T.ENTERED = U;
+T.EXITING = re;
+const Ve = T;
+function le(t, n) {
+  var i, s;
+  const {
+    timeout: r,
+    easing: o,
+    style: a = {}
+  } = t;
+  return {
+    duration: (i = a.transitionDuration) != null ? i : typeof r == "number" ? r : r[n.mode] || 0,
+    easing: (s = a.transitionTimingFunction) != null ? s : typeof o == "object" ? o[n.mode] : o,
+    delay: a.transitionDelay
+  };
+}
+function ze(t) {
+  return Q("MuiCollapse", t);
+}
+Y("MuiCollapse", ["root", "horizontal", "vertical", "entered", "hidden", "wrapper", "wrapperInner"]);
+const _e = ["addEndListener", "children", "className", "collapsedSize", "component", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "orientation", "style", "timeout", "TransitionComponent"], Ge = (t) => {
+  const {
+    orientation: n,
+    classes: i
+  } = t, s = {
+    root: ["root", `${n}`],
+    entered: ["entered"],
+    hidden: ["hidden"],
+    wrapper: ["wrapper", `${n}`],
+    wrapperInner: ["wrapperInner", `${n}`]
+  };
+  return ee(s, ze, i);
+}, Le = N("div", {
+  name: "MuiCollapse",
+  slot: "Root",
+  overridesResolver: (t, n) => {
+    const {
+      ownerState: i
+    } = t;
+    return [n.root, n[i.orientation], i.state === "entered" && n.entered, i.state === "exited" && !i.in && i.collapsedSize === "0px" && n.hidden];
+  }
+})(({
+  theme: t,
+  ownerState: n
+}) => p({
+  height: 0,
+  overflow: "hidden",
+  transition: t.transitions.create("height")
+}, n.orientation === "horizontal" && {
+  height: "auto",
+  width: 0,
+  transition: t.transitions.create("width")
+}, n.state === "entered" && p({
+  height: "auto",
+  overflow: "visible"
+}, n.orientation === "horizontal" && {
+  width: "auto"
+}), n.state === "exited" && !n.in && n.collapsedSize === "0px" && {
+  visibility: "hidden"
+})), Pe = N("div", {
+  name: "MuiCollapse",
+  slot: "Wrapper",
+  overridesResolver: (t, n) => n.wrapper
+})(({
+  ownerState: t
+}) => p({
+  // Hack to get children with a negative margin to not falsify the height computation.
+  display: "flex",
+  width: "100%"
+}, t.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), We = N("div", {
+  name: "MuiCollapse",
+  slot: "WrapperInner",
+  overridesResolver: (t, n) => n.wrapperInner
+})(({
+  ownerState: t
+}) => p({
+  width: "100%"
+}, t.orientation === "horizontal" && {
+  width: "auto",
+  height: "100%"
+})), ie = /* @__PURE__ */ u.forwardRef(function(n, i) {
+  const s = Z({
+    props: n,
+    name: "MuiCollapse"
+  }), {
+    addEndListener: r,
+    children: o,
+    className: a,
+    collapsedSize: c = "0px",
+    component: l,
+    easing: f,
+    in: m,
+    onEnter: g,
+    onEntered: v,
+    onEntering: S,
+    onExit: j,
+    onExited: x,
+    onExiting: b,
+    orientation: R = "vertical",
+    style: A,
+    timeout: y = Oe.standard,
+    // eslint-disable-next-line react/prop-types
+    TransitionComponent: te = Ve
+  } = s, q = W(s, _e), D = p({}, s, {
+    orientation: R,
+    collapsedSize: c
+  }), O = Ge(D), se = Se(), ae = u.useRef(), w = u.useRef(null), ne = u.useRef(), F = typeof c == "number" ? `${c}px` : c, z = R === "horizontal", _ = z ? "width" : "height";
+  u.useEffect(() => () => {
+    clearTimeout(ae.current);
+  }, []);
+  const B = u.useRef(null), Ee = Ae(i, B), I = (d) => (E) => {
+    if (d) {
+      const C = B.current;
+      E === void 0 ? d(C) : d(C, E);
+    }
+  }, oe = () => w.current ? w.current[z ? "clientWidth" : "clientHeight"] : 0, ge = I((d, E) => {
+    w.current && z && (w.current.style.position = "absolute"), d.style[_] = F, g && g(d, E);
+  }), be = I((d, E) => {
+    const C = oe();
+    w.current && z && (w.current.style.position = "");
+    const {
+      duration: G,
+      easing: H
+    } = le({
+      style: A,
+      timeout: y,
+      easing: f
+    }, {
+      mode: "enter"
+    });
+    if (y === "auto") {
+      const ce = se.transitions.getAutoHeightDuration(C);
+      d.style.transitionDuration = `${ce}ms`, ne.current = ce;
+    } else
+      d.style.transitionDuration = typeof G == "string" ? G : `${G}ms`;
+    d.style[_] = `${C}px`, d.style.transitionTimingFunction = H, S && S(d, E);
+  }), ve = I((d, E) => {
+    d.style[_] = "auto", v && v(d, E);
+  }), ye = I((d) => {
+    d.style[_] = `${oe()}px`, j && j(d);
+  }), Ce = I(x), Te = I((d) => {
+    const E = oe(), {
+      duration: C,
+      easing: G
+    } = le({
+      style: A,
+      timeout: y,
+      easing: f
+    }, {
+      mode: "exit"
+    });
+    if (y === "auto") {
+      const H = se.transitions.getAutoHeightDuration(E);
+      d.style.transitionDuration = `${H}ms`, ne.current = H;
+    } else
+      d.style.transitionDuration = typeof C == "string" ? C : `${C}ms`;
+    d.style[_] = F, d.style.transitionTimingFunction = G, b && b(d);
+  }), Re = (d) => {
+    y === "auto" && (ae.current = setTimeout(d, ne.current || 0)), r && r(B.current, d);
+  };
+  return /* @__PURE__ */ h.jsx(te, p({
+    in: m,
+    onEnter: ge,
+    onEntered: ve,
+    onEntering: be,
+    onExit: ye,
+    onExited: Ce,
+    onExiting: Te,
+    addEndListener: Re,
+    nodeRef: B,
+    timeout: y === "auto" ? null : y
+  }, q, {
+    children: (d, E) => /* @__PURE__ */ h.jsx(Le, p({
+      as: l,
+      className: P(O.root, a, {
+        entered: O.entered,
+        exited: !m && F === "0px" && O.hidden
+      }[d]),
+      style: p({
+        [z ? "minWidth" : "minHeight"]: F
+      }, A),
+      ownerState: p({}, D, {
+        state: d
+      }),
+      ref: Ee
+    }, E, {
+      children: /* @__PURE__ */ h.jsx(Pe, {
+        ownerState: p({}, D, {
+          state: d
+        }),
+        className: O.wrapper,
+        ref: w,
+        children: /* @__PURE__ */ h.jsx(We, {
+          ownerState: p({}, D, {
+            state: d
+          }),
+          className: O.wrapperInner,
+          children: o
+        })
+      })
+    }))
+  }));
+});
+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 "yarn 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: De,
+  /**
+   * 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
+  })])
+});
+ie.muiSupportAuto = !0;
+const qe = ie, pe = /* @__PURE__ */ u.createContext({});
+process.env.NODE_ENV !== "production" && (pe.displayName = "AccordionContext");
+const fe = pe;
+function Fe(t) {
+  return Q("MuiAccordion", t);
+}
+const Be = Y("MuiAccordion", ["root", "rounded", "expanded", "disabled", "gutters", "region"]), J = Be, He = ["children", "className", "defaultExpanded", "disabled", "disableGutters", "expanded", "onChange", "square", "TransitionComponent", "TransitionProps"], Xe = (t) => {
+  const {
+    classes: n,
+    square: i,
+    expanded: s,
+    disabled: r,
+    disableGutters: o
+  } = t;
+  return ee({
+    root: ["root", !i && "rounded", s && "expanded", r && "disabled", !o && "gutters"],
+    region: ["region"]
+  }, Fe, n);
+}, Ke = N(we, {
+  name: "MuiAccordion",
+  slot: "Root",
+  overridesResolver: (t, n) => {
+    const {
+      ownerState: i
+    } = t;
+    return [{
+      [`& .${J.region}`]: n.region
+    }, n.root, !i.square && n.rounded, !i.disableGutters && n.gutters];
+  }
+})(({
+  theme: t
+}) => {
+  const n = {
+    duration: t.transitions.duration.shortest
+  };
+  return {
+    position: "relative",
+    transition: t.transitions.create(["margin"], n),
+    overflowAnchor: "none",
+    // Keep the same scrolling position
+    "&:before": {
+      position: "absolute",
+      left: 0,
+      top: -1,
+      right: 0,
+      height: 1,
+      content: '""',
+      opacity: 1,
+      backgroundColor: (t.vars || t).palette.divider,
+      transition: t.transitions.create(["opacity", "background-color"], n)
+    },
+    "&:first-of-type": {
+      "&:before": {
+        display: "none"
+      }
+    },
+    [`&.${J.expanded}`]: {
+      "&:before": {
+        opacity: 0
+      },
+      "&:first-of-type": {
+        marginTop: 0
+      },
+      "&:last-of-type": {
+        marginBottom: 0
+      },
+      "& + &": {
+        "&:before": {
+          display: "none"
+        }
+      }
+    },
+    [`&.${J.disabled}`]: {
+      backgroundColor: (t.vars || t).palette.action.disabledBackground
+    }
+  };
+}, ({
+  theme: t,
+  ownerState: n
+}) => p({}, !n.square && {
+  borderRadius: 0,
+  "&:first-of-type": {
+    borderTopLeftRadius: (t.vars || t).shape.borderRadius,
+    borderTopRightRadius: (t.vars || t).shape.borderRadius
+  },
+  "&:last-of-type": {
+    borderBottomLeftRadius: (t.vars || t).shape.borderRadius,
+    borderBottomRightRadius: (t.vars || t).shape.borderRadius,
+    // Fix a rendering issue on Edge
+    "@supports (-ms-ime-align: auto)": {
+      borderBottomLeftRadius: 0,
+      borderBottomRightRadius: 0
+    }
+  }
+}, !n.disableGutters && {
+  [`&.${J.expanded}`]: {
+    margin: "16px 0"
+  }
+})), me = /* @__PURE__ */ u.forwardRef(function(n, i) {
+  const s = Z({
+    props: n,
+    name: "MuiAccordion"
+  }), {
+    children: r,
+    className: o,
+    defaultExpanded: a = !1,
+    disabled: c = !1,
+    disableGutters: l = !1,
+    expanded: f,
+    onChange: m,
+    square: g = !1,
+    TransitionComponent: v = qe,
+    TransitionProps: S
+  } = s, j = W(s, He), [x, b] = Ie({
+    controlled: f,
+    default: a,
+    name: "Accordion",
+    state: "expanded"
+  }), R = u.useCallback((O) => {
+    b(!x), m && m(O, !x);
+  }, [x, m, b]), [A, ...y] = u.Children.toArray(r), te = u.useMemo(() => ({
+    expanded: x,
+    disabled: c,
+    disableGutters: l,
+    toggle: R
+  }), [x, c, l, R]), q = p({}, s, {
+    square: g,
+    disabled: c,
+    disableGutters: l,
+    expanded: x
+  }), D = Xe(q);
+  return /* @__PURE__ */ h.jsxs(Ke, p({
+    className: P(D.root, o),
+    ref: i,
+    ownerState: q,
+    square: g
+  }, j, {
+    children: [/* @__PURE__ */ h.jsx(fe.Provider, {
+      value: te,
+      children: A
+    }), /* @__PURE__ */ h.jsx(v, p({
+      in: x,
+      timeout: "auto"
+    }, S, {
+      children: /* @__PURE__ */ h.jsx("div", {
+        "aria-labelledby": A.props.id,
+        id: A.props["aria-controls"],
+        role: "region",
+        className: D.region,
+        children: y
+      })
+    }))]
+  }));
+});
+process.env.NODE_ENV !== "production" && (me.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn proptypes"     |
+  // ----------------------------------------------------------------------
+  /**
+   * The content of the component.
+   */
+  children: $e(e.node.isRequired, (t) => {
+    const n = u.Children.toArray(t.children)[0];
+    return Me.isFragment(n) ? new Error("MUI: The Accordion doesn't accept a Fragment as a child. Consider providing an array instead.") : /* @__PURE__ */ u.isValidElement(n) ? 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,
+  /**
+   * 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.
+   * @default Collapse
+   */
+  TransitionComponent: e.elementType,
+  /**
+   * Props applied to the transition element.
+   * By default, the element is based on this [`Transition`](http://reactcommunity.org/react-transition-group/transition/) component.
+   */
+  TransitionProps: e.object
+});
+const Je = me;
+function Qe(t) {
+  return Q("MuiAccordionSummary", t);
+}
+const Ye = Y("MuiAccordionSummary", ["root", "expanded", "focusVisible", "disabled", "gutters", "contentGutters", "content", "expandIconWrapper"]), V = Ye, Ze = ["children", "className", "expandIcon", "focusVisibleClassName", "onClick"], et = (t) => {
+  const {
+    classes: n,
+    expanded: i,
+    disabled: s,
+    disableGutters: r
+  } = t;
+  return ee({
+    root: ["root", i && "expanded", s && "disabled", !r && "gutters"],
+    focusVisible: ["focusVisible"],
+    content: ["content", i && "expanded", !r && "contentGutters"],
+    expandIconWrapper: ["expandIconWrapper", i && "expanded"]
+  }, Qe, n);
+}, tt = N(je, {
+  name: "MuiAccordionSummary",
+  slot: "Root",
+  overridesResolver: (t, n) => n.root
+})(({
+  theme: t,
+  ownerState: n
+}) => {
+  const i = {
+    duration: t.transitions.duration.shortest
+  };
+  return p({
+    display: "flex",
+    minHeight: 48,
+    padding: t.spacing(0, 2),
+    transition: t.transitions.create(["min-height", "background-color"], i),
+    [`&.${V.focusVisible}`]: {
+      backgroundColor: (t.vars || t).palette.action.focus
+    },
+    [`&.${V.disabled}`]: {
+      opacity: (t.vars || t).palette.action.disabledOpacity
+    },
+    [`&:hover:not(.${V.disabled})`]: {
+      cursor: "pointer"
+    }
+  }, !n.disableGutters && {
+    [`&.${V.expanded}`]: {
+      minHeight: 64
+    }
+  });
+}), nt = N("div", {
+  name: "MuiAccordionSummary",
+  slot: "Content",
+  overridesResolver: (t, n) => n.content
+})(({
+  theme: t,
+  ownerState: n
+}) => p({
+  display: "flex",
+  flexGrow: 1,
+  margin: "12px 0"
+}, !n.disableGutters && {
+  transition: t.transitions.create(["margin"], {
+    duration: t.transitions.duration.shortest
+  }),
+  [`&.${V.expanded}`]: {
+    margin: "20px 0"
+  }
+})), ot = N("div", {
+  name: "MuiAccordionSummary",
+  slot: "ExpandIconWrapper",
+  overridesResolver: (t, n) => n.expandIconWrapper
+})(({
+  theme: t
+}) => ({
+  display: "flex",
+  color: (t.vars || t).palette.action.active,
+  transform: "rotate(0deg)",
+  transition: t.transitions.create("transform", {
+    duration: t.transitions.duration.shortest
+  }),
+  [`&.${V.expanded}`]: {
+    transform: "rotate(180deg)"
+  }
+})), he = /* @__PURE__ */ u.forwardRef(function(n, i) {
+  const s = Z({
+    props: n,
+    name: "MuiAccordionSummary"
+  }), {
+    children: r,
+    className: o,
+    expandIcon: a,
+    focusVisibleClassName: c,
+    onClick: l
+  } = s, f = W(s, Ze), {
+    disabled: m = !1,
+    disableGutters: g,
+    expanded: v,
+    toggle: S
+  } = u.useContext(fe), j = (R) => {
+    S && S(R), l && l(R);
+  }, x = p({}, s, {
+    expanded: v,
+    disabled: m,
+    disableGutters: g
+  }), b = et(x);
+  return /* @__PURE__ */ h.jsxs(tt, p({
+    focusRipple: !1,
+    disableRipple: !0,
+    disabled: m,
+    component: "div",
+    "aria-expanded": v,
+    className: P(b.root, o),
+    focusVisibleClassName: P(b.focusVisible, c),
+    onClick: j,
+    ref: i,
+    ownerState: x
+  }, f, {
+    children: [/* @__PURE__ */ h.jsx(nt, {
+      className: b.content,
+      ownerState: x,
+      children: r
+    }), a && /* @__PURE__ */ h.jsx(ot, {
+      className: b.expandIconWrapper,
+      ownerState: x,
+      children: a
+    })]
+  }));
+});
+process.env.NODE_ENV !== "production" && (he.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn 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 rt = he;
+function it(t) {
+  return Q("MuiAccordionDetails", t);
+}
+Y("MuiAccordionDetails", ["root"]);
+const st = ["className"], at = (t) => {
+  const {
+    classes: n
+  } = t;
+  return ee({
+    root: ["root"]
+  }, it, n);
+}, ct = N("div", {
+  name: "MuiAccordionDetails",
+  slot: "Root",
+  overridesResolver: (t, n) => n.root
+})(({
+  theme: t
+}) => ({
+  padding: t.spacing(1, 2, 2)
+})), xe = /* @__PURE__ */ u.forwardRef(function(n, i) {
+  const s = Z({
+    props: n,
+    name: "MuiAccordionDetails"
+  }), {
+    className: r
+  } = s, o = W(s, st), a = s, c = at(a);
+  return /* @__PURE__ */ h.jsx(ct, p({
+    className: P(c.root, r),
+    ref: i,
+    ownerState: a
+  }, o));
+});
+process.env.NODE_ENV !== "production" && (xe.propTypes = {
+  // ----------------------------- Warning --------------------------------
+  // | These PropTypes are generated from the TypeScript type definitions |
+  // |     To update them edit the d.ts file and run "yarn 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 dt = xe, ft = ({ children: t, ...n }) => /* @__PURE__ */ h.jsx(Je, { ...n, children: t }), mt = ({
+  children: t,
+  ...n
+}) => /* @__PURE__ */ h.jsx(rt, { "aria-controls": "panel1a-content", ...n, children: t }), ht = ({
+  children: t,
+  ...n
+}) => /* @__PURE__ */ h.jsx(dt, { ...n, children: t });
 export {
-  c as KdpaAccordion,
-  d as KdpaAccordionDetails,
-  m as KdpaAccordionSummary
+  ft as KdpaAccordion,
+  ht as KdpaAccordionDetails,
+  mt as KdpaAccordionSummary
 };