everest-npm-features 0.0.1

package/dist/CircularProgress-DcXA6nAu.js

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

package/dist/Close-CdRA3xUs.js

@@ -0,0 +1,75 @@
+import * as l from "react";
+import { P as o } from "./createTheme-NrBCWesw.js";
+import { s as d, u as g, a as u, b as T } from "./createSimplePaletteValueFilter-CsgjlRAs.js";
+import { b as y, g as D } from "./DialogContent-JgT9A6nk.js";
+import { jsx as n } from "react/jsx-runtime";
+import { T as x } from "./Typography-kyxogyUq.js";
+import { c as C } from "./createSvgIcon-CAZr4ukt.js";
+const b = (t) => {
+  const {
+    classes: s
+  } = t;
+  return T({
+    root: ["root"]
+  }, D, s);
+}, h = d(x, {
+  name: "MuiDialogTitle",
+  slot: "Root",
+  overridesResolver: (t, s) => s.root
+})({
+  padding: "16px 24px",
+  flex: "0 0 auto"
+}), v = /* @__PURE__ */ l.forwardRef(function(s, e) {
+  const r = g({
+    props: s,
+    name: "MuiDialogTitle"
+  }), {
+    className: c,
+    id: a,
+    ...p
+  } = r, i = r, m = b(i), {
+    titleId: f = a
+  } = l.useContext(y);
+  return /* @__PURE__ */ n(h, {
+    component: "h2",
+    className: u(m.root, c),
+    ownerState: i,
+    ref: e,
+    variant: "h6",
+    id: a ?? f,
+    ...p
+  });
+});
+process.env.NODE_ENV !== "production" && (v.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: o.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: o.object,
+  /**
+   * @ignore
+   */
+  className: o.string,
+  /**
+   * @ignore
+   */
+  id: o.string,
+  /**
+   * The system prop that allows defining system overrides as well as additional CSS styles.
+   */
+  sx: o.oneOfType([o.arrayOf(o.oneOfType([o.func, o.object, o.bool])), o.func, o.object])
+});
+const I = C(/* @__PURE__ */ n("path", {
+  d: "M19 6.41 17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"
+}), "Close");
+export {
+  I as C,
+  v as D
+};

package/dist/Container-CIMHcpEe.js

@@ -0,0 +1,181 @@
+import { P as e, c as T, e as m, g as W } from "./createTheme-NrBCWesw.js";
+import { a as v, b as y, s as O } from "./createSimplePaletteValueFilter-CsgjlRAs.js";
+import { u as k, a as G } from "./useThemeProps-BqWuFW3z.js";
+import * as R from "react";
+import { jsx as $ } from "react/jsx-runtime";
+import { s as j } from "./styled-Da6GnxEE.js";
+const N = T(), P = j("div", {
+  name: "MuiContainer",
+  slot: "Root",
+  overridesResolver: (a, t) => {
+    const {
+      ownerState: n
+    } = a;
+    return [t.root, t[`maxWidth${m(String(n.maxWidth))}`], n.fixed && t.fixed, n.disableGutters && t.disableGutters];
+  }
+}), S = (a) => k({
+  props: a,
+  name: "MuiContainer",
+  defaultTheme: N
+}), M = (a, t) => {
+  const n = (i) => W(t, i), {
+    classes: l,
+    fixed: u,
+    disableGutters: d,
+    maxWidth: o
+  } = a, s = {
+    root: ["root", o && `maxWidth${m(String(o))}`, u && "fixed", d && "disableGutters"]
+  };
+  return y(s, n, l);
+};
+function E(a = {}) {
+  const {
+    // This will allow adding custom styled fn (for example for custom sx style function)
+    createStyledComponent: t = P,
+    useThemeProps: n = S,
+    componentName: l = "MuiContainer"
+  } = a, u = t(({
+    theme: o,
+    ownerState: s
+  }) => ({
+    width: "100%",
+    marginLeft: "auto",
+    boxSizing: "border-box",
+    marginRight: "auto",
+    ...!s.disableGutters && {
+      paddingLeft: o.spacing(2),
+      paddingRight: o.spacing(2),
+      // @ts-ignore module augmentation fails if custom breakpoints are used
+      [o.breakpoints.up("sm")]: {
+        paddingLeft: o.spacing(3),
+        paddingRight: o.spacing(3)
+      }
+    }
+  }), ({
+    theme: o,
+    ownerState: s
+  }) => s.fixed && Object.keys(o.breakpoints.values).reduce((i, p) => {
+    const c = p, r = o.breakpoints.values[c];
+    return r !== 0 && (i[o.breakpoints.up(c)] = {
+      maxWidth: `${r}${o.breakpoints.unit}`
+    }), i;
+  }, {}), ({
+    theme: o,
+    ownerState: s
+  }) => ({
+    // @ts-ignore module augmentation fails if custom breakpoints are used
+    ...s.maxWidth === "xs" && {
+      // @ts-ignore module augmentation fails if custom breakpoints are used
+      [o.breakpoints.up("xs")]: {
+        // @ts-ignore module augmentation fails if custom breakpoints are used
+        maxWidth: Math.max(o.breakpoints.values.xs, 444)
+      }
+    },
+    ...s.maxWidth && // @ts-ignore module augmentation fails if custom breakpoints are used
+    s.maxWidth !== "xs" && {
+      // @ts-ignore module augmentation fails if custom breakpoints are used
+      [o.breakpoints.up(s.maxWidth)]: {
+        // @ts-ignore module augmentation fails if custom breakpoints are used
+        maxWidth: `${o.breakpoints.values[s.maxWidth]}${o.breakpoints.unit}`
+      }
+    }
+  })), d = /* @__PURE__ */ R.forwardRef(function(s, i) {
+    const p = n(s), {
+      className: c,
+      component: r = "div",
+      disableGutters: x = !1,
+      fixed: b = !1,
+      maxWidth: g = "lg",
+      classes: L,
+      ...h
+    } = p, f = {
+      ...p,
+      component: r,
+      disableGutters: x,
+      fixed: b,
+      maxWidth: g
+    }, C = M(f, l);
+    return (
+      // @ts-ignore theme is injected by the styled util
+      /* @__PURE__ */ $(u, {
+        as: r,
+        ownerState: f,
+        className: v(C.root, c),
+        ref: i,
+        ...h
+      })
+    );
+  });
+  return process.env.NODE_ENV !== "production" && (d.propTypes = {
+    children: e.node,
+    classes: e.object,
+    className: e.string,
+    component: e.elementType,
+    disableGutters: e.bool,
+    fixed: e.bool,
+    maxWidth: e.oneOfType([e.oneOf(["xs", "sm", "md", "lg", "xl", !1]), e.string]),
+    sx: e.oneOfType([e.arrayOf(e.oneOfType([e.func, e.object, e.bool])), e.func, e.object])
+  }), d;
+}
+const D = E({
+  createStyledComponent: O("div", {
+    name: "MuiContainer",
+    slot: "Root",
+    overridesResolver: (a, t) => {
+      const {
+        ownerState: n
+      } = a;
+      return [t.root, t[`maxWidth${m(String(n.maxWidth))}`], n.fixed && t.fixed, n.disableGutters && t.disableGutters];
+    }
+  }),
+  useThemeProps: (a) => G({
+    props: a,
+    name: "MuiContainer"
+  })
+});
+process.env.NODE_ENV !== "production" && (D.propTypes = {
+  // ┌────────────────────────────── Warning ──────────────────────────────┐
+  // │ These PropTypes are generated from the TypeScript type definitions. │
+  // │    To update them, edit the d.ts file and run `pnpm proptypes`.     │
+  // └─────────────────────────────────────────────────────────────────────┘
+  /**
+   * @ignore
+   */
+  children: e.node,
+  /**
+   * Override or extend the styles applied to the component.
+   */
+  classes: e.object,
+  /**
+   * The component used for the root node.
+   * Either a string to use a HTML element or a component.
+   */
+  component: e.elementType,
+  /**
+   * If `true`, the left and right padding is removed.
+   * @default false
+   */
+  disableGutters: e.bool,
+  /**
+   * Set the max-width to match the min-width of the current breakpoint.
+   * This is useful if you'd prefer to design for a fixed set of sizes
+   * instead of trying to accommodate a fully fluid viewport.
+   * It's fluid by default.
+   * @default false
+   */
+  fixed: e.bool,
+  /**
+   * Determine the max-width of the container.
+   * The container width grows with the size of the screen.
+   * Set to `false` to disable `maxWidth`.
+   * @default 'lg'
+   */
+  maxWidth: e.oneOfType([e.oneOf(["xs", "sm", "md", "lg", "xl", !1]), 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])
+});
+export {
+  D as C
+};

package/dist/ContentCopy-CexUUXuC.js

@@ -0,0 +1,8 @@
+import { jsx as o } from "react/jsx-runtime";
+import { c } from "./createSvgIcon-CAZr4ukt.js";
+const m = c(/* @__PURE__ */ o("path", {
+  d: "M16 1H4c-1.1 0-2 .9-2 2v14h2V3h12zm3 4H8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h11c1.1 0 2-.9 2-2V7c0-1.1-.9-2-2-2m0 16H8V7h11z"
+}), "ContentCopy");
+export {
+  m as C
+};