@cgi-learning-hub/ui 1.6.0-dev.1747905856 → 1.6.0-dev.1747921053

package/dist/Stepper-DOTvtRRL.js

@@ -0,0 +1,971 @@
+import * as l from "react";
+import { P as e } from "./index-Sy88PpwE.js";
+import { F as P, G as z, H as T } from "./generateUtilityClasses-DngCqveO.js";
+import { jsxs as D, jsx as b } from "react/jsx-runtime";
+import { u as $, s as S, c as E } from "./DefaultPropsProvider-hFv1J_xl.js";
+import { i as J } from "./integerPropType-D-nm5Xmm.js";
+import { i as ne } from "./isMuiElement-DnSE4qG4.js";
+import { m as V } from "./memoTheme-nmt7i1dS.js";
+import { u as k } from "./useSlot-WWh43uDP.js";
+import { c as K, S as re } from "./createSvgIcon-BlKmtOkV.js";
+import { B as ae } from "./ButtonBase-Chb99sDQ.js";
+import { c as Q } from "./capitalize-BHFotl9B.js";
+const w = /* @__PURE__ */ l.createContext({});
+process.env.NODE_ENV !== "production" && (w.displayName = "StepperContext");
+function He() {
+  return l.useContext(w);
+}
+const B = /* @__PURE__ */ l.createContext({});
+process.env.NODE_ENV !== "production" && (B.displayName = "StepContext");
+function Ge() {
+  return l.useContext(B);
+}
+function se(t) {
+  return z("MuiStep", t);
+}
+const qe = P("MuiStep", ["root", "horizontal", "vertical", "alternativeLabel", "completed"]), le = (t) => {
+  const {
+    classes: o,
+    orientation: n,
+    alternativeLabel: r,
+    completed: a
+  } = t;
+  return E({
+    root: ["root", n, r && "alternativeLabel", a && "completed"]
+  }, se, o);
+}, ie = S("div", {
+  name: "MuiStep",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.root, o[n.orientation], n.alternativeLabel && o.alternativeLabel, n.completed && o.completed];
+  }
+})({
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      paddingLeft: 8,
+      paddingRight: 8
+    }
+  }, {
+    props: {
+      alternativeLabel: !0
+    },
+    style: {
+      flex: 1,
+      position: "relative"
+    }
+  }]
+}), ce = /* @__PURE__ */ l.forwardRef(function(o, n) {
+  const r = $({
+    props: o,
+    name: "MuiStep"
+  }), {
+    active: a,
+    children: i,
+    className: d,
+    component: c = "div",
+    completed: u,
+    disabled: v,
+    expanded: p = !1,
+    index: s,
+    last: m,
+    ...x
+  } = r, {
+    activeStep: y,
+    connector: f,
+    alternativeLabel: N,
+    orientation: M,
+    nonLinear: R
+  } = l.useContext(w);
+  let [C = !1, I = !1, h = !1] = [a, u, v];
+  y === s ? C = a !== void 0 ? a : !0 : !R && y > s ? I = u !== void 0 ? u : !0 : !R && y < s && (h = v !== void 0 ? v : !0);
+  const U = l.useMemo(() => ({
+    index: s,
+    last: m,
+    expanded: p,
+    icon: s + 1,
+    active: C,
+    completed: I,
+    disabled: h
+  }), [s, m, p, C, I, h]), L = {
+    ...r,
+    active: C,
+    orientation: M,
+    alternativeLabel: N,
+    completed: I,
+    disabled: h,
+    expanded: p,
+    component: c
+  }, O = le(L), j = /* @__PURE__ */ D(ie, {
+    as: c,
+    className: T(O.root, d),
+    ref: n,
+    ownerState: L,
+    ...x,
+    children: [f && N && s !== 0 ? f : null, i]
+  });
+  return /* @__PURE__ */ b(B.Provider, {
+    value: U,
+    children: f && !N && s !== 0 ? /* @__PURE__ */ D(l.Fragment, {
+      children: [f, j]
+    }) : j
+  });
+});
+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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Sets the step as active. Is passed to child components.
+   */
+  active: e.bool,
+  /**
+   * Should be `Step` sub-components such as `StepLabel`, `StepContent`.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * Mark the step as completed. Is passed to child components.
+   */
+  completed: e.bool,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, the step is disabled, will also disable the button if
+   * `StepButton` is a child of `Step`. Is passed to child components.
+   */
+  disabled: e.bool,
+  /**
+   * Expand the step.
+   * @default false
+   */
+  expanded: e.bool,
+  /**
+   * The position of the step.
+   * The prop defaults to the value inherited from the parent Stepper component.
+   */
+  index: J,
+  /**
+   * If `true`, the Step is displayed as rendered last.
+   * The prop defaults to the value inherited from the parent Stepper component.
+   */
+  last: 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])
+});
+const pe = K(/* @__PURE__ */ b("path", {
+  d: "M12 0a12 12 0 1 0 0 24 12 12 0 0 0 0-24zm-2 17l-5-5 1.4-1.4 3.6 3.6 7.6-7.6L19 8l-9 9z"
+}), "CheckCircle"), de = K(/* @__PURE__ */ b("path", {
+  d: "M1 21h22L12 2 1 21zm12-3h-2v-2h2v2zm0-4h-2v-4h2v4z"
+}), "Warning");
+function ue(t) {
+  return z("MuiStepIcon", t);
+}
+const F = P("MuiStepIcon", ["root", "active", "completed", "error", "text"]);
+var G;
+const be = (t) => {
+  const {
+    classes: o,
+    active: n,
+    completed: r,
+    error: a
+  } = t;
+  return E({
+    root: ["root", n && "active", r && "completed", a && "error"],
+    text: ["text"]
+  }, ue, o);
+}, W = S(re, {
+  name: "MuiStepIcon",
+  slot: "Root",
+  overridesResolver: (t, o) => o.root
+})(V(({
+  theme: t
+}) => ({
+  display: "block",
+  transition: t.transitions.create("color", {
+    duration: t.transitions.duration.shortest
+  }),
+  color: (t.vars || t).palette.text.disabled,
+  [`&.${F.completed}`]: {
+    color: (t.vars || t).palette.primary.main
+  },
+  [`&.${F.active}`]: {
+    color: (t.vars || t).palette.primary.main
+  },
+  [`&.${F.error}`]: {
+    color: (t.vars || t).palette.error.main
+  }
+}))), ve = S("text", {
+  name: "MuiStepIcon",
+  slot: "Text",
+  overridesResolver: (t, o) => o.text
+})(V(({
+  theme: t
+}) => ({
+  fill: (t.vars || t).palette.primary.contrastText,
+  fontSize: t.typography.caption.fontSize,
+  fontFamily: t.typography.fontFamily
+}))), X = /* @__PURE__ */ l.forwardRef(function(o, n) {
+  const r = $({
+    props: o,
+    name: "MuiStepIcon"
+  }), {
+    active: a = !1,
+    className: i,
+    completed: d = !1,
+    error: c = !1,
+    icon: u,
+    ...v
+  } = r, p = {
+    ...r,
+    active: a,
+    completed: d,
+    error: c
+  }, s = be(p);
+  if (typeof u == "number" || typeof u == "string") {
+    const m = T(i, s.root);
+    return c ? /* @__PURE__ */ b(W, {
+      as: de,
+      className: m,
+      ref: n,
+      ownerState: p,
+      ...v
+    }) : d ? /* @__PURE__ */ b(W, {
+      as: pe,
+      className: m,
+      ref: n,
+      ownerState: p,
+      ...v
+    }) : /* @__PURE__ */ D(W, {
+      className: m,
+      ref: n,
+      ownerState: p,
+      ...v,
+      children: [G || (G = /* @__PURE__ */ b("circle", {
+        cx: "12",
+        cy: "12",
+        r: "12"
+      })), /* @__PURE__ */ b(ve, {
+        className: s.text,
+        x: "12",
+        y: "12",
+        textAnchor: "middle",
+        dominantBaseline: "central",
+        ownerState: p,
+        children: u
+      })]
+    });
+  }
+  return u;
+});
+process.env.NODE_ENV !== "production" && (X.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Whether this step is active.
+   * @default false
+   */
+  active: e.bool,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * Mark the step as completed. Is passed to child components.
+   * @default false
+   */
+  completed: e.bool,
+  /**
+   * If `true`, the step is marked as failed.
+   * @default false
+   */
+  error: e.bool,
+  /**
+   * The label displayed in the step icon.
+   */
+  icon: e.node,
+  /**
+   * 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 me(t) {
+  return z("MuiStepLabel", t);
+}
+const g = P("MuiStepLabel", ["root", "horizontal", "vertical", "label", "active", "completed", "error", "disabled", "iconContainer", "alternativeLabel", "labelContainer"]), fe = (t) => {
+  const {
+    classes: o,
+    orientation: n,
+    active: r,
+    completed: a,
+    error: i,
+    disabled: d,
+    alternativeLabel: c
+  } = t;
+  return E({
+    root: ["root", n, i && "error", d && "disabled", c && "alternativeLabel"],
+    label: ["label", r && "active", a && "completed", i && "error", d && "disabled", c && "alternativeLabel"],
+    iconContainer: ["iconContainer", r && "active", a && "completed", i && "error", d && "disabled", c && "alternativeLabel"],
+    labelContainer: ["labelContainer", c && "alternativeLabel"]
+  }, me, o);
+}, Se = S("span", {
+  name: "MuiStepLabel",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.root, o[n.orientation]];
+  }
+})({
+  display: "flex",
+  alignItems: "center",
+  [`&.${g.alternativeLabel}`]: {
+    flexDirection: "column"
+  },
+  [`&.${g.disabled}`]: {
+    cursor: "default"
+  },
+  variants: [{
+    props: {
+      orientation: "vertical"
+    },
+    style: {
+      textAlign: "left",
+      padding: "8px 0"
+    }
+  }]
+}), ye = S("span", {
+  name: "MuiStepLabel",
+  slot: "Label",
+  overridesResolver: (t, o) => o.label
+})(V(({
+  theme: t
+}) => ({
+  ...t.typography.body2,
+  display: "block",
+  transition: t.transitions.create("color", {
+    duration: t.transitions.duration.shortest
+  }),
+  [`&.${g.active}`]: {
+    color: (t.vars || t).palette.text.primary,
+    fontWeight: 500
+  },
+  [`&.${g.completed}`]: {
+    color: (t.vars || t).palette.text.primary,
+    fontWeight: 500
+  },
+  [`&.${g.alternativeLabel}`]: {
+    marginTop: 16
+  },
+  [`&.${g.error}`]: {
+    color: (t.vars || t).palette.error.main
+  }
+}))), Ce = S("span", {
+  name: "MuiStepLabel",
+  slot: "IconContainer",
+  overridesResolver: (t, o) => o.iconContainer
+})({
+  flexShrink: 0,
+  display: "flex",
+  paddingRight: 8,
+  [`&.${g.alternativeLabel}`]: {
+    paddingRight: 0
+  }
+}), xe = S("span", {
+  name: "MuiStepLabel",
+  slot: "LabelContainer",
+  overridesResolver: (t, o) => o.labelContainer
+})(V(({
+  theme: t
+}) => ({
+  width: "100%",
+  color: (t.vars || t).palette.text.secondary,
+  [`&.${g.alternativeLabel}`]: {
+    textAlign: "center"
+  }
+}))), A = /* @__PURE__ */ l.forwardRef(function(o, n) {
+  const r = $({
+    props: o,
+    name: "MuiStepLabel"
+  }), {
+    children: a,
+    className: i,
+    componentsProps: d = {},
+    error: c = !1,
+    icon: u,
+    optional: v,
+    slots: p = {},
+    slotProps: s = {},
+    StepIconComponent: m,
+    StepIconProps: x,
+    ...y
+  } = r, {
+    alternativeLabel: f,
+    orientation: N
+  } = l.useContext(w), {
+    active: M,
+    disabled: R,
+    completed: C,
+    icon: I
+  } = l.useContext(B), h = u || I;
+  let U = m;
+  h && !U && (U = X);
+  const L = {
+    ...r,
+    active: M,
+    alternativeLabel: f,
+    completed: C,
+    disabled: R,
+    error: c,
+    orientation: N
+  }, O = fe(L), j = {
+    slots: p,
+    slotProps: {
+      stepIcon: x,
+      ...d,
+      ...s
+    }
+  }, [Z, ee] = k("root", {
+    elementType: Se,
+    externalForwardedProps: {
+      ...j,
+      ...y
+    },
+    ownerState: L,
+    ref: n,
+    className: T(O.root, i)
+  }), [te, _] = k("label", {
+    elementType: ye,
+    externalForwardedProps: j,
+    ownerState: L
+  }), [H, oe] = k("stepIcon", {
+    elementType: U,
+    externalForwardedProps: j,
+    ownerState: L
+  });
+  return /* @__PURE__ */ D(Z, {
+    ...ee,
+    children: [h || H ? /* @__PURE__ */ b(Ce, {
+      className: O.iconContainer,
+      ownerState: L,
+      children: /* @__PURE__ */ b(H, {
+        completed: C,
+        active: M,
+        error: c,
+        icon: h,
+        ...oe
+      })
+    }) : null, /* @__PURE__ */ D(xe, {
+      className: O.labelContainer,
+      ownerState: L,
+      children: [a ? /* @__PURE__ */ b(te, {
+        ..._,
+        className: T(O.label, _ == null ? void 0 : _.className),
+        children: a
+      }) : null, v]
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (A.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * In most cases will simply be a string containing a title for the label.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   * @deprecated use the `slotProps` prop instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](https://mui.com/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  componentsProps: e.shape({
+    label: e.object
+  }),
+  /**
+   * If `true`, the step is marked as failed.
+   * @default false
+   */
+  error: e.bool,
+  /**
+   * Override the default label of the step icon.
+   */
+  icon: e.node,
+  /**
+   * The optional node to display.
+   */
+  optional: e.node,
+  /**
+   * The props used for each slot inside.
+   * @default {}
+   */
+  slotProps: e.shape({
+    label: e.oneOfType([e.func, e.object]),
+    root: e.oneOfType([e.func, e.object]),
+    stepIcon: e.oneOfType([e.func, e.object])
+  }),
+  /**
+   * The components used for each slot inside.
+   * @default {}
+   */
+  slots: e.shape({
+    label: e.elementType,
+    root: e.elementType,
+    stepIcon: e.elementType
+  }),
+  /**
+   * The component to render in place of the [`StepIcon`](https://mui.com/material-ui/api/step-icon/).
+   * @deprecated Use `slots.stepIcon` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  StepIconComponent: e.elementType,
+  /**
+   * Props applied to the [`StepIcon`](https://mui.com/material-ui/api/step-icon/) element.
+   * @deprecated Use `slotProps.stepIcon` instead. This prop will be removed in a future major release. See [Migrating from deprecated APIs](/material-ui/migration/migrating-from-deprecated-apis/) for more details.
+   */
+  StepIconProps: 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])
+});
+A.muiName = "StepLabel";
+function Le(t) {
+  return z("MuiStepButton", t);
+}
+const q = P("MuiStepButton", ["root", "horizontal", "vertical", "touchRipple"]), he = (t) => {
+  const {
+    classes: o,
+    orientation: n
+  } = t;
+  return E({
+    root: ["root", n],
+    touchRipple: ["touchRipple"]
+  }, Le, o);
+}, ge = S(ae, {
+  name: "MuiStepButton",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [{
+      [`& .${q.touchRipple}`]: o.touchRipple
+    }, o.root, o[n.orientation]];
+  }
+})({
+  width: "100%",
+  padding: "24px 16px",
+  margin: "-24px -16px",
+  boxSizing: "content-box",
+  [`& .${q.touchRipple}`]: {
+    color: "rgba(0, 0, 0, 0.3)"
+  },
+  variants: [{
+    props: {
+      orientation: "vertical"
+    },
+    style: {
+      justifyContent: "flex-start",
+      padding: "8px",
+      margin: "-8px"
+    }
+  }]
+}), Ne = /* @__PURE__ */ l.forwardRef(function(o, n) {
+  const r = $({
+    props: o,
+    name: "MuiStepButton"
+  }), {
+    children: a,
+    className: i,
+    icon: d,
+    optional: c,
+    ...u
+  } = r, {
+    disabled: v,
+    active: p
+  } = l.useContext(B), {
+    orientation: s
+  } = l.useContext(w), m = {
+    ...r,
+    orientation: s
+  }, x = he(m), y = {
+    icon: d,
+    optional: c
+  }, f = ne(a, ["StepLabel"]) ? /* @__PURE__ */ l.cloneElement(a, y) : /* @__PURE__ */ b(A, {
+    ...y,
+    children: a
+  });
+  return /* @__PURE__ */ b(ge, {
+    focusRipple: !0,
+    disabled: v,
+    TouchRippleProps: {
+      className: x.touchRipple
+    },
+    className: T(x.root, i),
+    ref: n,
+    ownerState: m,
+    "aria-current": p ? "step" : void 0,
+    ...u,
+    children: f
+  });
+});
+process.env.NODE_ENV !== "production" && (Ne.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Can be a `StepLabel` or a node to place inside `StepLabel` as children.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The icon displayed by the step label.
+   */
+  icon: e.node,
+  /**
+   * The optional node to display.
+   */
+  optional: e.node,
+  /**
+   * 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 Re(t) {
+  return z("MuiStepper", t);
+}
+const Je = P("MuiStepper", ["root", "horizontal", "vertical", "nonLinear", "alternativeLabel"]);
+function Te(t) {
+  return z("MuiStepConnector", t);
+}
+P("MuiStepConnector", ["root", "horizontal", "vertical", "alternativeLabel", "active", "completed", "disabled", "line", "lineHorizontal", "lineVertical"]);
+const we = (t) => {
+  const {
+    classes: o,
+    orientation: n,
+    alternativeLabel: r,
+    active: a,
+    completed: i,
+    disabled: d
+  } = t, c = {
+    root: ["root", n, r && "alternativeLabel", a && "active", i && "completed", d && "disabled"],
+    line: ["line", `line${Q(n)}`]
+  };
+  return E(c, Te, o);
+}, Me = S("div", {
+  name: "MuiStepConnector",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.root, o[n.orientation], n.alternativeLabel && o.alternativeLabel, n.completed && o.completed];
+  }
+})({
+  flex: "1 1 auto",
+  variants: [{
+    props: {
+      orientation: "vertical"
+    },
+    style: {
+      marginLeft: 12
+      // half icon
+    }
+  }, {
+    props: {
+      alternativeLabel: !0
+    },
+    style: {
+      position: "absolute",
+      top: 12,
+      left: "calc(-50% + 20px)",
+      right: "calc(50% + 20px)"
+    }
+  }]
+}), Ie = S("span", {
+  name: "MuiStepConnector",
+  slot: "Line",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.line, o[`line${Q(n.orientation)}`]];
+  }
+})(V(({
+  theme: t
+}) => {
+  const o = t.palette.mode === "light" ? t.palette.grey[400] : t.palette.grey[600];
+  return {
+    display: "block",
+    borderColor: t.vars ? t.vars.palette.StepConnector.border : o,
+    variants: [{
+      props: {
+        orientation: "horizontal"
+      },
+      style: {
+        borderTopStyle: "solid",
+        borderTopWidth: 1
+      }
+    }, {
+      props: {
+        orientation: "vertical"
+      },
+      style: {
+        borderLeftStyle: "solid",
+        borderLeftWidth: 1,
+        minHeight: 24
+      }
+    }]
+  };
+})), Y = /* @__PURE__ */ l.forwardRef(function(o, n) {
+  const r = $({
+    props: o,
+    name: "MuiStepConnector"
+  }), {
+    className: a,
+    ...i
+  } = r, {
+    alternativeLabel: d,
+    orientation: c = "horizontal"
+  } = l.useContext(w), {
+    active: u,
+    disabled: v,
+    completed: p
+  } = l.useContext(B), s = {
+    ...r,
+    alternativeLabel: d,
+    orientation: c,
+    active: u,
+    completed: p,
+    disabled: v
+  }, m = we(s);
+  return /* @__PURE__ */ b(Me, {
+    className: T(m.root, a),
+    ref: n,
+    ownerState: s,
+    ...i,
+    children: /* @__PURE__ */ b(Ie, {
+      className: m.line,
+      ownerState: s
+    })
+  });
+});
+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`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * 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 Oe = (t) => {
+  const {
+    orientation: o,
+    nonLinear: n,
+    alternativeLabel: r,
+    classes: a
+  } = t;
+  return E({
+    root: ["root", o, n && "nonLinear", r && "alternativeLabel"]
+  }, Re, a);
+}, je = S("div", {
+  name: "MuiStepper",
+  slot: "Root",
+  overridesResolver: (t, o) => {
+    const {
+      ownerState: n
+    } = t;
+    return [o.root, o[n.orientation], n.alternativeLabel && o.alternativeLabel, n.nonLinear && o.nonLinear];
+  }
+})({
+  display: "flex",
+  variants: [{
+    props: {
+      orientation: "horizontal"
+    },
+    style: {
+      flexDirection: "row",
+      alignItems: "center"
+    }
+  }, {
+    props: {
+      orientation: "vertical"
+    },
+    style: {
+      flexDirection: "column"
+    }
+  }, {
+    props: {
+      alternativeLabel: !0
+    },
+    style: {
+      alignItems: "flex-start"
+    }
+  }]
+}), Pe = /* @__PURE__ */ b(Y, {}), ze = /* @__PURE__ */ l.forwardRef(function(o, n) {
+  const r = $({
+    props: o,
+    name: "MuiStepper"
+  }), {
+    activeStep: a = 0,
+    alternativeLabel: i = !1,
+    children: d,
+    className: c,
+    component: u = "div",
+    connector: v = Pe,
+    nonLinear: p = !1,
+    orientation: s = "horizontal",
+    ...m
+  } = r, x = {
+    ...r,
+    nonLinear: p,
+    alternativeLabel: i,
+    orientation: s,
+    component: u
+  }, y = Oe(x), f = l.Children.toArray(d).filter(Boolean), N = f.map((R, C) => /* @__PURE__ */ l.cloneElement(R, {
+    index: C,
+    last: C + 1 === f.length,
+    ...R.props
+  })), M = l.useMemo(() => ({
+    activeStep: a,
+    alternativeLabel: i,
+    connector: v,
+    nonLinear: p,
+    orientation: s
+  }), [a, i, v, p, s]);
+  return /* @__PURE__ */ b(w.Provider, {
+    value: M,
+    children: /* @__PURE__ */ b(je, {
+      as: u,
+      ownerState: x,
+      className: T(y.root, c),
+      ref: n,
+      ...m,
+      children: N
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (ze.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * Set the active step (zero based index).
+   * Set to -1 to disable all the steps.
+   * @default 0
+   */
+  activeStep: J,
+  /**
+   * If set to 'true' and orientation is horizontal,
+   * then the step label will be positioned under the icon.
+   * @default false
+   */
+  alternativeLabel: e.bool,
+  /**
+   * Two or more `<Step />` components.
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * @ignore
+   */
+  className: e.string,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * An element to be placed between each step.
+   * @default <StepConnector />
+   */
+  connector: e.element,
+  /**
+   * If set the `Stepper` will not assist in controlling steps for linear flow.
+   * @default false
+   */
+  nonLinear: e.bool,
+  /**
+   * The component orientation (layout flow direction).
+   * @default 'horizontal'
+   */
+  orientation: e.oneOf(["horizontal", "vertical"]),
+  /**
+   * 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 {
+  ce as S,
+  Ne as a,
+  A as b,
+  ze as c,
+  B as d,
+  q as e,
+  Le as f,
+  se as g,
+  g as h,
+  me as i,
+  Je as j,
+  w as k,
+  Re as l,
+  He as m,
+  qe as s,
+  Ge as u
+};