@movable/ui 1.9.0 → 1.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/index.mjs CHANGED
@@ -6432,1464 +6432,7 @@ function Up({ id: e, label: t, menuOptions: r, name: n, control: o, inputProps:
6432
6432
  }, ...k, ...b, ref: x, children: w(m, r) }), (p.error || s) && v.jsx(Os, { "data-test-select-helper-text": n, children: ((j = p.error) == null ? void 0 : j.message) ?? s })] });
6433
6433
  } })] });
6434
6434
  }
6435
- const _n = /* @__PURE__ */ I.createContext();
6436
- process.env.NODE_ENV !== "production" && (_n.displayName = "GridContext");
6437
- function Ad(e) {
6438
- return St("MuiGrid", e);
6439
- }
6440
- const Pd = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], jd = ["column-reverse", "column", "row-reverse", "row"], Id = ["nowrap", "wrap-reverse", "wrap"], Lt = ["auto", !0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], Kt = $r("MuiGrid", [
6441
- "root",
6442
- "container",
6443
- "item",
6444
- "zeroMinWidth",
6445
- // spacings
6446
- ...Pd.map((e) => `spacing-xs-${e}`),
6447
- // direction values
6448
- ...jd.map((e) => `direction-xs-${e}`),
6449
- // wrap values
6450
- ...Id.map((e) => `wrap-xs-${e}`),
6451
- // grid sizes for all breakpoints
6452
- ...Lt.map((e) => `grid-xs-${e}`),
6453
- ...Lt.map((e) => `grid-sm-${e}`),
6454
- ...Lt.map((e) => `grid-md-${e}`),
6455
- ...Lt.map((e) => `grid-lg-${e}`),
6456
- ...Lt.map((e) => `grid-xl-${e}`)
6457
- ]), Nd = ["className", "columns", "columnSpacing", "component", "container", "direction", "item", "rowSpacing", "spacing", "wrap", "zeroMinWidth"];
6458
- function $t(e) {
6459
- const t = parseFloat(e);
6460
- return `${t}${String(e).replace(String(t), "") || "px"}`;
6461
- }
6462
- function Dd({
6463
- theme: e,
6464
- ownerState: t
6465
- }) {
6466
- let r;
6467
- return e.breakpoints.keys.reduce((n, o) => {
6468
- let i = {};
6469
- if (t[o] && (r = t[o]), !r)
6470
- return n;
6471
- if (r === !0)
6472
- i = {
6473
- flexBasis: 0,
6474
- flexGrow: 1,
6475
- maxWidth: "100%"
6476
- };
6477
- else if (r === "auto")
6478
- i = {
6479
- flexBasis: "auto",
6480
- flexGrow: 0,
6481
- flexShrink: 0,
6482
- maxWidth: "none",
6483
- width: "auto"
6484
- };
6485
- else {
6486
- const a = vt({
6487
- values: t.columns,
6488
- breakpoints: e.breakpoints.values
6489
- }), s = typeof a == "object" ? a[o] : a;
6490
- if (s == null)
6491
- return n;
6492
- const c = `${Math.round(r / s * 1e8) / 1e6}%`;
6493
- let u = {};
6494
- if (t.container && t.item && t.columnSpacing !== 0) {
6495
- const f = e.spacing(t.columnSpacing);
6496
- if (f !== "0px") {
6497
- const h = `calc(${c} + ${$t(f)})`;
6498
- u = {
6499
- flexBasis: h,
6500
- maxWidth: h
6501
- };
6502
- }
6503
- }
6504
- i = M({
6505
- flexBasis: c,
6506
- flexGrow: 0,
6507
- maxWidth: c
6508
- }, u);
6509
- }
6510
- return e.breakpoints.values[o] === 0 ? Object.assign(n, i) : n[e.breakpoints.up(o)] = i, n;
6511
- }, {});
6512
- }
6513
- function Fd({
6514
- theme: e,
6515
- ownerState: t
6516
- }) {
6517
- const r = vt({
6518
- values: t.direction,
6519
- breakpoints: e.breakpoints.values
6520
- });
6521
- return Ge({
6522
- theme: e
6523
- }, r, (n) => {
6524
- const o = {
6525
- flexDirection: n
6526
- };
6527
- return n.indexOf("column") === 0 && (o[`& > .${Kt.item}`] = {
6528
- maxWidth: "none"
6529
- }), o;
6530
- });
6531
- }
6532
- function wa({
6533
- breakpoints: e,
6534
- values: t
6535
- }) {
6536
- let r = "";
6537
- Object.keys(t).forEach((o) => {
6538
- r === "" && t[o] !== 0 && (r = o);
6539
- });
6540
- const n = Object.keys(e).sort((o, i) => e[o] - e[i]);
6541
- return n.slice(0, n.indexOf(r));
6542
- }
6543
- function Bd({
6544
- theme: e,
6545
- ownerState: t
6546
- }) {
6547
- const {
6548
- container: r,
6549
- rowSpacing: n
6550
- } = t;
6551
- let o = {};
6552
- if (r && n !== 0) {
6553
- const i = vt({
6554
- values: n,
6555
- breakpoints: e.breakpoints.values
6556
- });
6557
- let a;
6558
- typeof i == "object" && (a = wa({
6559
- breakpoints: e.breakpoints.values,
6560
- values: i
6561
- })), o = Ge({
6562
- theme: e
6563
- }, i, (s, c) => {
6564
- var u;
6565
- const f = e.spacing(s);
6566
- return f !== "0px" ? {
6567
- marginTop: `-${$t(f)}`,
6568
- [`& > .${Kt.item}`]: {
6569
- paddingTop: $t(f)
6570
- }
6571
- } : (u = a) != null && u.includes(c) ? {} : {
6572
- marginTop: 0,
6573
- [`& > .${Kt.item}`]: {
6574
- paddingTop: 0
6575
- }
6576
- };
6577
- });
6578
- }
6579
- return o;
6580
- }
6581
- function zd({
6582
- theme: e,
6583
- ownerState: t
6584
- }) {
6585
- const {
6586
- container: r,
6587
- columnSpacing: n
6588
- } = t;
6589
- let o = {};
6590
- if (r && n !== 0) {
6591
- const i = vt({
6592
- values: n,
6593
- breakpoints: e.breakpoints.values
6594
- });
6595
- let a;
6596
- typeof i == "object" && (a = wa({
6597
- breakpoints: e.breakpoints.values,
6598
- values: i
6599
- })), o = Ge({
6600
- theme: e
6601
- }, i, (s, c) => {
6602
- var u;
6603
- const f = e.spacing(s);
6604
- return f !== "0px" ? {
6605
- width: `calc(100% + ${$t(f)})`,
6606
- marginLeft: `-${$t(f)}`,
6607
- [`& > .${Kt.item}`]: {
6608
- paddingLeft: $t(f)
6609
- }
6610
- } : (u = a) != null && u.includes(c) ? {} : {
6611
- width: "100%",
6612
- marginLeft: 0,
6613
- [`& > .${Kt.item}`]: {
6614
- paddingLeft: 0
6615
- }
6616
- };
6617
- });
6618
- }
6619
- return o;
6620
- }
6621
- function Ld(e, t, r = {}) {
6622
- if (!e || e <= 0)
6623
- return [];
6624
- if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
6625
- return [r[`spacing-xs-${String(e)}`]];
6626
- const n = [];
6627
- return t.forEach((o) => {
6628
- const i = e[o];
6629
- Number(i) > 0 && n.push(r[`spacing-${o}-${String(i)}`]);
6630
- }), n;
6631
- }
6632
- const Wd = ir("div", {
6633
- name: "MuiGrid",
6634
- slot: "Root",
6635
- overridesResolver: (e, t) => {
6636
- const {
6637
- ownerState: r
6638
- } = e, {
6639
- container: n,
6640
- direction: o,
6641
- item: i,
6642
- spacing: a,
6643
- wrap: s,
6644
- zeroMinWidth: c,
6645
- breakpoints: u
6646
- } = r;
6647
- let f = [];
6648
- n && (f = Ld(a, u, t));
6649
- const h = [];
6650
- return u.forEach((m) => {
6651
- const b = r[m];
6652
- b && h.push(t[`grid-${m}-${String(b)}`]);
6653
- }), [t.root, n && t.container, i && t.item, c && t.zeroMinWidth, ...f, o !== "row" && t[`direction-xs-${String(o)}`], s !== "wrap" && t[`wrap-xs-${String(s)}`], ...h];
6654
- }
6655
- })(({
6656
- ownerState: e
6657
- }) => M({
6658
- boxSizing: "border-box"
6659
- }, e.container && {
6660
- display: "flex",
6661
- flexWrap: "wrap",
6662
- width: "100%"
6663
- }, e.item && {
6664
- margin: 0
6665
- // For instance, it's useful when used with a `figure` element.
6666
- }, e.zeroMinWidth && {
6667
- minWidth: 0
6668
- }, e.wrap !== "wrap" && {
6669
- flexWrap: e.wrap
6670
- }), Fd, Bd, zd, Dd);
6671
- function Vd(e, t) {
6672
- if (!e || e <= 0)
6673
- return [];
6674
- if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
6675
- return [`spacing-xs-${String(e)}`];
6676
- const r = [];
6677
- return t.forEach((n) => {
6678
- const o = e[n];
6679
- if (Number(o) > 0) {
6680
- const i = `spacing-${n}-${String(o)}`;
6681
- r.push(i);
6682
- }
6683
- }), r;
6684
- }
6685
- const Ud = (e) => {
6686
- const {
6687
- classes: t,
6688
- container: r,
6689
- direction: n,
6690
- item: o,
6691
- spacing: i,
6692
- wrap: a,
6693
- zeroMinWidth: s,
6694
- breakpoints: c
6695
- } = e;
6696
- let u = [];
6697
- r && (u = Vd(i, c));
6698
- const f = [];
6699
- c.forEach((m) => {
6700
- const b = e[m];
6701
- b && f.push(`grid-${m}-${String(b)}`);
6702
- });
6703
- const h = {
6704
- root: ["root", r && "container", o && "item", s && "zeroMinWidth", ...u, n !== "row" && `direction-xs-${String(n)}`, a !== "wrap" && `wrap-xs-${String(a)}`, ...f]
6705
- };
6706
- return Xt(h, Ad, t);
6707
- }, bt = /* @__PURE__ */ I.forwardRef(function(t, r) {
6708
- const n = Zt({
6709
- props: t,
6710
- name: "MuiGrid"
6711
- }), {
6712
- breakpoints: o
6713
- } = Un(), i = Wr(n), {
6714
- className: a,
6715
- columns: s,
6716
- columnSpacing: c,
6717
- component: u = "div",
6718
- container: f = !1,
6719
- direction: h = "row",
6720
- item: m = !1,
6721
- rowSpacing: b,
6722
- spacing: x = 0,
6723
- wrap: g = "wrap",
6724
- zeroMinWidth: y = !1
6725
- } = i, T = je(i, Nd), w = b || x, O = c || x, k = I.useContext(_n), p = f ? s || 12 : k, j = {}, P = M({}, T);
6726
- o.keys.forEach((ue) => {
6727
- T[ue] != null && (j[ue] = T[ue], delete P[ue]);
6728
- });
6729
- const fe = M({}, i, {
6730
- columns: p,
6731
- container: f,
6732
- direction: h,
6733
- item: m,
6734
- rowSpacing: w,
6735
- columnSpacing: O,
6736
- wrap: g,
6737
- zeroMinWidth: y,
6738
- spacing: x
6739
- }, j, {
6740
- breakpoints: o.keys
6741
- }), te = Ud(fe);
6742
- return /* @__PURE__ */ v.jsx(_n.Provider, {
6743
- value: p,
6744
- children: /* @__PURE__ */ v.jsx(Wd, M({
6745
- ownerState: fe,
6746
- className: Jt(te.root, a),
6747
- as: u,
6748
- ref: r
6749
- }, P))
6750
- });
6751
- });
6752
- process.env.NODE_ENV !== "production" && (bt.propTypes = {
6753
- // ┌────────────────────────────── Warning ──────────────────────────────┐
6754
- // │ These PropTypes are generated from the TypeScript type definitions. │
6755
- // │ To update them, edit the d.ts file and run `pnpm proptypes`. │
6756
- // └─────────────────────────────────────────────────────────────────────┘
6757
- /**
6758
- * The content of the component.
6759
- */
6760
- children: l.node,
6761
- /**
6762
- * Override or extend the styles applied to the component.
6763
- */
6764
- classes: l.object,
6765
- /**
6766
- * @ignore
6767
- */
6768
- className: l.string,
6769
- /**
6770
- * The number of columns.
6771
- * @default 12
6772
- */
6773
- columns: l.oneOfType([l.arrayOf(l.number), l.number, l.object]),
6774
- /**
6775
- * Defines the horizontal space between the type `item` components.
6776
- * It overrides the value of the `spacing` prop.
6777
- */
6778
- columnSpacing: l.oneOfType([l.arrayOf(l.oneOfType([l.number, l.string])), l.number, l.object, l.string]),
6779
- /**
6780
- * The component used for the root node.
6781
- * Either a string to use a HTML element or a component.
6782
- */
6783
- component: l.elementType,
6784
- /**
6785
- * If `true`, the component will have the flex *container* behavior.
6786
- * You should be wrapping *items* with a *container*.
6787
- * @default false
6788
- */
6789
- container: l.bool,
6790
- /**
6791
- * Defines the `flex-direction` style property.
6792
- * It is applied for all screen sizes.
6793
- * @default 'row'
6794
- */
6795
- direction: l.oneOfType([l.oneOf(["column-reverse", "column", "row-reverse", "row"]), l.arrayOf(l.oneOf(["column-reverse", "column", "row-reverse", "row"])), l.object]),
6796
- /**
6797
- * If `true`, the component will have the flex *item* behavior.
6798
- * You should be wrapping *items* with a *container*.
6799
- * @default false
6800
- */
6801
- item: l.bool,
6802
- /**
6803
- * If a number, it sets the number of columns the grid item uses.
6804
- * It can't be greater than the total number of columns of the container (12 by default).
6805
- * If 'auto', the grid item's width matches its content.
6806
- * If false, the prop is ignored.
6807
- * If true, the grid item's width grows to use the space available in the grid container.
6808
- * The value is applied for the `lg` breakpoint and wider screens if not overridden.
6809
- * @default false
6810
- */
6811
- lg: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
6812
- /**
6813
- * If a number, it sets the number of columns the grid item uses.
6814
- * It can't be greater than the total number of columns of the container (12 by default).
6815
- * If 'auto', the grid item's width matches its content.
6816
- * If false, the prop is ignored.
6817
- * If true, the grid item's width grows to use the space available in the grid container.
6818
- * The value is applied for the `md` breakpoint and wider screens if not overridden.
6819
- * @default false
6820
- */
6821
- md: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
6822
- /**
6823
- * Defines the vertical space between the type `item` components.
6824
- * It overrides the value of the `spacing` prop.
6825
- */
6826
- rowSpacing: l.oneOfType([l.arrayOf(l.oneOfType([l.number, l.string])), l.number, l.object, l.string]),
6827
- /**
6828
- * If a number, it sets the number of columns the grid item uses.
6829
- * It can't be greater than the total number of columns of the container (12 by default).
6830
- * If 'auto', the grid item's width matches its content.
6831
- * If false, the prop is ignored.
6832
- * If true, the grid item's width grows to use the space available in the grid container.
6833
- * The value is applied for the `sm` breakpoint and wider screens if not overridden.
6834
- * @default false
6835
- */
6836
- sm: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
6837
- /**
6838
- * Defines the space between the type `item` components.
6839
- * It can only be used on a type `container` component.
6840
- * @default 0
6841
- */
6842
- spacing: l.oneOfType([l.arrayOf(l.oneOfType([l.number, l.string])), l.number, l.object, l.string]),
6843
- /**
6844
- * The system prop that allows defining system overrides as well as additional CSS styles.
6845
- */
6846
- sx: l.oneOfType([l.arrayOf(l.oneOfType([l.func, l.object, l.bool])), l.func, l.object]),
6847
- /**
6848
- * Defines the `flex-wrap` style property.
6849
- * It's applied for all screen sizes.
6850
- * @default 'wrap'
6851
- */
6852
- wrap: l.oneOf(["nowrap", "wrap-reverse", "wrap"]),
6853
- /**
6854
- * If a number, it sets the number of columns the grid item uses.
6855
- * It can't be greater than the total number of columns of the container (12 by default).
6856
- * If 'auto', the grid item's width matches its content.
6857
- * If false, the prop is ignored.
6858
- * If true, the grid item's width grows to use the space available in the grid container.
6859
- * The value is applied for the `xl` breakpoint and wider screens if not overridden.
6860
- * @default false
6861
- */
6862
- xl: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
6863
- /**
6864
- * If a number, it sets the number of columns the grid item uses.
6865
- * It can't be greater than the total number of columns of the container (12 by default).
6866
- * If 'auto', the grid item's width matches its content.
6867
- * If false, the prop is ignored.
6868
- * If true, the grid item's width grows to use the space available in the grid container.
6869
- * The value is applied for all the screen sizes with the lowest priority.
6870
- * @default false
6871
- */
6872
- xs: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
6873
- /**
6874
- * If `true`, it sets `min-width: 0` on the item.
6875
- * Refer to the limitations section of the documentation to better understand the use case.
6876
- * @default false
6877
- */
6878
- zeroMinWidth: l.bool
6879
- });
6880
- if (process.env.NODE_ENV !== "production") {
6881
- const e = wi("Grid", bt);
6882
- bt.propTypes = M({}, bt.propTypes, {
6883
- direction: e("container"),
6884
- lg: e("item"),
6885
- md: e("item"),
6886
- sm: e("item"),
6887
- spacing: e("container"),
6888
- wrap: e("container"),
6889
- xs: e("item"),
6890
- zeroMinWidth: e("item")
6891
- });
6892
- }
6893
- function Gp({ Header: e, children: t }) {
6894
- return v.jsxs(bt, { container: !0, children: [e, v.jsx(bt, { item: !0, container: !0, xs: 12, sx: {
6895
- justifyContent: "center",
6896
- alignContent: "flex-start",
6897
- alignItems: "center",
6898
- pt: 8,
6899
- background: (r) => r.palette.neutral50,
6900
- minHeight: "100vh",
6901
- overflow: "auto"
6902
- }, "data-test-layout-details": "content-slot", children: v.jsx(bt, { item: !0, xs: 10, children: t }) })] });
6903
- }
6904
- class Gd {
6905
- constructor() {
6906
- sr(this, "BASE_ATTRIBUTE", 'data-test="ink-dialog"');
6907
- }
6908
- get element() {
6909
- return cy.get(`[${this.BASE_ATTRIBUTE}]`);
6910
- }
6911
- get paper() {
6912
- return this.element.find("[role=dialog]");
6913
- }
6914
- get primaryAction() {
6915
- return this.paper.find('[data-test="ink-dialog-primary-action"]');
6916
- }
6917
- get secondaryAction() {
6918
- return this.paper.find('[data-test="ink-dialog-secondary-action"]');
6919
- }
6920
- get cancelAction() {
6921
- return this.paper.find('[data-test="ink-dialog-cancel-action"]');
6922
- }
6923
- // NOTE:
6924
- // class SomeClass extends InkDialogPageObject {
6925
- // get dialogTrigger() {
6926
- // return cy.get('[data-test="_SPECIFIC_DIALOG_TRIGGER_"]');
6927
- // }
6928
- // ...
6929
- // }
6930
- get dialogTrigger() {
6931
- return cy.get('[data-test="ink-dialog-trigger"]');
6932
- }
6933
- get closeTrigger() {
6934
- return this.paper.find('[data-test="ink-dialog-close"]');
6935
- }
6936
- get title() {
6937
- return this.paper.find('[data-test="ink-dialog-title"]');
6938
- }
6939
- isOpen() {
6940
- cy.log("checking to see if dialog is open"), this.element.should("exist");
6941
- }
6942
- isClosed() {
6943
- cy.log("checking to see if dialog is closed"), this.element.should("not.exist");
6944
- }
6945
- openDialog() {
6946
- this.dialogTrigger.click();
6947
- }
6948
- closeDialog() {
6949
- this.closeTrigger.click();
6950
- }
6951
- hasPrimaryAction(t) {
6952
- this.primaryAction.should("have.text", t);
6953
- }
6954
- hasSecondaryAction(t) {
6955
- this.secondaryAction.should("have.text", t);
6956
- }
6957
- hasCancelAction(t) {
6958
- this.cancelAction.should("have.text", t);
6959
- }
6960
- hasTitle(t) {
6961
- this.title.should("have.text", t);
6962
- }
6963
- }
6964
- const qp = new Gd();
6965
- class Ra {
6966
- constructor(t) {
6967
- sr(this, "baseAttribute", "data-test-select");
6968
- sr(this, "name");
6969
- this.name = t;
6970
- }
6971
- static create(t) {
6972
- return new Ra(t);
6973
- }
6974
- get element() {
6975
- return cy.get(`[${this.baseAttribute}-root=${this.name}]`);
6976
- }
6977
- get menuElement() {
6978
- return cy.get(`[id=menu-${this.name}]`);
6979
- }
6980
- get label() {
6981
- return this.element.find(`[${this.baseAttribute}-label]`);
6982
- }
6983
- get select() {
6984
- return this.element.find(`[${this.baseAttribute}]`);
6985
- }
6986
- get input() {
6987
- return this.element.find(`[${this.baseAttribute}-input]`);
6988
- }
6989
- get options() {
6990
- return this.closeMenu(), this.openMenu(), this.menuElement.find(`[${this.baseAttribute}-menu-item]`);
6991
- }
6992
- option(t) {
6993
- return this.closeMenu(), cy.get("body").click(100, 0), this.openMenu(), this.menuElement.find(`[${this.baseAttribute}-menu-item=${t}]`);
6994
- }
6995
- get helperText() {
6996
- return this.element.find(`[${this.baseAttribute}-helper-text]`);
6997
- }
6998
- hasLabel(t) {
6999
- return this.label.should("have.text", t);
7000
- }
7001
- hasDisplayValue(t) {
7002
- return this.select.should("have.text", t);
7003
- }
7004
- hasValue(t) {
7005
- return this.input.should("have.value", t);
7006
- }
7007
- hasOption(t, r, n) {
7008
- const o = n !== void 0 ? this.options.eq(n) : this.option(r);
7009
- o.should("have.text", t), o.should("have.attr", "data-value", r);
7010
- }
7011
- closeMenu() {
7012
- cy.get("body").click(100, 0);
7013
- }
7014
- openMenu() {
7015
- this.select.click();
7016
- }
7017
- }
7018
- var Gn = {}, ln = {};
7019
- const qd = /* @__PURE__ */ lt(Df);
7020
- var ai;
7021
- function Vr() {
7022
- return ai || (ai = 1, function(e) {
7023
- "use client";
7024
- Object.defineProperty(e, "__esModule", {
7025
- value: !0
7026
- }), Object.defineProperty(e, "default", {
7027
- enumerable: !0,
7028
- get: function() {
7029
- return t.createSvgIcon;
7030
- }
7031
- });
7032
- var t = qd;
7033
- }(ln)), ln;
7034
- }
7035
- var Yd = At;
7036
- Object.defineProperty(Gn, "__esModule", {
7037
- value: !0
7038
- });
7039
- var $a = Gn.default = void 0, Hd = Yd(Vr()), Kd = v;
7040
- $a = Gn.default = (0, Hd.default)(/* @__PURE__ */ (0, Kd.jsx)("path", {
7041
- d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2M9.29 16.29 5.7 12.7a.9959.9959 0 0 1 0-1.41c.39-.39 1.02-.39 1.41 0L10 14.17l6.88-6.88c.39-.39 1.02-.39 1.41 0 .39.39.39 1.02 0 1.41l-7.59 7.59c-.38.39-1.02.39-1.41 0"
7042
- }), "CheckCircleRounded");
7043
- var qn = {}, Xd = At;
7044
- Object.defineProperty(qn, "__esModule", {
7045
- value: !0
7046
- });
7047
- var ka = qn.default = void 0, Jd = Xd(Vr()), Zd = v;
7048
- ka = qn.default = (0, Jd.default)(/* @__PURE__ */ (0, Zd.jsx)("path", {
7049
- d: "M14.9 3H9.1c-.53 0-1.04.21-1.42.59l-4.1 4.1C3.21 8.06 3 8.57 3 9.1v5.8c0 .53.21 1.04.59 1.41l4.1 4.1c.37.38.88.59 1.41.59h5.8c.53 0 1.04-.21 1.41-.59l4.1-4.1c.38-.37.59-.88.59-1.41V9.1c0-.53-.21-1.04-.59-1.41l-4.1-4.1c-.37-.38-.88-.59-1.41-.59m.64 12.54c-.39.39-1.02.39-1.41 0L12 13.41l-2.12 2.12c-.39.39-1.02.39-1.41 0a.9959.9959 0 0 1 0-1.41L10.59 12 8.46 9.88a.9959.9959 0 0 1 0-1.41c.39-.39 1.02-.39 1.41 0L12 10.59l2.12-2.12c.39-.39 1.02-.39 1.41 0 .39.39.39 1.02 0 1.41L13.41 12l2.12 2.12c.4.39.4 1.03.01 1.42"
7050
- }), "DangerousRounded");
7051
- var Yn = {}, Qd = At;
7052
- Object.defineProperty(Yn, "__esModule", {
7053
- value: !0
7054
- });
7055
- var Ma = Yn.default = void 0, ep = Qd(Vr()), tp = v;
7056
- Ma = Yn.default = (0, ep.default)(/* @__PURE__ */ (0, tp.jsx)("path", {
7057
- d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2m0 15c-.55 0-1-.45-1-1v-4c0-.55.45-1 1-1s1 .45 1 1v4c0 .55-.45 1-1 1m1-8h-2V7h2z"
7058
- }), "InfoRounded");
7059
- var Hn = {}, rp = At;
7060
- Object.defineProperty(Hn, "__esModule", {
7061
- value: !0
7062
- });
7063
- var Aa = Hn.default = void 0, np = rp(Vr()), op = v;
7064
- Aa = Hn.default = (0, np.default)(/* @__PURE__ */ (0, op.jsx)("path", {
7065
- d: "M12 5.99 19.53 19H4.47zM2.74 18c-.77 1.33.19 3 1.73 3h15.06c1.54 0 2.5-1.67 1.73-3L13.73 4.99c-.77-1.33-2.69-1.33-3.46 0zM11 11v2c0 .55.45 1 1 1s1-.45 1-1v-2c0-.55-.45-1-1-1s-1 .45-1 1m0 5h2v2h-2z"
7066
- }), "WarningAmberRounded");
7067
- const ip = {
7068
- MuiAlert: {
7069
- defaultProps: {
7070
- iconMapping: {
7071
- success: v.jsx($a, {}),
7072
- error: v.jsx(ka, {}),
7073
- info: v.jsx(Ma, {}),
7074
- warning: v.jsx(Aa, {})
7075
- }
7076
- },
7077
- variants: [
7078
- {
7079
- props: {
7080
- variant: "snackbar"
7081
- },
7082
- style: {
7083
- width: "100%"
7084
- }
7085
- }
7086
- ],
7087
- styleOverrides: {
7088
- root: {
7089
- "& .MuiAlert-action": {
7090
- gap: "16px",
7091
- // NOTE:
7092
- // To ensure `onClose` and the `action` attributes are styled the same
7093
- "> .MuiIconButton-root, > .MuiButton-root": {
7094
- padding: "4px",
7095
- color: "inherit"
7096
- },
7097
- "> .MuiButton-root": {
7098
- fontSize: "13px",
7099
- textTransform: "capitalize"
7100
- }
7101
- },
7102
- "& .MuiAlert-message": {
7103
- color: "black"
7104
- }
7105
- },
7106
- snackbar: ({ theme: e, ownerState: t }) => ({
7107
- color: "white",
7108
- backgroundColor: e.palette.neutral900,
7109
- "& .MuiAlert-message": {
7110
- color: "white"
7111
- },
7112
- "& .MuiAlert-icon": {
7113
- ...t.severity === "success" && {
7114
- color: e.palette.success.light
7115
- },
7116
- ...t.severity === "error" && {
7117
- color: e.palette.error.light
7118
- },
7119
- ...t.severity === "info" && {
7120
- color: e.palette.info.light
7121
- },
7122
- ...t.severity === "warning" && {
7123
- color: e.palette.warning.light
7124
- }
7125
- },
7126
- "& .MuiAlert-action": {
7127
- "> .MuiButton-root": {
7128
- color: e.palette.blueA100
7129
- }
7130
- }
7131
- })
7132
- }
7133
- }
7134
- }, ap = {
7135
- MuiAutocomplete: {
7136
- defaultProps: {
7137
- ChipProps: {
7138
- size: "small",
7139
- color: "primary"
7140
- }
7141
- },
7142
- styleOverrides: {
7143
- root: ({ theme: e }) => ({
7144
- ".MuiChip-root": {
7145
- margin: 0
7146
- },
7147
- '& .MuiAutocomplete-inputRoot[class*="Mui-disabled"]': {
7148
- backgroundColor: e.palette.neutral300,
7149
- cursor: "not-allowed"
7150
- }
7151
- }),
7152
- option: ({ theme: e }) => ({
7153
- "&.MuiAutocomplete-option.MuiAutocomplete-option": {
7154
- "&.Mui-focused": {
7155
- backgroundColor: e.palette.primary.selected
7156
- },
7157
- '&[aria-selected="true"]': {
7158
- backgroundColor: e.palette.primary.selected
7159
- }
7160
- }
7161
- }),
7162
- inputRoot: ({ theme: e }) => ({
7163
- "&.MuiInputBase-hiddenLabel": {
7164
- padding: e.spacing(1, 1.5),
7165
- "& .MuiAutocomplete-input": {
7166
- padding: e.spacing(0)
7167
- }
7168
- },
7169
- "&.MuiInputBase-hiddenLabel.MuiInputBase-sizeSmall": {
7170
- paddingTop: e.spacing(0.5),
7171
- paddingBottom: e.spacing(0.5),
7172
- paddingLeft: e.spacing(1),
7173
- "& .MuiAutocomplete-input": {
7174
- padding: e.spacing(0)
7175
- }
7176
- },
7177
- gap: e.spacing(1)
7178
- }),
7179
- paper: {
7180
- padding: 0
7181
- },
7182
- listbox: {
7183
- maxHeight: 400
7184
- }
7185
- }
7186
- }
7187
- }, sp = {
7188
- MuiDialog: {
7189
- defaultProps: {
7190
- maxWidth: "xs",
7191
- fullWidth: !0,
7192
- scroll: "paper"
7193
- },
7194
- styleOverrides: {
7195
- paper: {
7196
- padding: 0
7197
- }
7198
- }
7199
- },
7200
- MuiDialogTitle: {
7201
- defaultProps: {
7202
- variant: "h6"
7203
- },
7204
- styleOverrides: {
7205
- root: {
7206
- fontWeight: 500
7207
- }
7208
- }
7209
- },
7210
- MuiDialogActions: {
7211
- styleOverrides: {
7212
- root: {
7213
- padding: "16px"
7214
- }
7215
- }
7216
- }
7217
- }, cp = {
7218
- MuiDrawer: {
7219
- styleOverrides: {
7220
- paper: {
7221
- padding: 0
7222
- }
7223
- }
7224
- }
7225
- }, lp = {
7226
- MuiStepper: {
7227
- styleOverrides: {
7228
- root: ({ theme: e }) => ({
7229
- justifyContent: "center",
7230
- gap: e.spacing(0.5)
7231
- })
7232
- }
7233
- },
7234
- MuiStep: {
7235
- styleOverrides: {
7236
- root: ({ theme: e, ownerState: t }) => ({
7237
- padding: 0,
7238
- whiteSpace: "nowrap",
7239
- "> .MuiStepButton-root": {
7240
- ...e.typography.body2,
7241
- padding: "8px 20px",
7242
- "&.MuiButtonBase-root": {
7243
- boxSizing: "border-box",
7244
- width: "unset",
7245
- margin: 0,
7246
- backgroundColor: "white",
7247
- borderRadius: 100,
7248
- border: `1px solid ${e.palette.neutral300}`,
7249
- ...t.active && {
7250
- border: `2px solid ${e.palette.primary.main}`,
7251
- // NOTE:
7252
- // These not selectors are useed to NOT inherit the active color if present. If you need to expand this see the other color variants of icons here: https://mui.com/material-ui/api/icon/
7253
- "& .MuiIcon-root:not(.MuiIcon-colorSuccess):not(.MuiIcon-colorWarning):not(.MuiIcon-colorError)": {
7254
- color: e.palette.primary.main
7255
- }
7256
- },
7257
- "&:disabled, &:hover": {
7258
- backgroundColor: e.palette.neutral200
7259
- },
7260
- "& .MuiStepLabel-labelContainer": {
7261
- color: e.palette.text.primary,
7262
- textTransform: "capitalize"
7263
- }
7264
- }
7265
- }
7266
- })
7267
- }
7268
- },
7269
- MuiStepConnector: {
7270
- styleOverrides: {
7271
- root: {
7272
- flex: "0 1 28px"
7273
- },
7274
- line: {
7275
- borderColor: "netural300",
7276
- borderWidth: "1px"
7277
- }
7278
- }
7279
- },
7280
- MuiStepButton: {
7281
- styleOverrides: {
7282
- root: ({ ownerState: e }) => ({
7283
- ...!e.icon && {
7284
- "& .MuiStepLabel-iconContainer": {
7285
- display: "none"
7286
- }
7287
- }
7288
- })
7289
- }
7290
- }
7291
- };
7292
- function On(e, t) {
7293
- return On = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, n) {
7294
- return r.__proto__ = n, r;
7295
- }, On(e, t);
7296
- }
7297
- function up(e, t) {
7298
- e.prototype = Object.create(t.prototype), e.prototype.constructor = e, On(e, t);
7299
- }
7300
- const si = {
7301
- disabled: !1
7302
- };
7303
- var fp = process.env.NODE_ENV !== "production" ? l.oneOfType([l.number, l.shape({
7304
- enter: l.number,
7305
- exit: l.number,
7306
- appear: l.number
7307
- }).isRequired]) : null;
7308
- process.env.NODE_ENV !== "production" && l.oneOfType([l.string, l.shape({
7309
- enter: l.string,
7310
- exit: l.string,
7311
- active: l.string
7312
- }), l.shape({
7313
- enter: l.string,
7314
- enterDone: l.string,
7315
- enterActive: l.string,
7316
- exit: l.string,
7317
- exitDone: l.string,
7318
- exitActive: l.string
7319
- })]);
7320
- const Pa = gt.createContext(null);
7321
- var dp = function(t) {
7322
- return t.scrollTop;
7323
- }, Wt = "unmounted", mt = "exited", ht = "entering", Ot = "entered", wn = "exiting", ut = /* @__PURE__ */ function(e) {
7324
- up(t, e);
7325
- function t(n, o) {
7326
- var i;
7327
- i = e.call(this, n, o) || this;
7328
- var a = o, s = a && !a.isMounting ? n.enter : n.appear, c;
7329
- return i.appearStatus = null, n.in ? s ? (c = mt, i.appearStatus = ht) : c = Ot : n.unmountOnExit || n.mountOnEnter ? c = Wt : c = mt, i.state = {
7330
- status: c
7331
- }, i.nextCallback = null, i;
7332
- }
7333
- t.getDerivedStateFromProps = function(o, i) {
7334
- var a = o.in;
7335
- return a && i.status === Wt ? {
7336
- status: mt
7337
- } : null;
7338
- };
7339
- var r = t.prototype;
7340
- return r.componentDidMount = function() {
7341
- this.updateStatus(!0, this.appearStatus);
7342
- }, r.componentDidUpdate = function(o) {
7343
- var i = null;
7344
- if (o !== this.props) {
7345
- var a = this.state.status;
7346
- this.props.in ? a !== ht && a !== Ot && (i = ht) : (a === ht || a === Ot) && (i = wn);
7347
- }
7348
- this.updateStatus(!1, i);
7349
- }, r.componentWillUnmount = function() {
7350
- this.cancelNextCallback();
7351
- }, r.getTimeouts = function() {
7352
- var o = this.props.timeout, i, a, s;
7353
- return i = a = s = o, o != null && typeof o != "number" && (i = o.exit, a = o.enter, s = o.appear !== void 0 ? o.appear : a), {
7354
- exit: i,
7355
- enter: a,
7356
- appear: s
7357
- };
7358
- }, r.updateStatus = function(o, i) {
7359
- if (o === void 0 && (o = !1), i !== null)
7360
- if (this.cancelNextCallback(), i === ht) {
7361
- if (this.props.unmountOnExit || this.props.mountOnEnter) {
7362
- var a = this.props.nodeRef ? this.props.nodeRef.current : cr.findDOMNode(this);
7363
- a && dp(a);
7364
- }
7365
- this.performEnter(o);
7366
- } else
7367
- this.performExit();
7368
- else this.props.unmountOnExit && this.state.status === mt && this.setState({
7369
- status: Wt
7370
- });
7371
- }, r.performEnter = function(o) {
7372
- var i = this, a = this.props.enter, s = this.context ? this.context.isMounting : o, c = this.props.nodeRef ? [s] : [cr.findDOMNode(this), s], u = c[0], f = c[1], h = this.getTimeouts(), m = s ? h.appear : h.enter;
7373
- if (!o && !a || si.disabled) {
7374
- this.safeSetState({
7375
- status: Ot
7376
- }, function() {
7377
- i.props.onEntered(u);
7378
- });
7379
- return;
7380
- }
7381
- this.props.onEnter(u, f), this.safeSetState({
7382
- status: ht
7383
- }, function() {
7384
- i.props.onEntering(u, f), i.onTransitionEnd(m, function() {
7385
- i.safeSetState({
7386
- status: Ot
7387
- }, function() {
7388
- i.props.onEntered(u, f);
7389
- });
7390
- });
7391
- });
7392
- }, r.performExit = function() {
7393
- var o = this, i = this.props.exit, a = this.getTimeouts(), s = this.props.nodeRef ? void 0 : cr.findDOMNode(this);
7394
- if (!i || si.disabled) {
7395
- this.safeSetState({
7396
- status: mt
7397
- }, function() {
7398
- o.props.onExited(s);
7399
- });
7400
- return;
7401
- }
7402
- this.props.onExit(s), this.safeSetState({
7403
- status: wn
7404
- }, function() {
7405
- o.props.onExiting(s), o.onTransitionEnd(a.exit, function() {
7406
- o.safeSetState({
7407
- status: mt
7408
- }, function() {
7409
- o.props.onExited(s);
7410
- });
7411
- });
7412
- });
7413
- }, r.cancelNextCallback = function() {
7414
- this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
7415
- }, r.safeSetState = function(o, i) {
7416
- i = this.setNextCallback(i), this.setState(o, i);
7417
- }, r.setNextCallback = function(o) {
7418
- var i = this, a = !0;
7419
- return this.nextCallback = function(s) {
7420
- a && (a = !1, i.nextCallback = null, o(s));
7421
- }, this.nextCallback.cancel = function() {
7422
- a = !1;
7423
- }, this.nextCallback;
7424
- }, r.onTransitionEnd = function(o, i) {
7425
- this.setNextCallback(i);
7426
- var a = this.props.nodeRef ? this.props.nodeRef.current : cr.findDOMNode(this), s = o == null && !this.props.addEndListener;
7427
- if (!a || s) {
7428
- setTimeout(this.nextCallback, 0);
7429
- return;
7430
- }
7431
- if (this.props.addEndListener) {
7432
- var c = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], u = c[0], f = c[1];
7433
- this.props.addEndListener(u, f);
7434
- }
7435
- o != null && setTimeout(this.nextCallback, o);
7436
- }, r.render = function() {
7437
- var o = this.state.status;
7438
- if (o === Wt)
7439
- return null;
7440
- var i = this.props, a = i.children;
7441
- i.in, i.mountOnEnter, i.unmountOnExit, i.appear, i.enter, i.exit, i.timeout, i.addEndListener, i.onEnter, i.onEntering, i.onEntered, i.onExit, i.onExiting, i.onExited, i.nodeRef;
7442
- var s = je(i, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
7443
- return (
7444
- // allows for nested Transitions
7445
- /* @__PURE__ */ gt.createElement(Pa.Provider, {
7446
- value: null
7447
- }, typeof a == "function" ? a(o, s) : gt.cloneElement(gt.Children.only(a), s))
7448
- );
7449
- }, t;
7450
- }(gt.Component);
7451
- ut.contextType = Pa;
7452
- ut.propTypes = process.env.NODE_ENV !== "production" ? {
7453
- /**
7454
- * A React reference to DOM element that need to transition:
7455
- * https://stackoverflow.com/a/51127130/4671932
7456
- *
7457
- * - When `nodeRef` prop is used, `node` is not passed to callback functions
7458
- * (e.g. `onEnter`) because user already has direct access to the node.
7459
- * - When changing `key` prop of `Transition` in a `TransitionGroup` a new
7460
- * `nodeRef` need to be provided to `Transition` with changed `key` prop
7461
- * (see
7462
- * [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
7463
- */
7464
- nodeRef: l.shape({
7465
- current: typeof Element > "u" ? l.any : function(e, t, r, n, o, i) {
7466
- var a = e[t];
7467
- return l.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(e, t, r, n, o, i);
7468
- }
7469
- }),
7470
- /**
7471
- * A `function` child can be used instead of a React element. This function is
7472
- * called with the current transition status (`'entering'`, `'entered'`,
7473
- * `'exiting'`, `'exited'`), which can be used to apply context
7474
- * specific props to a component.
7475
- *
7476
- * ```jsx
7477
- * <Transition in={this.state.in} timeout={150}>
7478
- * {state => (
7479
- * <MyComponent className={`fade fade-${state}`} />
7480
- * )}
7481
- * </Transition>
7482
- * ```
7483
- */
7484
- children: l.oneOfType([l.func.isRequired, l.element.isRequired]).isRequired,
7485
- /**
7486
- * Show the component; triggers the enter or exit states
7487
- */
7488
- in: l.bool,
7489
- /**
7490
- * By default the child component is mounted immediately along with
7491
- * the parent `Transition` component. If you want to "lazy mount" the component on the
7492
- * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
7493
- * mounted, even on "exited", unless you also specify `unmountOnExit`.
7494
- */
7495
- mountOnEnter: l.bool,
7496
- /**
7497
- * By default the child component stays mounted after it reaches the `'exited'` state.
7498
- * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
7499
- */
7500
- unmountOnExit: l.bool,
7501
- /**
7502
- * By default the child component does not perform the enter transition when
7503
- * it first mounts, regardless of the value of `in`. If you want this
7504
- * behavior, set both `appear` and `in` to `true`.
7505
- *
7506
- * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
7507
- * > only adds an additional enter transition. However, in the
7508
- * > `<CSSTransition>` component that first enter transition does result in
7509
- * > additional `.appear-*` classes, that way you can choose to style it
7510
- * > differently.
7511
- */
7512
- appear: l.bool,
7513
- /**
7514
- * Enable or disable enter transitions.
7515
- */
7516
- enter: l.bool,
7517
- /**
7518
- * Enable or disable exit transitions.
7519
- */
7520
- exit: l.bool,
7521
- /**
7522
- * The duration of the transition, in milliseconds.
7523
- * Required unless `addEndListener` is provided.
7524
- *
7525
- * You may specify a single timeout for all transitions:
7526
- *
7527
- * ```jsx
7528
- * timeout={500}
7529
- * ```
7530
- *
7531
- * or individually:
7532
- *
7533
- * ```jsx
7534
- * timeout={{
7535
- * appear: 500,
7536
- * enter: 300,
7537
- * exit: 500,
7538
- * }}
7539
- * ```
7540
- *
7541
- * - `appear` defaults to the value of `enter`
7542
- * - `enter` defaults to `0`
7543
- * - `exit` defaults to `0`
7544
- *
7545
- * @type {number | { enter?: number, exit?: number, appear?: number }}
7546
- */
7547
- timeout: function(t) {
7548
- var r = fp;
7549
- t.addEndListener || (r = r.isRequired);
7550
- for (var n = arguments.length, o = new Array(n > 1 ? n - 1 : 0), i = 1; i < n; i++)
7551
- o[i - 1] = arguments[i];
7552
- return r.apply(void 0, [t].concat(o));
7553
- },
7554
- /**
7555
- * Add a custom transition end trigger. Called with the transitioning
7556
- * DOM node and a `done` callback. Allows for more fine grained transition end
7557
- * logic. Timeouts are still used as a fallback if provided.
7558
- *
7559
- * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7560
- *
7561
- * ```jsx
7562
- * addEndListener={(node, done) => {
7563
- * // use the css transitionend event to mark the finish of a transition
7564
- * node.addEventListener('transitionend', done, false);
7565
- * }}
7566
- * ```
7567
- */
7568
- addEndListener: l.func,
7569
- /**
7570
- * Callback fired before the "entering" status is applied. An extra parameter
7571
- * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
7572
- *
7573
- * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7574
- *
7575
- * @type Function(node: HtmlElement, isAppearing: bool) -> void
7576
- */
7577
- onEnter: l.func,
7578
- /**
7579
- * Callback fired after the "entering" status is applied. An extra parameter
7580
- * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
7581
- *
7582
- * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7583
- *
7584
- * @type Function(node: HtmlElement, isAppearing: bool)
7585
- */
7586
- onEntering: l.func,
7587
- /**
7588
- * Callback fired after the "entered" status is applied. An extra parameter
7589
- * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
7590
- *
7591
- * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7592
- *
7593
- * @type Function(node: HtmlElement, isAppearing: bool) -> void
7594
- */
7595
- onEntered: l.func,
7596
- /**
7597
- * Callback fired before the "exiting" status is applied.
7598
- *
7599
- * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7600
- *
7601
- * @type Function(node: HtmlElement) -> void
7602
- */
7603
- onExit: l.func,
7604
- /**
7605
- * Callback fired after the "exiting" status is applied.
7606
- *
7607
- * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7608
- *
7609
- * @type Function(node: HtmlElement) -> void
7610
- */
7611
- onExiting: l.func,
7612
- /**
7613
- * Callback fired after the "exited" status is applied.
7614
- *
7615
- * **Note**: when `nodeRef` prop is passed, `node` is not passed
7616
- *
7617
- * @type Function(node: HtmlElement) -> void
7618
- */
7619
- onExited: l.func
7620
- } : {};
7621
- function _t() {
7622
- }
7623
- ut.defaultProps = {
7624
- in: !1,
7625
- mountOnEnter: !1,
7626
- unmountOnExit: !1,
7627
- appear: !1,
7628
- enter: !0,
7629
- exit: !0,
7630
- onEnter: _t,
7631
- onEntering: _t,
7632
- onEntered: _t,
7633
- onExit: _t,
7634
- onExiting: _t,
7635
- onExited: _t
7636
- };
7637
- ut.UNMOUNTED = Wt;
7638
- ut.EXITED = mt;
7639
- ut.ENTERING = ht;
7640
- ut.ENTERED = Ot;
7641
- ut.EXITING = wn;
7642
- const pp = (e) => e.scrollTop;
7643
- function ci(e, t) {
7644
- var r, n;
7645
- const {
7646
- timeout: o,
7647
- easing: i,
7648
- style: a = {}
7649
- } = e;
7650
- return {
7651
- duration: (r = a.transitionDuration) != null ? r : typeof o == "number" ? o : o[t.mode] || 0,
7652
- easing: (n = a.transitionTimingFunction) != null ? n : typeof i == "object" ? i[t.mode] : i,
7653
- delay: a.transitionDelay
7654
- };
7655
- }
7656
- const mp = ["addEndListener", "appear", "children", "container", "direction", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"];
7657
- function hp(e, t, r) {
7658
- const n = t.getBoundingClientRect(), o = r && r.getBoundingClientRect(), i = Mn(t);
7659
- let a;
7660
- if (t.fakeTransform)
7661
- a = t.fakeTransform;
7662
- else {
7663
- const u = i.getComputedStyle(t);
7664
- a = u.getPropertyValue("-webkit-transform") || u.getPropertyValue("transform");
7665
- }
7666
- let s = 0, c = 0;
7667
- if (a && a !== "none" && typeof a == "string") {
7668
- const u = a.split("(")[1].split(")")[0].split(",");
7669
- s = parseInt(u[4], 10), c = parseInt(u[5], 10);
7670
- }
7671
- return e === "left" ? o ? `translateX(${o.right + s - n.left}px)` : `translateX(${i.innerWidth + s - n.left}px)` : e === "right" ? o ? `translateX(-${n.right - o.left - s}px)` : `translateX(-${n.left + n.width - s}px)` : e === "up" ? o ? `translateY(${o.bottom + c - n.top}px)` : `translateY(${i.innerHeight + c - n.top}px)` : o ? `translateY(-${n.top - o.top + n.height - c}px)` : `translateY(-${n.top + n.height - c}px)`;
7672
- }
7673
- function ja(e) {
7674
- return typeof e == "function" ? e() : e;
7675
- }
7676
- function mr(e, t, r) {
7677
- const n = ja(r), o = hp(e, t, n);
7678
- o && (t.style.webkitTransform = o, t.style.transform = o);
7679
- }
7680
- const Ia = /* @__PURE__ */ I.forwardRef(function(t, r) {
7681
- const n = Un(), o = {
7682
- enter: n.transitions.easing.easeOut,
7683
- exit: n.transitions.easing.sharp
7684
- }, i = {
7685
- enter: n.transitions.duration.enteringScreen,
7686
- exit: n.transitions.duration.leavingScreen
7687
- }, {
7688
- addEndListener: a,
7689
- appear: s = !0,
7690
- children: c,
7691
- container: u,
7692
- direction: f = "down",
7693
- easing: h = o,
7694
- in: m,
7695
- onEnter: b,
7696
- onEntered: x,
7697
- onEntering: g,
7698
- onExit: y,
7699
- onExited: T,
7700
- onExiting: w,
7701
- style: O,
7702
- timeout: k = i,
7703
- // eslint-disable-next-line react/prop-types
7704
- TransitionComponent: p = ut
7705
- } = t, j = je(t, mp), P = I.useRef(null), fe = ki(c.ref, P, r), te = (z) => (he) => {
7706
- z && (he === void 0 ? z(P.current) : z(P.current, he));
7707
- }, ue = te((z, he) => {
7708
- mr(f, z, u), pp(z), b && b(z, he);
7709
- }), V = te((z, he) => {
7710
- const C = ci({
7711
- timeout: k,
7712
- style: O,
7713
- easing: h
7714
- }, {
7715
- mode: "enter"
7716
- });
7717
- z.style.webkitTransition = n.transitions.create("-webkit-transform", M({}, C)), z.style.transition = n.transitions.create("transform", M({}, C)), z.style.webkitTransform = "none", z.style.transform = "none", g && g(z, he);
7718
- }), X = te(x), Z = te(w), re = te((z) => {
7719
- const he = ci({
7720
- timeout: k,
7721
- style: O,
7722
- easing: h
7723
- }, {
7724
- mode: "exit"
7725
- });
7726
- z.style.webkitTransition = n.transitions.create("-webkit-transform", he), z.style.transition = n.transitions.create("transform", he), mr(f, z, u), y && y(z);
7727
- }), Re = te((z) => {
7728
- z.style.webkitTransition = "", z.style.transition = "", T && T(z);
7729
- }), ve = (z) => {
7730
- a && a(P.current, z);
7731
- }, Ae = I.useCallback(() => {
7732
- P.current && mr(f, P.current, u);
7733
- }, [f, u]);
7734
- return I.useEffect(() => {
7735
- if (m || f === "down" || f === "right")
7736
- return;
7737
- const z = _i(() => {
7738
- P.current && mr(f, P.current, u);
7739
- }), he = Mn(P.current);
7740
- return he.addEventListener("resize", z), () => {
7741
- z.clear(), he.removeEventListener("resize", z);
7742
- };
7743
- }, [f, m, u]), I.useEffect(() => {
7744
- m || Ae();
7745
- }, [m, Ae]), /* @__PURE__ */ v.jsx(p, M({
7746
- nodeRef: P,
7747
- onEnter: ue,
7748
- onEntered: X,
7749
- onEntering: V,
7750
- onExit: re,
7751
- onExited: Re,
7752
- onExiting: Z,
7753
- addEndListener: ve,
7754
- appear: s,
7755
- in: m,
7756
- timeout: k
7757
- }, j, {
7758
- children: (z, he) => /* @__PURE__ */ I.cloneElement(c, M({
7759
- ref: fe,
7760
- style: M({
7761
- visibility: z === "exited" && !m ? "hidden" : void 0
7762
- }, O, c.props.style)
7763
- }, he))
7764
- }));
7765
- });
7766
- process.env.NODE_ENV !== "production" && (Ia.propTypes = {
7767
- // ┌────────────────────────────── Warning ──────────────────────────────┐
7768
- // │ These PropTypes are generated from the TypeScript type definitions. │
7769
- // │ To update them, edit the d.ts file and run `pnpm proptypes`. │
7770
- // └─────────────────────────────────────────────────────────────────────┘
7771
- /**
7772
- * Add a custom transition end trigger. Called with the transitioning DOM
7773
- * node and a done callback. Allows for more fine grained transition end
7774
- * logic. Note: Timeouts are still used as a fallback if provided.
7775
- */
7776
- addEndListener: l.func,
7777
- /**
7778
- * Perform the enter transition when it first mounts if `in` is also `true`.
7779
- * Set this to `false` to disable this behavior.
7780
- * @default true
7781
- */
7782
- appear: l.bool,
7783
- /**
7784
- * A single child content element.
7785
- */
7786
- children: Ei.isRequired,
7787
- /**
7788
- * An HTML element, or a function that returns one.
7789
- * It's used to set the container the Slide is transitioning from.
7790
- */
7791
- container: wr(l.oneOfType([Xs, l.func]), (e) => {
7792
- if (e.open) {
7793
- const t = ja(e.container);
7794
- if (t && t.nodeType === 1) {
7795
- const r = t.getBoundingClientRect();
7796
- if (process.env.NODE_ENV !== "test" && r.top === 0 && r.left === 0 && r.right === 0 && r.bottom === 0)
7797
- return new Error(["MUI: The `container` prop provided to the component is invalid.", "The anchor element should be part of the document layout.", "Make sure the element is present in the document or that it's not display none."].join(`
7798
- `));
7799
- } else if (!t || typeof t.getBoundingClientRect != "function" || t.contextElement != null && t.contextElement.nodeType !== 1)
7800
- return new Error(["MUI: The `container` prop provided to the component is invalid.", "It should be an HTML element instance."].join(`
7801
- `));
7802
- }
7803
- return null;
7804
- }),
7805
- /**
7806
- * Direction the child node will enter from.
7807
- * @default 'down'
7808
- */
7809
- direction: l.oneOf(["down", "left", "right", "up"]),
7810
- /**
7811
- * The transition timing function.
7812
- * You may specify a single easing or a object containing enter and exit values.
7813
- * @default {
7814
- * enter: theme.transitions.easing.easeOut,
7815
- * exit: theme.transitions.easing.sharp,
7816
- * }
7817
- */
7818
- easing: l.oneOfType([l.shape({
7819
- enter: l.string,
7820
- exit: l.string
7821
- }), l.string]),
7822
- /**
7823
- * If `true`, the component will transition in.
7824
- */
7825
- in: l.bool,
7826
- /**
7827
- * @ignore
7828
- */
7829
- onEnter: l.func,
7830
- /**
7831
- * @ignore
7832
- */
7833
- onEntered: l.func,
7834
- /**
7835
- * @ignore
7836
- */
7837
- onEntering: l.func,
7838
- /**
7839
- * @ignore
7840
- */
7841
- onExit: l.func,
7842
- /**
7843
- * @ignore
7844
- */
7845
- onExited: l.func,
7846
- /**
7847
- * @ignore
7848
- */
7849
- onExiting: l.func,
7850
- /**
7851
- * @ignore
7852
- */
7853
- style: l.object,
7854
- /**
7855
- * The duration for the transition, in milliseconds.
7856
- * You may specify a single timeout for all transitions, or individually with an object.
7857
- * @default {
7858
- * enter: theme.transitions.duration.enteringScreen,
7859
- * exit: theme.transitions.duration.leavingScreen,
7860
- * }
7861
- */
7862
- timeout: l.oneOfType([l.number, l.shape({
7863
- appear: l.number,
7864
- enter: l.number,
7865
- exit: l.number
7866
- })])
7867
- });
7868
- const gp = {
7869
- MuiSnackbar: {
7870
- defaultProps: {
7871
- anchorOrigin: {
7872
- horizontal: "center",
7873
- vertical: "bottom"
7874
- },
7875
- TransitionComponent: Ia
7876
- }
7877
- }
7878
- }, yp = {
7879
- MuiTypography: {
7880
- styleOverrides: {
7881
- root: ({ ownerState: e }) => ({
7882
- // bold weight
7883
- ...(e.component === "strong" || e.component === "b") && {
7884
- fontWeight: 600
7885
- }
7886
- }),
7887
- overline: ({ theme: e }) => ({
7888
- color: e.palette.text.secondary
7889
- })
7890
- }
7891
- }
7892
- }, Fe = {
6435
+ const Fe = {
7893
6436
  50: "#ede7f6",
7894
6437
  100: "#d1c4e9",
7895
6438
  200: "#b39ddb",
@@ -8189,41 +6732,1500 @@ const gp = {
8189
6732
  contrastText: N.neutral00,
8190
6733
  hover: We(ye[700], 0.04)
8191
6734
  },
8192
- warning: {
8193
- main: Ie[900],
8194
- dark: N.yellow1000,
8195
- light: Ie[800],
8196
- contrastText: N.neutral00
6735
+ warning: {
6736
+ main: Ie[900],
6737
+ dark: N.yellow1000,
6738
+ light: Ie[800],
6739
+ contrastText: N.neutral00
6740
+ },
6741
+ info: {
6742
+ main: me.A700,
6743
+ dark: me[900],
6744
+ light: me.A400,
6745
+ contrastText: N.neutral00
6746
+ },
6747
+ ai: {
6748
+ main: Fe.A700,
6749
+ dark: N.deepPurpleA800,
6750
+ contrastText: N.neutral00
6751
+ },
6752
+ inProgress: {
6753
+ main: ft.A700,
6754
+ dark: N.greenA900,
6755
+ contrastText: N.neutral00
6756
+ },
6757
+ success: {
6758
+ main: N.greenA900,
6759
+ dark: ft[700],
6760
+ light: N.greenA700,
6761
+ contrastText: N.neutral00
6762
+ },
6763
+ action: {
6764
+ active: Oe[700],
6765
+ hover: We(Oe[700], 0.04),
6766
+ selected: We(Oe[700], 0.08),
6767
+ focus: We(Oe[700], 0.12),
6768
+ disabledBackground: Oe[200],
6769
+ disabled: Oe[700]
6770
+ }
6771
+ }, _n = /* @__PURE__ */ I.createContext();
6772
+ process.env.NODE_ENV !== "production" && (_n.displayName = "GridContext");
6773
+ function Ad(e) {
6774
+ return St("MuiGrid", e);
6775
+ }
6776
+ const Pd = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], jd = ["column-reverse", "column", "row-reverse", "row"], Id = ["nowrap", "wrap-reverse", "wrap"], Lt = ["auto", !0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], Kt = $r("MuiGrid", [
6777
+ "root",
6778
+ "container",
6779
+ "item",
6780
+ "zeroMinWidth",
6781
+ // spacings
6782
+ ...Pd.map((e) => `spacing-xs-${e}`),
6783
+ // direction values
6784
+ ...jd.map((e) => `direction-xs-${e}`),
6785
+ // wrap values
6786
+ ...Id.map((e) => `wrap-xs-${e}`),
6787
+ // grid sizes for all breakpoints
6788
+ ...Lt.map((e) => `grid-xs-${e}`),
6789
+ ...Lt.map((e) => `grid-sm-${e}`),
6790
+ ...Lt.map((e) => `grid-md-${e}`),
6791
+ ...Lt.map((e) => `grid-lg-${e}`),
6792
+ ...Lt.map((e) => `grid-xl-${e}`)
6793
+ ]), Nd = ["className", "columns", "columnSpacing", "component", "container", "direction", "item", "rowSpacing", "spacing", "wrap", "zeroMinWidth"];
6794
+ function $t(e) {
6795
+ const t = parseFloat(e);
6796
+ return `${t}${String(e).replace(String(t), "") || "px"}`;
6797
+ }
6798
+ function Dd({
6799
+ theme: e,
6800
+ ownerState: t
6801
+ }) {
6802
+ let r;
6803
+ return e.breakpoints.keys.reduce((n, o) => {
6804
+ let i = {};
6805
+ if (t[o] && (r = t[o]), !r)
6806
+ return n;
6807
+ if (r === !0)
6808
+ i = {
6809
+ flexBasis: 0,
6810
+ flexGrow: 1,
6811
+ maxWidth: "100%"
6812
+ };
6813
+ else if (r === "auto")
6814
+ i = {
6815
+ flexBasis: "auto",
6816
+ flexGrow: 0,
6817
+ flexShrink: 0,
6818
+ maxWidth: "none",
6819
+ width: "auto"
6820
+ };
6821
+ else {
6822
+ const a = vt({
6823
+ values: t.columns,
6824
+ breakpoints: e.breakpoints.values
6825
+ }), s = typeof a == "object" ? a[o] : a;
6826
+ if (s == null)
6827
+ return n;
6828
+ const c = `${Math.round(r / s * 1e8) / 1e6}%`;
6829
+ let u = {};
6830
+ if (t.container && t.item && t.columnSpacing !== 0) {
6831
+ const f = e.spacing(t.columnSpacing);
6832
+ if (f !== "0px") {
6833
+ const h = `calc(${c} + ${$t(f)})`;
6834
+ u = {
6835
+ flexBasis: h,
6836
+ maxWidth: h
6837
+ };
6838
+ }
6839
+ }
6840
+ i = M({
6841
+ flexBasis: c,
6842
+ flexGrow: 0,
6843
+ maxWidth: c
6844
+ }, u);
6845
+ }
6846
+ return e.breakpoints.values[o] === 0 ? Object.assign(n, i) : n[e.breakpoints.up(o)] = i, n;
6847
+ }, {});
6848
+ }
6849
+ function Fd({
6850
+ theme: e,
6851
+ ownerState: t
6852
+ }) {
6853
+ const r = vt({
6854
+ values: t.direction,
6855
+ breakpoints: e.breakpoints.values
6856
+ });
6857
+ return Ge({
6858
+ theme: e
6859
+ }, r, (n) => {
6860
+ const o = {
6861
+ flexDirection: n
6862
+ };
6863
+ return n.indexOf("column") === 0 && (o[`& > .${Kt.item}`] = {
6864
+ maxWidth: "none"
6865
+ }), o;
6866
+ });
6867
+ }
6868
+ function wa({
6869
+ breakpoints: e,
6870
+ values: t
6871
+ }) {
6872
+ let r = "";
6873
+ Object.keys(t).forEach((o) => {
6874
+ r === "" && t[o] !== 0 && (r = o);
6875
+ });
6876
+ const n = Object.keys(e).sort((o, i) => e[o] - e[i]);
6877
+ return n.slice(0, n.indexOf(r));
6878
+ }
6879
+ function Bd({
6880
+ theme: e,
6881
+ ownerState: t
6882
+ }) {
6883
+ const {
6884
+ container: r,
6885
+ rowSpacing: n
6886
+ } = t;
6887
+ let o = {};
6888
+ if (r && n !== 0) {
6889
+ const i = vt({
6890
+ values: n,
6891
+ breakpoints: e.breakpoints.values
6892
+ });
6893
+ let a;
6894
+ typeof i == "object" && (a = wa({
6895
+ breakpoints: e.breakpoints.values,
6896
+ values: i
6897
+ })), o = Ge({
6898
+ theme: e
6899
+ }, i, (s, c) => {
6900
+ var u;
6901
+ const f = e.spacing(s);
6902
+ return f !== "0px" ? {
6903
+ marginTop: `-${$t(f)}`,
6904
+ [`& > .${Kt.item}`]: {
6905
+ paddingTop: $t(f)
6906
+ }
6907
+ } : (u = a) != null && u.includes(c) ? {} : {
6908
+ marginTop: 0,
6909
+ [`& > .${Kt.item}`]: {
6910
+ paddingTop: 0
6911
+ }
6912
+ };
6913
+ });
6914
+ }
6915
+ return o;
6916
+ }
6917
+ function zd({
6918
+ theme: e,
6919
+ ownerState: t
6920
+ }) {
6921
+ const {
6922
+ container: r,
6923
+ columnSpacing: n
6924
+ } = t;
6925
+ let o = {};
6926
+ if (r && n !== 0) {
6927
+ const i = vt({
6928
+ values: n,
6929
+ breakpoints: e.breakpoints.values
6930
+ });
6931
+ let a;
6932
+ typeof i == "object" && (a = wa({
6933
+ breakpoints: e.breakpoints.values,
6934
+ values: i
6935
+ })), o = Ge({
6936
+ theme: e
6937
+ }, i, (s, c) => {
6938
+ var u;
6939
+ const f = e.spacing(s);
6940
+ return f !== "0px" ? {
6941
+ width: `calc(100% + ${$t(f)})`,
6942
+ marginLeft: `-${$t(f)}`,
6943
+ [`& > .${Kt.item}`]: {
6944
+ paddingLeft: $t(f)
6945
+ }
6946
+ } : (u = a) != null && u.includes(c) ? {} : {
6947
+ width: "100%",
6948
+ marginLeft: 0,
6949
+ [`& > .${Kt.item}`]: {
6950
+ paddingLeft: 0
6951
+ }
6952
+ };
6953
+ });
6954
+ }
6955
+ return o;
6956
+ }
6957
+ function Ld(e, t, r = {}) {
6958
+ if (!e || e <= 0)
6959
+ return [];
6960
+ if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
6961
+ return [r[`spacing-xs-${String(e)}`]];
6962
+ const n = [];
6963
+ return t.forEach((o) => {
6964
+ const i = e[o];
6965
+ Number(i) > 0 && n.push(r[`spacing-${o}-${String(i)}`]);
6966
+ }), n;
6967
+ }
6968
+ const Wd = ir("div", {
6969
+ name: "MuiGrid",
6970
+ slot: "Root",
6971
+ overridesResolver: (e, t) => {
6972
+ const {
6973
+ ownerState: r
6974
+ } = e, {
6975
+ container: n,
6976
+ direction: o,
6977
+ item: i,
6978
+ spacing: a,
6979
+ wrap: s,
6980
+ zeroMinWidth: c,
6981
+ breakpoints: u
6982
+ } = r;
6983
+ let f = [];
6984
+ n && (f = Ld(a, u, t));
6985
+ const h = [];
6986
+ return u.forEach((m) => {
6987
+ const b = r[m];
6988
+ b && h.push(t[`grid-${m}-${String(b)}`]);
6989
+ }), [t.root, n && t.container, i && t.item, c && t.zeroMinWidth, ...f, o !== "row" && t[`direction-xs-${String(o)}`], s !== "wrap" && t[`wrap-xs-${String(s)}`], ...h];
6990
+ }
6991
+ })(({
6992
+ ownerState: e
6993
+ }) => M({
6994
+ boxSizing: "border-box"
6995
+ }, e.container && {
6996
+ display: "flex",
6997
+ flexWrap: "wrap",
6998
+ width: "100%"
6999
+ }, e.item && {
7000
+ margin: 0
7001
+ // For instance, it's useful when used with a `figure` element.
7002
+ }, e.zeroMinWidth && {
7003
+ minWidth: 0
7004
+ }, e.wrap !== "wrap" && {
7005
+ flexWrap: e.wrap
7006
+ }), Fd, Bd, zd, Dd);
7007
+ function Vd(e, t) {
7008
+ if (!e || e <= 0)
7009
+ return [];
7010
+ if (typeof e == "string" && !Number.isNaN(Number(e)) || typeof e == "number")
7011
+ return [`spacing-xs-${String(e)}`];
7012
+ const r = [];
7013
+ return t.forEach((n) => {
7014
+ const o = e[n];
7015
+ if (Number(o) > 0) {
7016
+ const i = `spacing-${n}-${String(o)}`;
7017
+ r.push(i);
7018
+ }
7019
+ }), r;
7020
+ }
7021
+ const Ud = (e) => {
7022
+ const {
7023
+ classes: t,
7024
+ container: r,
7025
+ direction: n,
7026
+ item: o,
7027
+ spacing: i,
7028
+ wrap: a,
7029
+ zeroMinWidth: s,
7030
+ breakpoints: c
7031
+ } = e;
7032
+ let u = [];
7033
+ r && (u = Vd(i, c));
7034
+ const f = [];
7035
+ c.forEach((m) => {
7036
+ const b = e[m];
7037
+ b && f.push(`grid-${m}-${String(b)}`);
7038
+ });
7039
+ const h = {
7040
+ root: ["root", r && "container", o && "item", s && "zeroMinWidth", ...u, n !== "row" && `direction-xs-${String(n)}`, a !== "wrap" && `wrap-xs-${String(a)}`, ...f]
7041
+ };
7042
+ return Xt(h, Ad, t);
7043
+ }, bt = /* @__PURE__ */ I.forwardRef(function(t, r) {
7044
+ const n = Zt({
7045
+ props: t,
7046
+ name: "MuiGrid"
7047
+ }), {
7048
+ breakpoints: o
7049
+ } = Un(), i = Wr(n), {
7050
+ className: a,
7051
+ columns: s,
7052
+ columnSpacing: c,
7053
+ component: u = "div",
7054
+ container: f = !1,
7055
+ direction: h = "row",
7056
+ item: m = !1,
7057
+ rowSpacing: b,
7058
+ spacing: x = 0,
7059
+ wrap: g = "wrap",
7060
+ zeroMinWidth: y = !1
7061
+ } = i, T = je(i, Nd), w = b || x, O = c || x, k = I.useContext(_n), p = f ? s || 12 : k, j = {}, P = M({}, T);
7062
+ o.keys.forEach((ue) => {
7063
+ T[ue] != null && (j[ue] = T[ue], delete P[ue]);
7064
+ });
7065
+ const fe = M({}, i, {
7066
+ columns: p,
7067
+ container: f,
7068
+ direction: h,
7069
+ item: m,
7070
+ rowSpacing: w,
7071
+ columnSpacing: O,
7072
+ wrap: g,
7073
+ zeroMinWidth: y,
7074
+ spacing: x
7075
+ }, j, {
7076
+ breakpoints: o.keys
7077
+ }), te = Ud(fe);
7078
+ return /* @__PURE__ */ v.jsx(_n.Provider, {
7079
+ value: p,
7080
+ children: /* @__PURE__ */ v.jsx(Wd, M({
7081
+ ownerState: fe,
7082
+ className: Jt(te.root, a),
7083
+ as: u,
7084
+ ref: r
7085
+ }, P))
7086
+ });
7087
+ });
7088
+ process.env.NODE_ENV !== "production" && (bt.propTypes = {
7089
+ // ┌────────────────────────────── Warning ──────────────────────────────┐
7090
+ // │ These PropTypes are generated from the TypeScript type definitions. │
7091
+ // │ To update them, edit the d.ts file and run `pnpm proptypes`. │
7092
+ // └─────────────────────────────────────────────────────────────────────┘
7093
+ /**
7094
+ * The content of the component.
7095
+ */
7096
+ children: l.node,
7097
+ /**
7098
+ * Override or extend the styles applied to the component.
7099
+ */
7100
+ classes: l.object,
7101
+ /**
7102
+ * @ignore
7103
+ */
7104
+ className: l.string,
7105
+ /**
7106
+ * The number of columns.
7107
+ * @default 12
7108
+ */
7109
+ columns: l.oneOfType([l.arrayOf(l.number), l.number, l.object]),
7110
+ /**
7111
+ * Defines the horizontal space between the type `item` components.
7112
+ * It overrides the value of the `spacing` prop.
7113
+ */
7114
+ columnSpacing: l.oneOfType([l.arrayOf(l.oneOfType([l.number, l.string])), l.number, l.object, l.string]),
7115
+ /**
7116
+ * The component used for the root node.
7117
+ * Either a string to use a HTML element or a component.
7118
+ */
7119
+ component: l.elementType,
7120
+ /**
7121
+ * If `true`, the component will have the flex *container* behavior.
7122
+ * You should be wrapping *items* with a *container*.
7123
+ * @default false
7124
+ */
7125
+ container: l.bool,
7126
+ /**
7127
+ * Defines the `flex-direction` style property.
7128
+ * It is applied for all screen sizes.
7129
+ * @default 'row'
7130
+ */
7131
+ direction: l.oneOfType([l.oneOf(["column-reverse", "column", "row-reverse", "row"]), l.arrayOf(l.oneOf(["column-reverse", "column", "row-reverse", "row"])), l.object]),
7132
+ /**
7133
+ * If `true`, the component will have the flex *item* behavior.
7134
+ * You should be wrapping *items* with a *container*.
7135
+ * @default false
7136
+ */
7137
+ item: l.bool,
7138
+ /**
7139
+ * If a number, it sets the number of columns the grid item uses.
7140
+ * It can't be greater than the total number of columns of the container (12 by default).
7141
+ * If 'auto', the grid item's width matches its content.
7142
+ * If false, the prop is ignored.
7143
+ * If true, the grid item's width grows to use the space available in the grid container.
7144
+ * The value is applied for the `lg` breakpoint and wider screens if not overridden.
7145
+ * @default false
7146
+ */
7147
+ lg: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
7148
+ /**
7149
+ * If a number, it sets the number of columns the grid item uses.
7150
+ * It can't be greater than the total number of columns of the container (12 by default).
7151
+ * If 'auto', the grid item's width matches its content.
7152
+ * If false, the prop is ignored.
7153
+ * If true, the grid item's width grows to use the space available in the grid container.
7154
+ * The value is applied for the `md` breakpoint and wider screens if not overridden.
7155
+ * @default false
7156
+ */
7157
+ md: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
7158
+ /**
7159
+ * Defines the vertical space between the type `item` components.
7160
+ * It overrides the value of the `spacing` prop.
7161
+ */
7162
+ rowSpacing: l.oneOfType([l.arrayOf(l.oneOfType([l.number, l.string])), l.number, l.object, l.string]),
7163
+ /**
7164
+ * If a number, it sets the number of columns the grid item uses.
7165
+ * It can't be greater than the total number of columns of the container (12 by default).
7166
+ * If 'auto', the grid item's width matches its content.
7167
+ * If false, the prop is ignored.
7168
+ * If true, the grid item's width grows to use the space available in the grid container.
7169
+ * The value is applied for the `sm` breakpoint and wider screens if not overridden.
7170
+ * @default false
7171
+ */
7172
+ sm: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
7173
+ /**
7174
+ * Defines the space between the type `item` components.
7175
+ * It can only be used on a type `container` component.
7176
+ * @default 0
7177
+ */
7178
+ spacing: l.oneOfType([l.arrayOf(l.oneOfType([l.number, l.string])), l.number, l.object, l.string]),
7179
+ /**
7180
+ * The system prop that allows defining system overrides as well as additional CSS styles.
7181
+ */
7182
+ sx: l.oneOfType([l.arrayOf(l.oneOfType([l.func, l.object, l.bool])), l.func, l.object]),
7183
+ /**
7184
+ * Defines the `flex-wrap` style property.
7185
+ * It's applied for all screen sizes.
7186
+ * @default 'wrap'
7187
+ */
7188
+ wrap: l.oneOf(["nowrap", "wrap-reverse", "wrap"]),
7189
+ /**
7190
+ * If a number, it sets the number of columns the grid item uses.
7191
+ * It can't be greater than the total number of columns of the container (12 by default).
7192
+ * If 'auto', the grid item's width matches its content.
7193
+ * If false, the prop is ignored.
7194
+ * If true, the grid item's width grows to use the space available in the grid container.
7195
+ * The value is applied for the `xl` breakpoint and wider screens if not overridden.
7196
+ * @default false
7197
+ */
7198
+ xl: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
7199
+ /**
7200
+ * If a number, it sets the number of columns the grid item uses.
7201
+ * It can't be greater than the total number of columns of the container (12 by default).
7202
+ * If 'auto', the grid item's width matches its content.
7203
+ * If false, the prop is ignored.
7204
+ * If true, the grid item's width grows to use the space available in the grid container.
7205
+ * The value is applied for all the screen sizes with the lowest priority.
7206
+ * @default false
7207
+ */
7208
+ xs: l.oneOfType([l.oneOf(["auto"]), l.number, l.bool]),
7209
+ /**
7210
+ * If `true`, it sets `min-width: 0` on the item.
7211
+ * Refer to the limitations section of the documentation to better understand the use case.
7212
+ * @default false
7213
+ */
7214
+ zeroMinWidth: l.bool
7215
+ });
7216
+ if (process.env.NODE_ENV !== "production") {
7217
+ const e = wi("Grid", bt);
7218
+ bt.propTypes = M({}, bt.propTypes, {
7219
+ direction: e("container"),
7220
+ lg: e("item"),
7221
+ md: e("item"),
7222
+ sm: e("item"),
7223
+ spacing: e("container"),
7224
+ wrap: e("container"),
7225
+ xs: e("item"),
7226
+ zeroMinWidth: e("item")
7227
+ });
7228
+ }
7229
+ function Gp({ Header: e, children: t, ...r }) {
7230
+ const { sx: n, ...o } = r || {};
7231
+ return v.jsxs(bt, { container: !0, children: [e, v.jsx(bt, { item: !0, container: !0, xs: 12, sx: {
7232
+ justifyContent: "center",
7233
+ alignContent: "flex-start",
7234
+ alignItems: "center",
7235
+ pt: 8,
7236
+ backgroundColor: S.neutral50,
7237
+ minHeight: "100vh",
7238
+ overflow: "auto",
7239
+ ...n
7240
+ }, "data-test-layout-details": "content-slot", ...o, children: v.jsx(bt, { item: !0, xs: 10, children: t }) })] });
7241
+ }
7242
+ class Gd {
7243
+ constructor() {
7244
+ sr(this, "BASE_ATTRIBUTE", 'data-test="ink-dialog"');
7245
+ }
7246
+ get element() {
7247
+ return cy.get(`[${this.BASE_ATTRIBUTE}]`);
7248
+ }
7249
+ get paper() {
7250
+ return this.element.find("[role=dialog]");
7251
+ }
7252
+ get primaryAction() {
7253
+ return this.paper.find('[data-test="ink-dialog-primary-action"]');
7254
+ }
7255
+ get secondaryAction() {
7256
+ return this.paper.find('[data-test="ink-dialog-secondary-action"]');
7257
+ }
7258
+ get cancelAction() {
7259
+ return this.paper.find('[data-test="ink-dialog-cancel-action"]');
7260
+ }
7261
+ // NOTE:
7262
+ // class SomeClass extends InkDialogPageObject {
7263
+ // get dialogTrigger() {
7264
+ // return cy.get('[data-test="_SPECIFIC_DIALOG_TRIGGER_"]');
7265
+ // }
7266
+ // ...
7267
+ // }
7268
+ get dialogTrigger() {
7269
+ return cy.get('[data-test="ink-dialog-trigger"]');
7270
+ }
7271
+ get closeTrigger() {
7272
+ return this.paper.find('[data-test="ink-dialog-close"]');
7273
+ }
7274
+ get title() {
7275
+ return this.paper.find('[data-test="ink-dialog-title"]');
7276
+ }
7277
+ isOpen() {
7278
+ cy.log("checking to see if dialog is open"), this.element.should("exist");
7279
+ }
7280
+ isClosed() {
7281
+ cy.log("checking to see if dialog is closed"), this.element.should("not.exist");
7282
+ }
7283
+ openDialog() {
7284
+ this.dialogTrigger.click();
7285
+ }
7286
+ closeDialog() {
7287
+ this.closeTrigger.click();
7288
+ }
7289
+ hasPrimaryAction(t) {
7290
+ this.primaryAction.should("have.text", t);
7291
+ }
7292
+ hasSecondaryAction(t) {
7293
+ this.secondaryAction.should("have.text", t);
7294
+ }
7295
+ hasCancelAction(t) {
7296
+ this.cancelAction.should("have.text", t);
7297
+ }
7298
+ hasTitle(t) {
7299
+ this.title.should("have.text", t);
7300
+ }
7301
+ }
7302
+ const qp = new Gd();
7303
+ class Ra {
7304
+ constructor(t) {
7305
+ sr(this, "baseAttribute", "data-test-select");
7306
+ sr(this, "name");
7307
+ this.name = t;
7308
+ }
7309
+ static create(t) {
7310
+ return new Ra(t);
7311
+ }
7312
+ get element() {
7313
+ return cy.get(`[${this.baseAttribute}-root=${this.name}]`);
7314
+ }
7315
+ get menuElement() {
7316
+ return cy.get(`[id=menu-${this.name}]`);
7317
+ }
7318
+ get label() {
7319
+ return this.element.find(`[${this.baseAttribute}-label]`);
7320
+ }
7321
+ get select() {
7322
+ return this.element.find(`[${this.baseAttribute}]`);
7323
+ }
7324
+ get input() {
7325
+ return this.element.find(`[${this.baseAttribute}-input]`);
7326
+ }
7327
+ get options() {
7328
+ return this.closeMenu(), this.openMenu(), this.menuElement.find(`[${this.baseAttribute}-menu-item]`);
7329
+ }
7330
+ option(t) {
7331
+ return this.closeMenu(), cy.get("body").click(100, 0), this.openMenu(), this.menuElement.find(`[${this.baseAttribute}-menu-item=${t}]`);
7332
+ }
7333
+ get helperText() {
7334
+ return this.element.find(`[${this.baseAttribute}-helper-text]`);
7335
+ }
7336
+ hasLabel(t) {
7337
+ return this.label.should("have.text", t);
7338
+ }
7339
+ hasDisplayValue(t) {
7340
+ return this.select.should("have.text", t);
7341
+ }
7342
+ hasValue(t) {
7343
+ return this.input.should("have.value", t);
7344
+ }
7345
+ hasOption(t, r, n) {
7346
+ const o = n !== void 0 ? this.options.eq(n) : this.option(r);
7347
+ o.should("have.text", t), o.should("have.attr", "data-value", r);
7348
+ }
7349
+ closeMenu() {
7350
+ cy.get("body").click(100, 0);
7351
+ }
7352
+ openMenu() {
7353
+ this.select.click();
7354
+ }
7355
+ }
7356
+ var Gn = {}, ln = {};
7357
+ const qd = /* @__PURE__ */ lt(Df);
7358
+ var ai;
7359
+ function Vr() {
7360
+ return ai || (ai = 1, function(e) {
7361
+ "use client";
7362
+ Object.defineProperty(e, "__esModule", {
7363
+ value: !0
7364
+ }), Object.defineProperty(e, "default", {
7365
+ enumerable: !0,
7366
+ get: function() {
7367
+ return t.createSvgIcon;
7368
+ }
7369
+ });
7370
+ var t = qd;
7371
+ }(ln)), ln;
7372
+ }
7373
+ var Yd = At;
7374
+ Object.defineProperty(Gn, "__esModule", {
7375
+ value: !0
7376
+ });
7377
+ var $a = Gn.default = void 0, Hd = Yd(Vr()), Kd = v;
7378
+ $a = Gn.default = (0, Hd.default)(/* @__PURE__ */ (0, Kd.jsx)("path", {
7379
+ d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2M9.29 16.29 5.7 12.7a.9959.9959 0 0 1 0-1.41c.39-.39 1.02-.39 1.41 0L10 14.17l6.88-6.88c.39-.39 1.02-.39 1.41 0 .39.39.39 1.02 0 1.41l-7.59 7.59c-.38.39-1.02.39-1.41 0"
7380
+ }), "CheckCircleRounded");
7381
+ var qn = {}, Xd = At;
7382
+ Object.defineProperty(qn, "__esModule", {
7383
+ value: !0
7384
+ });
7385
+ var ka = qn.default = void 0, Jd = Xd(Vr()), Zd = v;
7386
+ ka = qn.default = (0, Jd.default)(/* @__PURE__ */ (0, Zd.jsx)("path", {
7387
+ d: "M14.9 3H9.1c-.53 0-1.04.21-1.42.59l-4.1 4.1C3.21 8.06 3 8.57 3 9.1v5.8c0 .53.21 1.04.59 1.41l4.1 4.1c.37.38.88.59 1.41.59h5.8c.53 0 1.04-.21 1.41-.59l4.1-4.1c.38-.37.59-.88.59-1.41V9.1c0-.53-.21-1.04-.59-1.41l-4.1-4.1c-.37-.38-.88-.59-1.41-.59m.64 12.54c-.39.39-1.02.39-1.41 0L12 13.41l-2.12 2.12c-.39.39-1.02.39-1.41 0a.9959.9959 0 0 1 0-1.41L10.59 12 8.46 9.88a.9959.9959 0 0 1 0-1.41c.39-.39 1.02-.39 1.41 0L12 10.59l2.12-2.12c.39-.39 1.02-.39 1.41 0 .39.39.39 1.02 0 1.41L13.41 12l2.12 2.12c.4.39.4 1.03.01 1.42"
7388
+ }), "DangerousRounded");
7389
+ var Yn = {}, Qd = At;
7390
+ Object.defineProperty(Yn, "__esModule", {
7391
+ value: !0
7392
+ });
7393
+ var Ma = Yn.default = void 0, ep = Qd(Vr()), tp = v;
7394
+ Ma = Yn.default = (0, ep.default)(/* @__PURE__ */ (0, tp.jsx)("path", {
7395
+ d: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2m0 15c-.55 0-1-.45-1-1v-4c0-.55.45-1 1-1s1 .45 1 1v4c0 .55-.45 1-1 1m1-8h-2V7h2z"
7396
+ }), "InfoRounded");
7397
+ var Hn = {}, rp = At;
7398
+ Object.defineProperty(Hn, "__esModule", {
7399
+ value: !0
7400
+ });
7401
+ var Aa = Hn.default = void 0, np = rp(Vr()), op = v;
7402
+ Aa = Hn.default = (0, np.default)(/* @__PURE__ */ (0, op.jsx)("path", {
7403
+ d: "M12 5.99 19.53 19H4.47zM2.74 18c-.77 1.33.19 3 1.73 3h15.06c1.54 0 2.5-1.67 1.73-3L13.73 4.99c-.77-1.33-2.69-1.33-3.46 0zM11 11v2c0 .55.45 1 1 1s1-.45 1-1v-2c0-.55-.45-1-1-1s-1 .45-1 1m0 5h2v2h-2z"
7404
+ }), "WarningAmberRounded");
7405
+ const ip = {
7406
+ MuiAlert: {
7407
+ defaultProps: {
7408
+ iconMapping: {
7409
+ success: v.jsx($a, {}),
7410
+ error: v.jsx(ka, {}),
7411
+ info: v.jsx(Ma, {}),
7412
+ warning: v.jsx(Aa, {})
7413
+ }
7414
+ },
7415
+ variants: [
7416
+ {
7417
+ props: {
7418
+ variant: "snackbar"
7419
+ },
7420
+ style: {
7421
+ width: "100%"
7422
+ }
7423
+ }
7424
+ ],
7425
+ styleOverrides: {
7426
+ root: {
7427
+ "& .MuiAlert-action": {
7428
+ gap: "16px",
7429
+ // NOTE:
7430
+ // To ensure `onClose` and the `action` attributes are styled the same
7431
+ "> .MuiIconButton-root, > .MuiButton-root": {
7432
+ padding: "4px",
7433
+ color: "inherit"
7434
+ },
7435
+ "> .MuiButton-root": {
7436
+ fontSize: "13px",
7437
+ textTransform: "capitalize"
7438
+ }
7439
+ },
7440
+ "& .MuiAlert-message": {
7441
+ color: "black"
7442
+ }
7443
+ },
7444
+ snackbar: ({ theme: e, ownerState: t }) => ({
7445
+ color: "white",
7446
+ backgroundColor: e.palette.neutral900,
7447
+ "& .MuiAlert-message": {
7448
+ color: "white"
7449
+ },
7450
+ "& .MuiAlert-icon": {
7451
+ ...t.severity === "success" && {
7452
+ color: e.palette.success.light
7453
+ },
7454
+ ...t.severity === "error" && {
7455
+ color: e.palette.error.light
7456
+ },
7457
+ ...t.severity === "info" && {
7458
+ color: e.palette.info.light
7459
+ },
7460
+ ...t.severity === "warning" && {
7461
+ color: e.palette.warning.light
7462
+ }
7463
+ },
7464
+ "& .MuiAlert-action": {
7465
+ "> .MuiButton-root": {
7466
+ color: e.palette.blueA100
7467
+ }
7468
+ }
7469
+ })
7470
+ }
7471
+ }
7472
+ }, ap = {
7473
+ MuiAutocomplete: {
7474
+ defaultProps: {
7475
+ ChipProps: {
7476
+ size: "small",
7477
+ color: "primary"
7478
+ }
7479
+ },
7480
+ styleOverrides: {
7481
+ root: ({ theme: e }) => ({
7482
+ ".MuiChip-root": {
7483
+ margin: 0
7484
+ },
7485
+ '& .MuiAutocomplete-inputRoot[class*="Mui-disabled"]': {
7486
+ backgroundColor: e.palette.neutral300,
7487
+ cursor: "not-allowed"
7488
+ }
7489
+ }),
7490
+ option: ({ theme: e }) => ({
7491
+ "&.MuiAutocomplete-option.MuiAutocomplete-option": {
7492
+ "&.Mui-focused": {
7493
+ backgroundColor: e.palette.primary.selected
7494
+ },
7495
+ '&[aria-selected="true"]': {
7496
+ backgroundColor: e.palette.primary.selected
7497
+ }
7498
+ }
7499
+ }),
7500
+ inputRoot: ({ theme: e }) => ({
7501
+ "&.MuiInputBase-hiddenLabel": {
7502
+ padding: e.spacing(1, 1.5),
7503
+ "& .MuiAutocomplete-input": {
7504
+ padding: e.spacing(0)
7505
+ }
7506
+ },
7507
+ "&.MuiInputBase-hiddenLabel.MuiInputBase-sizeSmall": {
7508
+ paddingTop: e.spacing(0.5),
7509
+ paddingBottom: e.spacing(0.5),
7510
+ paddingLeft: e.spacing(1),
7511
+ "& .MuiAutocomplete-input": {
7512
+ padding: e.spacing(0)
7513
+ }
7514
+ },
7515
+ gap: e.spacing(1)
7516
+ }),
7517
+ paper: {
7518
+ padding: 0
7519
+ },
7520
+ listbox: {
7521
+ maxHeight: 400
7522
+ }
7523
+ }
7524
+ }
7525
+ }, sp = {
7526
+ MuiDialog: {
7527
+ defaultProps: {
7528
+ maxWidth: "xs",
7529
+ fullWidth: !0,
7530
+ scroll: "paper"
7531
+ },
7532
+ styleOverrides: {
7533
+ paper: {
7534
+ padding: 0
7535
+ }
7536
+ }
7537
+ },
7538
+ MuiDialogTitle: {
7539
+ defaultProps: {
7540
+ variant: "h6"
7541
+ },
7542
+ styleOverrides: {
7543
+ root: {
7544
+ fontWeight: 500
7545
+ }
7546
+ }
8197
7547
  },
8198
- info: {
8199
- main: me.A700,
8200
- dark: me[900],
8201
- light: me.A400,
8202
- contrastText: N.neutral00
7548
+ MuiDialogActions: {
7549
+ styleOverrides: {
7550
+ root: {
7551
+ padding: "16px"
7552
+ }
7553
+ }
7554
+ }
7555
+ }, cp = {
7556
+ MuiDrawer: {
7557
+ styleOverrides: {
7558
+ paper: {
7559
+ padding: 0
7560
+ }
7561
+ }
7562
+ }
7563
+ }, lp = {
7564
+ MuiStepper: {
7565
+ styleOverrides: {
7566
+ root: ({ theme: e }) => ({
7567
+ justifyContent: "center",
7568
+ gap: e.spacing(0.5)
7569
+ })
7570
+ }
8203
7571
  },
8204
- ai: {
8205
- main: Fe.A700,
8206
- dark: N.deepPurpleA800,
8207
- contrastText: N.neutral00
7572
+ MuiStep: {
7573
+ styleOverrides: {
7574
+ root: ({ theme: e, ownerState: t }) => ({
7575
+ padding: 0,
7576
+ whiteSpace: "nowrap",
7577
+ "> .MuiStepButton-root": {
7578
+ ...e.typography.body2,
7579
+ padding: "8px 20px",
7580
+ "&.MuiButtonBase-root": {
7581
+ boxSizing: "border-box",
7582
+ width: "unset",
7583
+ margin: 0,
7584
+ backgroundColor: "white",
7585
+ borderRadius: 100,
7586
+ border: `1px solid ${e.palette.neutral300}`,
7587
+ ...t.active && {
7588
+ border: `2px solid ${e.palette.primary.main}`,
7589
+ // NOTE:
7590
+ // These not selectors are useed to NOT inherit the active color if present. If you need to expand this see the other color variants of icons here: https://mui.com/material-ui/api/icon/
7591
+ "& .MuiIcon-root:not(.MuiIcon-colorSuccess):not(.MuiIcon-colorWarning):not(.MuiIcon-colorError)": {
7592
+ color: e.palette.primary.main
7593
+ }
7594
+ },
7595
+ "&:disabled, &:hover": {
7596
+ backgroundColor: e.palette.neutral200
7597
+ },
7598
+ "& .MuiStepLabel-labelContainer": {
7599
+ color: e.palette.text.primary,
7600
+ textTransform: "capitalize"
7601
+ }
7602
+ }
7603
+ }
7604
+ })
7605
+ }
8208
7606
  },
8209
- inProgress: {
8210
- main: ft.A700,
8211
- dark: N.greenA900,
8212
- contrastText: N.neutral00
7607
+ MuiStepConnector: {
7608
+ styleOverrides: {
7609
+ root: {
7610
+ flex: "0 1 28px"
7611
+ },
7612
+ line: {
7613
+ borderColor: "netural300",
7614
+ borderWidth: "1px"
7615
+ }
7616
+ }
8213
7617
  },
8214
- success: {
8215
- main: N.greenA900,
8216
- dark: ft[700],
8217
- light: N.greenA700,
8218
- contrastText: N.neutral00
7618
+ MuiStepButton: {
7619
+ styleOverrides: {
7620
+ root: ({ ownerState: e }) => ({
7621
+ ...!e.icon && {
7622
+ "& .MuiStepLabel-iconContainer": {
7623
+ display: "none"
7624
+ }
7625
+ }
7626
+ })
7627
+ }
7628
+ }
7629
+ };
7630
+ function On(e, t) {
7631
+ return On = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, n) {
7632
+ return r.__proto__ = n, r;
7633
+ }, On(e, t);
7634
+ }
7635
+ function up(e, t) {
7636
+ e.prototype = Object.create(t.prototype), e.prototype.constructor = e, On(e, t);
7637
+ }
7638
+ const si = {
7639
+ disabled: !1
7640
+ };
7641
+ var fp = process.env.NODE_ENV !== "production" ? l.oneOfType([l.number, l.shape({
7642
+ enter: l.number,
7643
+ exit: l.number,
7644
+ appear: l.number
7645
+ }).isRequired]) : null;
7646
+ process.env.NODE_ENV !== "production" && l.oneOfType([l.string, l.shape({
7647
+ enter: l.string,
7648
+ exit: l.string,
7649
+ active: l.string
7650
+ }), l.shape({
7651
+ enter: l.string,
7652
+ enterDone: l.string,
7653
+ enterActive: l.string,
7654
+ exit: l.string,
7655
+ exitDone: l.string,
7656
+ exitActive: l.string
7657
+ })]);
7658
+ const Pa = gt.createContext(null);
7659
+ var dp = function(t) {
7660
+ return t.scrollTop;
7661
+ }, Wt = "unmounted", mt = "exited", ht = "entering", Ot = "entered", wn = "exiting", ut = /* @__PURE__ */ function(e) {
7662
+ up(t, e);
7663
+ function t(n, o) {
7664
+ var i;
7665
+ i = e.call(this, n, o) || this;
7666
+ var a = o, s = a && !a.isMounting ? n.enter : n.appear, c;
7667
+ return i.appearStatus = null, n.in ? s ? (c = mt, i.appearStatus = ht) : c = Ot : n.unmountOnExit || n.mountOnEnter ? c = Wt : c = mt, i.state = {
7668
+ status: c
7669
+ }, i.nextCallback = null, i;
7670
+ }
7671
+ t.getDerivedStateFromProps = function(o, i) {
7672
+ var a = o.in;
7673
+ return a && i.status === Wt ? {
7674
+ status: mt
7675
+ } : null;
7676
+ };
7677
+ var r = t.prototype;
7678
+ return r.componentDidMount = function() {
7679
+ this.updateStatus(!0, this.appearStatus);
7680
+ }, r.componentDidUpdate = function(o) {
7681
+ var i = null;
7682
+ if (o !== this.props) {
7683
+ var a = this.state.status;
7684
+ this.props.in ? a !== ht && a !== Ot && (i = ht) : (a === ht || a === Ot) && (i = wn);
7685
+ }
7686
+ this.updateStatus(!1, i);
7687
+ }, r.componentWillUnmount = function() {
7688
+ this.cancelNextCallback();
7689
+ }, r.getTimeouts = function() {
7690
+ var o = this.props.timeout, i, a, s;
7691
+ return i = a = s = o, o != null && typeof o != "number" && (i = o.exit, a = o.enter, s = o.appear !== void 0 ? o.appear : a), {
7692
+ exit: i,
7693
+ enter: a,
7694
+ appear: s
7695
+ };
7696
+ }, r.updateStatus = function(o, i) {
7697
+ if (o === void 0 && (o = !1), i !== null)
7698
+ if (this.cancelNextCallback(), i === ht) {
7699
+ if (this.props.unmountOnExit || this.props.mountOnEnter) {
7700
+ var a = this.props.nodeRef ? this.props.nodeRef.current : cr.findDOMNode(this);
7701
+ a && dp(a);
7702
+ }
7703
+ this.performEnter(o);
7704
+ } else
7705
+ this.performExit();
7706
+ else this.props.unmountOnExit && this.state.status === mt && this.setState({
7707
+ status: Wt
7708
+ });
7709
+ }, r.performEnter = function(o) {
7710
+ var i = this, a = this.props.enter, s = this.context ? this.context.isMounting : o, c = this.props.nodeRef ? [s] : [cr.findDOMNode(this), s], u = c[0], f = c[1], h = this.getTimeouts(), m = s ? h.appear : h.enter;
7711
+ if (!o && !a || si.disabled) {
7712
+ this.safeSetState({
7713
+ status: Ot
7714
+ }, function() {
7715
+ i.props.onEntered(u);
7716
+ });
7717
+ return;
7718
+ }
7719
+ this.props.onEnter(u, f), this.safeSetState({
7720
+ status: ht
7721
+ }, function() {
7722
+ i.props.onEntering(u, f), i.onTransitionEnd(m, function() {
7723
+ i.safeSetState({
7724
+ status: Ot
7725
+ }, function() {
7726
+ i.props.onEntered(u, f);
7727
+ });
7728
+ });
7729
+ });
7730
+ }, r.performExit = function() {
7731
+ var o = this, i = this.props.exit, a = this.getTimeouts(), s = this.props.nodeRef ? void 0 : cr.findDOMNode(this);
7732
+ if (!i || si.disabled) {
7733
+ this.safeSetState({
7734
+ status: mt
7735
+ }, function() {
7736
+ o.props.onExited(s);
7737
+ });
7738
+ return;
7739
+ }
7740
+ this.props.onExit(s), this.safeSetState({
7741
+ status: wn
7742
+ }, function() {
7743
+ o.props.onExiting(s), o.onTransitionEnd(a.exit, function() {
7744
+ o.safeSetState({
7745
+ status: mt
7746
+ }, function() {
7747
+ o.props.onExited(s);
7748
+ });
7749
+ });
7750
+ });
7751
+ }, r.cancelNextCallback = function() {
7752
+ this.nextCallback !== null && (this.nextCallback.cancel(), this.nextCallback = null);
7753
+ }, r.safeSetState = function(o, i) {
7754
+ i = this.setNextCallback(i), this.setState(o, i);
7755
+ }, r.setNextCallback = function(o) {
7756
+ var i = this, a = !0;
7757
+ return this.nextCallback = function(s) {
7758
+ a && (a = !1, i.nextCallback = null, o(s));
7759
+ }, this.nextCallback.cancel = function() {
7760
+ a = !1;
7761
+ }, this.nextCallback;
7762
+ }, r.onTransitionEnd = function(o, i) {
7763
+ this.setNextCallback(i);
7764
+ var a = this.props.nodeRef ? this.props.nodeRef.current : cr.findDOMNode(this), s = o == null && !this.props.addEndListener;
7765
+ if (!a || s) {
7766
+ setTimeout(this.nextCallback, 0);
7767
+ return;
7768
+ }
7769
+ if (this.props.addEndListener) {
7770
+ var c = this.props.nodeRef ? [this.nextCallback] : [a, this.nextCallback], u = c[0], f = c[1];
7771
+ this.props.addEndListener(u, f);
7772
+ }
7773
+ o != null && setTimeout(this.nextCallback, o);
7774
+ }, r.render = function() {
7775
+ var o = this.state.status;
7776
+ if (o === Wt)
7777
+ return null;
7778
+ var i = this.props, a = i.children;
7779
+ i.in, i.mountOnEnter, i.unmountOnExit, i.appear, i.enter, i.exit, i.timeout, i.addEndListener, i.onEnter, i.onEntering, i.onEntered, i.onExit, i.onExiting, i.onExited, i.nodeRef;
7780
+ var s = je(i, ["children", "in", "mountOnEnter", "unmountOnExit", "appear", "enter", "exit", "timeout", "addEndListener", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "nodeRef"]);
7781
+ return (
7782
+ // allows for nested Transitions
7783
+ /* @__PURE__ */ gt.createElement(Pa.Provider, {
7784
+ value: null
7785
+ }, typeof a == "function" ? a(o, s) : gt.cloneElement(gt.Children.only(a), s))
7786
+ );
7787
+ }, t;
7788
+ }(gt.Component);
7789
+ ut.contextType = Pa;
7790
+ ut.propTypes = process.env.NODE_ENV !== "production" ? {
7791
+ /**
7792
+ * A React reference to DOM element that need to transition:
7793
+ * https://stackoverflow.com/a/51127130/4671932
7794
+ *
7795
+ * - When `nodeRef` prop is used, `node` is not passed to callback functions
7796
+ * (e.g. `onEnter`) because user already has direct access to the node.
7797
+ * - When changing `key` prop of `Transition` in a `TransitionGroup` a new
7798
+ * `nodeRef` need to be provided to `Transition` with changed `key` prop
7799
+ * (see
7800
+ * [test/CSSTransition-test.js](https://github.com/reactjs/react-transition-group/blob/13435f897b3ab71f6e19d724f145596f5910581c/test/CSSTransition-test.js#L362-L437)).
7801
+ */
7802
+ nodeRef: l.shape({
7803
+ current: typeof Element > "u" ? l.any : function(e, t, r, n, o, i) {
7804
+ var a = e[t];
7805
+ return l.instanceOf(a && "ownerDocument" in a ? a.ownerDocument.defaultView.Element : Element)(e, t, r, n, o, i);
7806
+ }
7807
+ }),
7808
+ /**
7809
+ * A `function` child can be used instead of a React element. This function is
7810
+ * called with the current transition status (`'entering'`, `'entered'`,
7811
+ * `'exiting'`, `'exited'`), which can be used to apply context
7812
+ * specific props to a component.
7813
+ *
7814
+ * ```jsx
7815
+ * <Transition in={this.state.in} timeout={150}>
7816
+ * {state => (
7817
+ * <MyComponent className={`fade fade-${state}`} />
7818
+ * )}
7819
+ * </Transition>
7820
+ * ```
7821
+ */
7822
+ children: l.oneOfType([l.func.isRequired, l.element.isRequired]).isRequired,
7823
+ /**
7824
+ * Show the component; triggers the enter or exit states
7825
+ */
7826
+ in: l.bool,
7827
+ /**
7828
+ * By default the child component is mounted immediately along with
7829
+ * the parent `Transition` component. If you want to "lazy mount" the component on the
7830
+ * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
7831
+ * mounted, even on "exited", unless you also specify `unmountOnExit`.
7832
+ */
7833
+ mountOnEnter: l.bool,
7834
+ /**
7835
+ * By default the child component stays mounted after it reaches the `'exited'` state.
7836
+ * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
7837
+ */
7838
+ unmountOnExit: l.bool,
7839
+ /**
7840
+ * By default the child component does not perform the enter transition when
7841
+ * it first mounts, regardless of the value of `in`. If you want this
7842
+ * behavior, set both `appear` and `in` to `true`.
7843
+ *
7844
+ * > **Note**: there are no special appear states like `appearing`/`appeared`, this prop
7845
+ * > only adds an additional enter transition. However, in the
7846
+ * > `<CSSTransition>` component that first enter transition does result in
7847
+ * > additional `.appear-*` classes, that way you can choose to style it
7848
+ * > differently.
7849
+ */
7850
+ appear: l.bool,
7851
+ /**
7852
+ * Enable or disable enter transitions.
7853
+ */
7854
+ enter: l.bool,
7855
+ /**
7856
+ * Enable or disable exit transitions.
7857
+ */
7858
+ exit: l.bool,
7859
+ /**
7860
+ * The duration of the transition, in milliseconds.
7861
+ * Required unless `addEndListener` is provided.
7862
+ *
7863
+ * You may specify a single timeout for all transitions:
7864
+ *
7865
+ * ```jsx
7866
+ * timeout={500}
7867
+ * ```
7868
+ *
7869
+ * or individually:
7870
+ *
7871
+ * ```jsx
7872
+ * timeout={{
7873
+ * appear: 500,
7874
+ * enter: 300,
7875
+ * exit: 500,
7876
+ * }}
7877
+ * ```
7878
+ *
7879
+ * - `appear` defaults to the value of `enter`
7880
+ * - `enter` defaults to `0`
7881
+ * - `exit` defaults to `0`
7882
+ *
7883
+ * @type {number | { enter?: number, exit?: number, appear?: number }}
7884
+ */
7885
+ timeout: function(t) {
7886
+ var r = fp;
7887
+ t.addEndListener || (r = r.isRequired);
7888
+ for (var n = arguments.length, o = new Array(n > 1 ? n - 1 : 0), i = 1; i < n; i++)
7889
+ o[i - 1] = arguments[i];
7890
+ return r.apply(void 0, [t].concat(o));
8219
7891
  },
8220
- action: {
8221
- active: Oe[700],
8222
- hover: We(Oe[700], 0.04),
8223
- selected: We(Oe[700], 0.08),
8224
- focus: We(Oe[700], 0.12),
8225
- disabledBackground: Oe[200],
8226
- disabled: Oe[700]
7892
+ /**
7893
+ * Add a custom transition end trigger. Called with the transitioning
7894
+ * DOM node and a `done` callback. Allows for more fine grained transition end
7895
+ * logic. Timeouts are still used as a fallback if provided.
7896
+ *
7897
+ * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7898
+ *
7899
+ * ```jsx
7900
+ * addEndListener={(node, done) => {
7901
+ * // use the css transitionend event to mark the finish of a transition
7902
+ * node.addEventListener('transitionend', done, false);
7903
+ * }}
7904
+ * ```
7905
+ */
7906
+ addEndListener: l.func,
7907
+ /**
7908
+ * Callback fired before the "entering" status is applied. An extra parameter
7909
+ * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
7910
+ *
7911
+ * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7912
+ *
7913
+ * @type Function(node: HtmlElement, isAppearing: bool) -> void
7914
+ */
7915
+ onEnter: l.func,
7916
+ /**
7917
+ * Callback fired after the "entering" status is applied. An extra parameter
7918
+ * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
7919
+ *
7920
+ * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7921
+ *
7922
+ * @type Function(node: HtmlElement, isAppearing: bool)
7923
+ */
7924
+ onEntering: l.func,
7925
+ /**
7926
+ * Callback fired after the "entered" status is applied. An extra parameter
7927
+ * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
7928
+ *
7929
+ * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7930
+ *
7931
+ * @type Function(node: HtmlElement, isAppearing: bool) -> void
7932
+ */
7933
+ onEntered: l.func,
7934
+ /**
7935
+ * Callback fired before the "exiting" status is applied.
7936
+ *
7937
+ * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7938
+ *
7939
+ * @type Function(node: HtmlElement) -> void
7940
+ */
7941
+ onExit: l.func,
7942
+ /**
7943
+ * Callback fired after the "exiting" status is applied.
7944
+ *
7945
+ * **Note**: when `nodeRef` prop is passed, `node` is not passed.
7946
+ *
7947
+ * @type Function(node: HtmlElement) -> void
7948
+ */
7949
+ onExiting: l.func,
7950
+ /**
7951
+ * Callback fired after the "exited" status is applied.
7952
+ *
7953
+ * **Note**: when `nodeRef` prop is passed, `node` is not passed
7954
+ *
7955
+ * @type Function(node: HtmlElement) -> void
7956
+ */
7957
+ onExited: l.func
7958
+ } : {};
7959
+ function _t() {
7960
+ }
7961
+ ut.defaultProps = {
7962
+ in: !1,
7963
+ mountOnEnter: !1,
7964
+ unmountOnExit: !1,
7965
+ appear: !1,
7966
+ enter: !0,
7967
+ exit: !0,
7968
+ onEnter: _t,
7969
+ onEntering: _t,
7970
+ onEntered: _t,
7971
+ onExit: _t,
7972
+ onExiting: _t,
7973
+ onExited: _t
7974
+ };
7975
+ ut.UNMOUNTED = Wt;
7976
+ ut.EXITED = mt;
7977
+ ut.ENTERING = ht;
7978
+ ut.ENTERED = Ot;
7979
+ ut.EXITING = wn;
7980
+ const pp = (e) => e.scrollTop;
7981
+ function ci(e, t) {
7982
+ var r, n;
7983
+ const {
7984
+ timeout: o,
7985
+ easing: i,
7986
+ style: a = {}
7987
+ } = e;
7988
+ return {
7989
+ duration: (r = a.transitionDuration) != null ? r : typeof o == "number" ? o : o[t.mode] || 0,
7990
+ easing: (n = a.transitionTimingFunction) != null ? n : typeof i == "object" ? i[t.mode] : i,
7991
+ delay: a.transitionDelay
7992
+ };
7993
+ }
7994
+ const mp = ["addEndListener", "appear", "children", "container", "direction", "easing", "in", "onEnter", "onEntered", "onEntering", "onExit", "onExited", "onExiting", "style", "timeout", "TransitionComponent"];
7995
+ function hp(e, t, r) {
7996
+ const n = t.getBoundingClientRect(), o = r && r.getBoundingClientRect(), i = Mn(t);
7997
+ let a;
7998
+ if (t.fakeTransform)
7999
+ a = t.fakeTransform;
8000
+ else {
8001
+ const u = i.getComputedStyle(t);
8002
+ a = u.getPropertyValue("-webkit-transform") || u.getPropertyValue("transform");
8003
+ }
8004
+ let s = 0, c = 0;
8005
+ if (a && a !== "none" && typeof a == "string") {
8006
+ const u = a.split("(")[1].split(")")[0].split(",");
8007
+ s = parseInt(u[4], 10), c = parseInt(u[5], 10);
8008
+ }
8009
+ return e === "left" ? o ? `translateX(${o.right + s - n.left}px)` : `translateX(${i.innerWidth + s - n.left}px)` : e === "right" ? o ? `translateX(-${n.right - o.left - s}px)` : `translateX(-${n.left + n.width - s}px)` : e === "up" ? o ? `translateY(${o.bottom + c - n.top}px)` : `translateY(${i.innerHeight + c - n.top}px)` : o ? `translateY(-${n.top - o.top + n.height - c}px)` : `translateY(-${n.top + n.height - c}px)`;
8010
+ }
8011
+ function ja(e) {
8012
+ return typeof e == "function" ? e() : e;
8013
+ }
8014
+ function mr(e, t, r) {
8015
+ const n = ja(r), o = hp(e, t, n);
8016
+ o && (t.style.webkitTransform = o, t.style.transform = o);
8017
+ }
8018
+ const Ia = /* @__PURE__ */ I.forwardRef(function(t, r) {
8019
+ const n = Un(), o = {
8020
+ enter: n.transitions.easing.easeOut,
8021
+ exit: n.transitions.easing.sharp
8022
+ }, i = {
8023
+ enter: n.transitions.duration.enteringScreen,
8024
+ exit: n.transitions.duration.leavingScreen
8025
+ }, {
8026
+ addEndListener: a,
8027
+ appear: s = !0,
8028
+ children: c,
8029
+ container: u,
8030
+ direction: f = "down",
8031
+ easing: h = o,
8032
+ in: m,
8033
+ onEnter: b,
8034
+ onEntered: x,
8035
+ onEntering: g,
8036
+ onExit: y,
8037
+ onExited: T,
8038
+ onExiting: w,
8039
+ style: O,
8040
+ timeout: k = i,
8041
+ // eslint-disable-next-line react/prop-types
8042
+ TransitionComponent: p = ut
8043
+ } = t, j = je(t, mp), P = I.useRef(null), fe = ki(c.ref, P, r), te = (z) => (he) => {
8044
+ z && (he === void 0 ? z(P.current) : z(P.current, he));
8045
+ }, ue = te((z, he) => {
8046
+ mr(f, z, u), pp(z), b && b(z, he);
8047
+ }), V = te((z, he) => {
8048
+ const C = ci({
8049
+ timeout: k,
8050
+ style: O,
8051
+ easing: h
8052
+ }, {
8053
+ mode: "enter"
8054
+ });
8055
+ z.style.webkitTransition = n.transitions.create("-webkit-transform", M({}, C)), z.style.transition = n.transitions.create("transform", M({}, C)), z.style.webkitTransform = "none", z.style.transform = "none", g && g(z, he);
8056
+ }), X = te(x), Z = te(w), re = te((z) => {
8057
+ const he = ci({
8058
+ timeout: k,
8059
+ style: O,
8060
+ easing: h
8061
+ }, {
8062
+ mode: "exit"
8063
+ });
8064
+ z.style.webkitTransition = n.transitions.create("-webkit-transform", he), z.style.transition = n.transitions.create("transform", he), mr(f, z, u), y && y(z);
8065
+ }), Re = te((z) => {
8066
+ z.style.webkitTransition = "", z.style.transition = "", T && T(z);
8067
+ }), ve = (z) => {
8068
+ a && a(P.current, z);
8069
+ }, Ae = I.useCallback(() => {
8070
+ P.current && mr(f, P.current, u);
8071
+ }, [f, u]);
8072
+ return I.useEffect(() => {
8073
+ if (m || f === "down" || f === "right")
8074
+ return;
8075
+ const z = _i(() => {
8076
+ P.current && mr(f, P.current, u);
8077
+ }), he = Mn(P.current);
8078
+ return he.addEventListener("resize", z), () => {
8079
+ z.clear(), he.removeEventListener("resize", z);
8080
+ };
8081
+ }, [f, m, u]), I.useEffect(() => {
8082
+ m || Ae();
8083
+ }, [m, Ae]), /* @__PURE__ */ v.jsx(p, M({
8084
+ nodeRef: P,
8085
+ onEnter: ue,
8086
+ onEntered: X,
8087
+ onEntering: V,
8088
+ onExit: re,
8089
+ onExited: Re,
8090
+ onExiting: Z,
8091
+ addEndListener: ve,
8092
+ appear: s,
8093
+ in: m,
8094
+ timeout: k
8095
+ }, j, {
8096
+ children: (z, he) => /* @__PURE__ */ I.cloneElement(c, M({
8097
+ ref: fe,
8098
+ style: M({
8099
+ visibility: z === "exited" && !m ? "hidden" : void 0
8100
+ }, O, c.props.style)
8101
+ }, he))
8102
+ }));
8103
+ });
8104
+ process.env.NODE_ENV !== "production" && (Ia.propTypes = {
8105
+ // ┌────────────────────────────── Warning ──────────────────────────────┐
8106
+ // │ These PropTypes are generated from the TypeScript type definitions. │
8107
+ // │ To update them, edit the d.ts file and run `pnpm proptypes`. │
8108
+ // └─────────────────────────────────────────────────────────────────────┘
8109
+ /**
8110
+ * Add a custom transition end trigger. Called with the transitioning DOM
8111
+ * node and a done callback. Allows for more fine grained transition end
8112
+ * logic. Note: Timeouts are still used as a fallback if provided.
8113
+ */
8114
+ addEndListener: l.func,
8115
+ /**
8116
+ * Perform the enter transition when it first mounts if `in` is also `true`.
8117
+ * Set this to `false` to disable this behavior.
8118
+ * @default true
8119
+ */
8120
+ appear: l.bool,
8121
+ /**
8122
+ * A single child content element.
8123
+ */
8124
+ children: Ei.isRequired,
8125
+ /**
8126
+ * An HTML element, or a function that returns one.
8127
+ * It's used to set the container the Slide is transitioning from.
8128
+ */
8129
+ container: wr(l.oneOfType([Xs, l.func]), (e) => {
8130
+ if (e.open) {
8131
+ const t = ja(e.container);
8132
+ if (t && t.nodeType === 1) {
8133
+ const r = t.getBoundingClientRect();
8134
+ if (process.env.NODE_ENV !== "test" && r.top === 0 && r.left === 0 && r.right === 0 && r.bottom === 0)
8135
+ return new Error(["MUI: The `container` prop provided to the component is invalid.", "The anchor element should be part of the document layout.", "Make sure the element is present in the document or that it's not display none."].join(`
8136
+ `));
8137
+ } else if (!t || typeof t.getBoundingClientRect != "function" || t.contextElement != null && t.contextElement.nodeType !== 1)
8138
+ return new Error(["MUI: The `container` prop provided to the component is invalid.", "It should be an HTML element instance."].join(`
8139
+ `));
8140
+ }
8141
+ return null;
8142
+ }),
8143
+ /**
8144
+ * Direction the child node will enter from.
8145
+ * @default 'down'
8146
+ */
8147
+ direction: l.oneOf(["down", "left", "right", "up"]),
8148
+ /**
8149
+ * The transition timing function.
8150
+ * You may specify a single easing or a object containing enter and exit values.
8151
+ * @default {
8152
+ * enter: theme.transitions.easing.easeOut,
8153
+ * exit: theme.transitions.easing.sharp,
8154
+ * }
8155
+ */
8156
+ easing: l.oneOfType([l.shape({
8157
+ enter: l.string,
8158
+ exit: l.string
8159
+ }), l.string]),
8160
+ /**
8161
+ * If `true`, the component will transition in.
8162
+ */
8163
+ in: l.bool,
8164
+ /**
8165
+ * @ignore
8166
+ */
8167
+ onEnter: l.func,
8168
+ /**
8169
+ * @ignore
8170
+ */
8171
+ onEntered: l.func,
8172
+ /**
8173
+ * @ignore
8174
+ */
8175
+ onEntering: l.func,
8176
+ /**
8177
+ * @ignore
8178
+ */
8179
+ onExit: l.func,
8180
+ /**
8181
+ * @ignore
8182
+ */
8183
+ onExited: l.func,
8184
+ /**
8185
+ * @ignore
8186
+ */
8187
+ onExiting: l.func,
8188
+ /**
8189
+ * @ignore
8190
+ */
8191
+ style: l.object,
8192
+ /**
8193
+ * The duration for the transition, in milliseconds.
8194
+ * You may specify a single timeout for all transitions, or individually with an object.
8195
+ * @default {
8196
+ * enter: theme.transitions.duration.enteringScreen,
8197
+ * exit: theme.transitions.duration.leavingScreen,
8198
+ * }
8199
+ */
8200
+ timeout: l.oneOfType([l.number, l.shape({
8201
+ appear: l.number,
8202
+ enter: l.number,
8203
+ exit: l.number
8204
+ })])
8205
+ });
8206
+ const gp = {
8207
+ MuiSnackbar: {
8208
+ defaultProps: {
8209
+ anchorOrigin: {
8210
+ horizontal: "center",
8211
+ vertical: "bottom"
8212
+ },
8213
+ TransitionComponent: Ia
8214
+ }
8215
+ }
8216
+ }, yp = {
8217
+ MuiTypography: {
8218
+ styleOverrides: {
8219
+ root: ({ ownerState: e }) => ({
8220
+ // bold weight
8221
+ ...(e.component === "strong" || e.component === "b") && {
8222
+ fontWeight: 600
8223
+ }
8224
+ }),
8225
+ overline: ({ theme: e }) => ({
8226
+ color: e.palette.text.secondary
8227
+ })
8228
+ }
8227
8229
  }
8228
8230
  }, vp = {
8229
8231
  MuiCard: {